@happyvertical/smrt-facts 0.30.0

package/dist/index.d.ts

@@ -0,0 +1,781 @@
+import { PromptConfigOverrideInput } from '@happyvertical/smrt-prompts';
+import { PromptDefinition } from '@happyvertical/smrt-prompts';
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { SmrtJunction } from '@happyvertical/smrt-core';
+import { SmrtObject } from '@happyvertical/smrt-core';
+import { SmrtObjectOptions } from '@happyvertical/smrt-core';
+
+/**
+ * Utility functions for @happyvertical/smrt-facts
+ */
+/**
+ * Calculate confidence score for a fact based on multiple signals.
+ *
+ * Formula (v1, simple weighted):
+ *   base = 0.5
+ *   + min(sourceCount/10, 0.3)          source volume boost
+ *   + avgSourceCredibility * 0.2         credibility boost
+ *   + max(0, 0.1 - days*0.01)           recency boost (decays over 10 days)
+ *   + corroborationScore * 0.1           agreement boost
+ *   = clamped to [0, 1]
+ */
+export declare function calculateConfidence(params: {
+    sourceCount: number;
+    avgSourceCredibility?: number;
+    daysSinceLastSource?: number;
+    corroborationScore?: number;
+}): number;
+
+export declare function createFactEvidenceKey(input: Pick<FactEvidenceOptions, 'sourceKind' | 'sourceId' | 'sourceUrl' | 'locator' | 'quote'>): string;
+
+/**
+ * Entity briefing - summary of all facts about an entity
+ */
+export declare interface EntityBriefing {
+    entityType: string;
+    entityId: string;
+    facts: Fact[];
+    totalCount: number;
+    byType: Record<string, number>;
+    byStatus: Record<string, number>;
+}
+
+/**
+ * How a fact evolved from its predecessor in the evolution chain.
+ */
+export declare type EvolutionType = 'original' | 'correction' | 'refinement' | 'contradiction' | 'extension' | 'merge';
+
+export declare class Fact extends SmrtObject {
+    textRefined: string;
+    textRaw: string;
+    type: string;
+    status: string;
+    domain: string;
+    /**
+     * Self-referencing pointer to the predecessor fact in an evolution chain.
+     *
+     * This is NOT a structural hierarchy edge — Fact does not extend
+     * SmrtHierarchical. The chain represents knowledge evolution: an original
+     * fact, then corrections, refinements, contradictions, or extensions of
+     * that fact. See `evolutionType` for the kind of step.
+     */
+    previousFactId: string;
+    evolutionType: string;
+    sourceCount: number;
+    confidence: number;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactOptions);
+    getMetadata(): FactMetadata;
+    setMetadata(data: FactMetadata): void;
+    updateMetadata(updates: Partial<FactMetadata>): void;
+    getType(): FactType;
+    getStatus(): FactStatus;
+    getEvolutionType(): EvolutionType;
+    isActive(): boolean;
+    isSuperseded(): boolean;
+    /**
+     * Whether this fact has a predecessor in the evolution chain.
+     *
+     * Returns false for the framework default (`''`) and for any nullish
+     * value — defensive against rows whose `previous_fact_id` column is
+     * NULL (e.g. after a migration that left root facts un-backfilled).
+     */
+    hasPredecessor(): boolean;
+    /**
+     * Get the predecessor fact (the prior version in the evolution chain).
+     */
+    getPredecessor(): Promise<Fact | null>;
+    /**
+     * Get successor facts (facts that evolved directly from this one).
+     */
+    getSuccessors(): Promise<Fact[]>;
+    /**
+     * Get all sources for this fact
+     */
+    getSources(): Promise<FactSource[]>;
+    /**
+     * Get all subjects linked to this fact
+     */
+    getSubjects(): Promise<FactSubject[]>;
+}
+
+export declare interface FactClaimSupportAssessment {
+    status: FactClaimSupportStatus;
+    matchedFactIds: string[];
+    matchedEvidenceIds: string[];
+    rationale: string;
+    confidence?: number;
+}
+
+export declare interface FactClaimSupportCandidate {
+    id?: string | null;
+    statement: string;
+    evidence?: Array<{
+        id?: string | null;
+        status?: FactEvidenceStatus | null;
+        quote?: string | null;
+        sourceTitle?: string | null;
+        sourceUrl?: string | null;
+        locator?: string | null;
+    }>;
+}
+
+export declare interface FactClaimSupportOptions {
+    tenantId?: string | null;
+    promptOverride?: PromptConfigOverrideInput;
+}
+
+export declare type FactClaimSupportStatus = 'supported' | 'unsupported' | 'contradicted' | 'needs_review';
+
+export declare class FactCollection extends SmrtCollection<Fact> {
+    static readonly _itemClass: typeof Fact;
+    /**
+     * Get all active facts
+     */
+    getActive(): Promise<Fact[]>;
+    /**
+     * Get all pending facts
+     */
+    getPending(): Promise<Fact[]>;
+    /**
+     * Get facts by type
+     */
+    getByType(type: FactType): Promise<Fact[]>;
+    /**
+     * Get facts by domain
+     */
+    getByDomain(domain: string): Promise<Fact[]>;
+    /**
+     * Get facts by status
+     */
+    getByStatus(status: FactStatus): Promise<Fact[]>;
+    /**
+     * Get successor facts for a given predecessor (facts that evolved
+     * directly from `previousFactId`).
+     */
+    getSuccessors(previousFactId: string): Promise<Fact[]>;
+    /**
+     * Find all facts belonging to a specific tenant
+     */
+    findByTenant(tenantId: string): Promise<Fact[]>;
+    /**
+     * Find all global (tenant-less) facts
+     */
+    findGlobal(): Promise<Fact[]>;
+    /**
+     * Find facts for a tenant including global facts
+     */
+    findWithGlobals(tenantId: string): Promise<Fact[]>;
+    /**
+     * Browse active facts for editorial association.
+     * Uses semantic search when a query is provided and falls back to text filtering
+     * if embeddings are unavailable.
+     */
+    browseCatalog(query?: string, options?: {
+        tenantId?: string | null;
+        limit?: number;
+        offset?: number;
+        minSimilarity?: number;
+        includeSuperseded?: boolean;
+        latestOnly?: boolean;
+    }): Promise<Fact[]>;
+    /**
+     * Get all facts linked to a content item.
+     */
+    getForContent(contentId: string, options?: {
+        relationship?: FactContentRelationship;
+        includeSuperseded?: boolean;
+        latestOnly?: boolean;
+    }): Promise<Fact[]>;
+    /**
+     * Reconcile raw input against existing facts using semantic search + AI.
+     * Determines whether to create, merge, or branch.
+     *
+     * Algorithm:
+     * 1. semanticSearch(rawInput) against existing facts
+     * 2. Decision:
+     *    - No match above conflictThreshold (0.60) -> CREATE new fact
+     *    - Top match >= similarityThreshold (0.85) -> MERGE (add source, bump sourceCount)
+     *    - Ambiguous zone (0.60-0.85) -> AI disambiguation via this.ai.message()
+     *      - AI says "merge" -> MERGE
+     *      - AI says "branch" -> BRANCH (new fact as successor, predecessor marked superseded)
+     * 3. Record FactSource if source metadata provided
+     * 4. Return { action, fact, source?, similarity?, matchedFact? }
+     */
+    reconcile(options: ReconcileOptions): Promise<ReconcileResult>;
+    /**
+     * Extract atomic factual statements from unstructured source text using AI.
+     *
+     * This method is intentionally non-persistent: callers can review, reconcile,
+     * link, or discard the returned candidates according to their app workflow.
+     */
+    extractCandidatesFromText(text: string, options?: FactExtractionOptions): Promise<FactExtractionCandidate[]>;
+    /**
+     * Extract material factual claims made by an article.
+     *
+     * This is intentionally separate from source extraction: source extraction
+     * finds evidence-backed facts, while claim extraction finds statements the
+     * draft itself needs to justify.
+     */
+    extractArticleClaims(text: string, options?: FactExtractionOptions): Promise<FactExtractionCandidate[]>;
+    /**
+     * Classify whether a claim is supported by candidate facts/evidence.
+     */
+    assessClaimSupport(claim: string, candidateFacts: FactClaimSupportCandidate[], options?: FactClaimSupportOptions): Promise<FactClaimSupportAssessment>;
+    /**
+     * Use AI to determine whether new input should be merged with
+     * or branched from an existing fact.
+     */
+    private _disambiguateWithAI;
+    /**
+     * Create a branched fact from an existing predecessor.
+     *
+     * For 'correction' and 'contradiction' evolution types, the
+     * predecessor is marked as superseded.
+     *
+     * @param previousFactId ID of the predecessor fact this branches from.
+     * @param data Partial fact options for the new successor.
+     * @param evolutionType How the successor relates to the predecessor.
+     */
+    branch(previousFactId: string, data: Partial<FactOptions>, evolutionType?: EvolutionType): Promise<Fact>;
+    /**
+     * Walk up the evolution chain via previousFactId, returning the
+     * predecessors followed by the current fact in order.
+     *
+     * @returns Array ordered from root (original) → current fact.
+     */
+    getEvolutionChain(factId: string): Promise<Fact[]>;
+    /**
+     * Walk down successors to find the latest (highest confidence) leaf.
+     * At each level, picks the successor with the highest confidence score.
+     */
+    getLatestInChain(factId: string): Promise<Fact>;
+    /**
+     * Find the root of the chain via `getEvolutionChain`, then collect every
+     * successor iteratively via BFS (queue-based, with a `visited` set for
+     * cycle protection). Returns the full tree as a flat array in BFS
+     * order — root first, then each level of successors.
+     */
+    getEvolutionTree(factId: string): Promise<Fact[]>;
+    /**
+     * Recalculate confidence score for a fact based on its sources.
+     * Uses calculateConfidence from utils.ts with data from FactSourceCollection.
+     */
+    recalculateConfidence(factId: string): Promise<number>;
+    /**
+     * Get a briefing of all facts related to a given entity.
+     * Finds all FactSubject links for the entity, loads corresponding facts,
+     * and returns summary statistics.
+     */
+    getEntityBriefing(entityType: string, entityId: string): Promise<EntityBriefing>;
+}
+
+export declare class FactContent extends SmrtObject {
+    factId: string;
+    contentId: string;
+    relationship: string;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactContentOptions);
+    /**
+     * Get the relationship type as a typed value
+     */
+    getRelationship(): FactContentRelationship;
+    /**
+     * Get metadata as parsed object
+     */
+    getMetadata(): Record<string, any>;
+    /**
+     * Set metadata from object
+     */
+    setMetadata(data: Record<string, any>): void;
+    /**
+     * Update metadata by merging with existing values
+     */
+    updateMetadata(updates: Record<string, any>): void;
+    /**
+     * Get the fact this content link belongs to
+     */
+    getFact(): Promise<Fact | null>;
+}
+
+export declare class FactContentCollection extends SmrtJunction<FactContent> {
+    static readonly _itemClass: typeof FactContent;
+    protected leftField: string;
+    protected rightField: string;
+    protected sortField: string | null;
+    protected positionField: string | null;
+    findByTenant(tenantId: string): Promise<FactContent[]>;
+    findGlobal(): Promise<FactContent[]>;
+    findWithGlobals(tenantId: string): Promise<FactContent[]>;
+}
+
+/**
+ * Options for creating a FactContent join
+ */
+export declare interface FactContentOptions extends SmrtObjectOptions {
+    id?: string;
+    factId?: string;
+    contentId?: string;
+    relationship?: FactContentRelationship;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+/**
+ * Relationship between a fact and content
+ */
+export declare type FactContentRelationship = 'extracted_from' | 'referenced_in' | 'supports' | 'contradicts' | 'related';
+
+export declare class FactEvidence extends SmrtObject {
+    factId: string;
+    evidenceKey: string;
+    status: FactEvidenceStatus;
+    sourceKind: string;
+    sourceId: string;
+    sourceUrl: string;
+    sourceTitle: string;
+    quote: string;
+    locator: string;
+    extractionMethod: string;
+    confidence: number;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactEvidenceOptions);
+    getMetadata(): Record<string, any>;
+    setMetadata(data: Record<string, any>): void;
+    updateMetadata(updates: Record<string, any>): void;
+}
+
+export declare class FactEvidenceCollection extends SmrtCollection<FactEvidence> {
+    static readonly _itemClass: typeof FactEvidence;
+    getForFact(factId: string): Promise<FactEvidence[]>;
+    getForSource(sourceKind: string, sourceId: string): Promise<FactEvidence[]>;
+    getForSources(sources: Array<{
+        sourceKind: string;
+        sourceId: string;
+    }>): Promise<FactEvidence[]>;
+    bulkUpdateStatus(evidenceIds: string[], status: FactEvidenceStatus, options?: {
+        reason?: string;
+        reviewedBy?: string | null;
+    }): Promise<FactEvidence[]>;
+    replaceGeneratedForSources(sources: Array<{
+        sourceKind: string;
+        sourceId: string;
+    }>, options?: {
+        generatedBy?: string;
+        contentId?: string;
+        tenantId?: string | null;
+    }): Promise<{
+        deletedEvidenceIds: string[];
+    }>;
+    upsertEvidence(options: FactEvidenceOptions): Promise<FactEvidence>;
+}
+
+/**
+ * Options for creating concrete evidence for a fact.
+ */
+export declare interface FactEvidenceOptions extends SmrtObjectOptions {
+    id?: string;
+    factId?: string;
+    evidenceKey?: string;
+    status?: FactEvidenceStatus;
+    sourceKind?: string;
+    sourceId?: string;
+    sourceUrl?: string;
+    sourceTitle?: string;
+    quote?: string;
+    locator?: string;
+    extractionMethod?: string;
+    confidence?: number;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+/**
+ * Review status for a concrete evidence excerpt.
+ */
+export declare type FactEvidenceStatus = 'supports' | 'contradicts' | 'unclear' | 'irrelevant' | 'invalid';
+
+/**
+ * A candidate factual statement extracted from unstructured source text.
+ */
+export declare interface FactExtractionCandidate {
+    /** Concise, atomic factual statement suitable for audit */
+    statement: string;
+    /** Fact type classification */
+    type?: FactType;
+    /** Short source excerpt that supports the statement */
+    sourceExcerpt?: string;
+    /** Optional extraction confidence from 0 to 1 */
+    confidence?: number;
+    /** Optional extraction metadata */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Options for AI-assisted fact extraction from source text.
+ */
+export declare interface FactExtractionOptions {
+    /** Domain to guide extraction and later reconciliation */
+    domain?: string;
+    /** Source type, e.g. agenda, minutes, article, transcript */
+    sourceType?: string;
+    /** Human-readable context for the source text */
+    context?: string;
+    /** Maximum number of facts to extract */
+    maxFacts?: number;
+    /** Fact types the extractor may return */
+    allowedTypes?: FactType[];
+    /** Tenant id used when resolving stored prompt overrides */
+    tenantId?: string | null;
+    /** Runtime prompt override for a single extraction call */
+    promptOverride?: PromptConfigOverrideInput;
+}
+
+/**
+ * Fact metadata structure (flexible, application-specific)
+ */
+export declare interface FactMetadata {
+    /** Original extraction context */
+    extractionContext?: string;
+    /** AI model used for refinement */
+    refinedBy?: string;
+    /** Tags for categorization */
+    tags?: string[];
+    /** Related fact IDs */
+    relatedFactIds?: string[];
+    /** Corroboration score from cross-referencing */
+    corroborationScore?: number;
+    /** Allow any other properties */
+    [key: string]: any;
+}
+
+/**
+ * Options for creating a Fact instance
+ */
+export declare interface FactOptions extends SmrtObjectOptions {
+    id?: string;
+    slug?: string;
+    type?: FactType;
+    status?: FactStatus;
+    domain?: string;
+    textRaw?: string;
+    textRefined?: string;
+    /**
+     * Self-referencing pointer to the predecessor fact in the evolution
+     * chain. NOT a structural hierarchy edge — see Fact.previousFactId.
+     */
+    previousFactId?: string;
+    evolutionType?: EvolutionType;
+    sourceCount?: number;
+    confidence?: number;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+export declare class FactSource extends SmrtObject {
+    factId: string;
+    sourceType: string;
+    sourceUrl: string;
+    sourceTitle: string;
+    credibility: number;
+    extractedAt: Date;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactSourceOptions);
+    getMetadata(): Record<string, any>;
+    setMetadata(data: Record<string, any>): void;
+    updateMetadata(updates: Record<string, any>): void;
+    /**
+     * Get the fact this source belongs to
+     */
+    getFact(): Promise<Fact | null>;
+}
+
+export declare class FactSourceCollection extends SmrtCollection<FactSource> {
+    static readonly _itemClass: typeof FactSource;
+    /**
+     * Get all sources for a given fact
+     */
+    getForFact(factId: string): Promise<FactSource[]>;
+    /**
+     * Count sources for a given fact
+     */
+    countForFact(factId: string): Promise<number>;
+    /**
+     * Get sources by type
+     */
+    getByType(sourceType: string): Promise<FactSource[]>;
+    /**
+     * Get sources with credibility above a threshold
+     */
+    getHighCredibility(minCredibility?: number): Promise<FactSource[]>;
+    /**
+     * Get average credibility for a fact's sources
+     */
+    getAverageCredibility(factId: string): Promise<number>;
+    /**
+     * Find all sources belonging to a specific tenant
+     */
+    findByTenant(tenantId: string): Promise<FactSource[]>;
+    /**
+     * Find all global (tenant-less) sources
+     */
+    findGlobal(): Promise<FactSource[]>;
+    /**
+     * Find sources for a tenant including global sources
+     */
+    findWithGlobals(tenantId: string): Promise<FactSource[]>;
+}
+
+/**
+ * Options for creating a FactSource instance
+ */
+export declare interface FactSourceOptions extends SmrtObjectOptions {
+    id?: string;
+    factId?: string;
+    sourceType?: string;
+    sourceUrl?: string;
+    sourceTitle?: string;
+    credibility?: number;
+    extractedAt?: Date;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+/**
+ * Fact lifecycle status
+ */
+export declare type FactStatus = 'pending' | 'active' | 'disputed' | 'superseded' | 'archived' | 'retracted';
+
+export declare class FactSubject extends SmrtObject {
+    factId: string;
+    entityType: string;
+    entityId: string;
+    role: string;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactSubjectOptions);
+    getRole(): SubjectRole;
+    getMetadata(): Record<string, any>;
+    setMetadata(data: Record<string, any>): void;
+    updateMetadata(updates: Record<string, any>): void;
+    /**
+     * Get the fact this subject is linked to
+     */
+    getFact(): Promise<Fact | null>;
+}
+
+export declare class FactSubjectCollection extends SmrtCollection<FactSubject> {
+    static readonly _itemClass: typeof FactSubject;
+    /**
+     * Get all subjects linked to a fact
+     */
+    getForFact(factId: string): Promise<FactSubject[]>;
+    /**
+     * Get all fact-subject links for a given entity
+     */
+    getForEntity(entityType: string, entityId: string): Promise<FactSubject[]>;
+    /**
+     * Link an entity to a fact
+     */
+    linkEntity(factId: string, entityType: string, entityId: string, role?: SubjectRole): Promise<FactSubject>;
+    /**
+     * Unlink an entity from a fact
+     */
+    unlinkEntity(factId: string, entityType: string, entityId: string): Promise<void>;
+    /**
+     * Get subjects by role for a fact
+     */
+    getByRole(factId: string, role: SubjectRole): Promise<FactSubject[]>;
+    /**
+     * Count entities linked to a fact
+     */
+    countForFact(factId: string): Promise<number>;
+    /**
+     * Find all subjects belonging to a specific tenant
+     */
+    findByTenant(tenantId: string): Promise<FactSubject[]>;
+    /**
+     * Find all global (tenant-less) subjects
+     */
+    findGlobal(): Promise<FactSubject[]>;
+    /**
+     * Find subjects for a tenant including global subjects
+     */
+    findWithGlobals(tenantId: string): Promise<FactSubject[]>;
+}
+
+/**
+ * Options for creating a FactSubject instance
+ */
+export declare interface FactSubjectOptions extends SmrtObjectOptions {
+    id?: string;
+    factId?: string;
+    entityType?: string;
+    entityId?: string;
+    role?: SubjectRole;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+export declare class FactTag extends SmrtObject {
+    factId: string;
+    tagSlug: string;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: FactTagOptions);
+    /**
+     * Get metadata as parsed object
+     */
+    getMetadata(): Record<string, any>;
+    /**
+     * Set metadata from object
+     */
+    setMetadata(data: Record<string, any>): void;
+    /**
+     * Update metadata by merging with existing values
+     */
+    updateMetadata(updates: Record<string, any>): void;
+    /**
+     * Get the fact this tag link belongs to
+     */
+    getFact(): Promise<Fact | null>;
+}
+
+export declare class FactTagCollection extends SmrtCollection<FactTag> {
+    static readonly _itemClass: typeof FactTag;
+    /**
+     * Get all tag links for a fact
+     */
+    getForFact(factId: string): Promise<FactTag[]>;
+    /**
+     * Get all fact links for a tag slug
+     */
+    getForTag(tagSlug: string): Promise<FactTag[]>;
+    /**
+     * Add a tag to a fact
+     */
+    addTag(factId: string, tagSlug: string): Promise<FactTag>;
+    /**
+     * Remove a tag from a fact
+     */
+    removeTag(factId: string, tagSlug: string): Promise<void>;
+    /**
+     * Get all tag slugs for a fact
+     */
+    getTagSlugs(factId: string): Promise<string[]>;
+    /**
+     * Find all fact-tag links belonging to a specific tenant
+     */
+    findByTenant(tenantId: string): Promise<FactTag[]>;
+    /**
+     * Find all global (tenant-less) fact-tag links
+     */
+    findGlobal(): Promise<FactTag[]>;
+    /**
+     * Find fact-tag links for a tenant including global links
+     */
+    findWithGlobals(tenantId: string): Promise<FactTag[]>;
+}
+
+/**
+ * Options for creating a FactTag join
+ */
+export declare interface FactTagOptions extends SmrtObjectOptions {
+    id?: string;
+    factId?: string;
+    tagSlug?: string;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+/**
+ * Fact type classification
+ */
+export declare type FactType = 'assertion' | 'observation' | 'measurement' | 'definition' | 'relationship' | 'event' | 'opinion' | 'prediction';
+
+/**
+ * Normalize text for comparison and storage.
+ * Trims whitespace, collapses multiple spaces, and lowercases.
+ */
+export declare function normalizeText(text: string): string;
+
+/**
+ * Reconcile action taken
+ */
+export declare type ReconcileAction = 'created' | 'merged' | 'branched';
+
+/**
+ * Options for the reconcile() operation
+ */
+export declare interface ReconcileOptions {
+    /** Raw text input to reconcile */
+    rawInput: string;
+    /** Similarity threshold for automatic merge (default: 0.85) */
+    similarityThreshold?: number;
+    /** Minimum similarity to consider a conflict (default: 0.60) */
+    conflictThreshold?: number;
+    /** Fact type classification */
+    type?: FactType;
+    /** Domain for the fact */
+    domain?: string;
+    /** Source metadata */
+    source?: {
+        sourceType?: string;
+        sourceUrl?: string;
+        sourceTitle?: string;
+        credibility?: number;
+        metadata?: Record<string, any>;
+    };
+    tenantId?: string | null;
+    /** Runtime prompt override for AI-assisted ambiguous reconciliation */
+    promptOverride?: PromptConfigOverrideInput;
+}
+
+/**
+ * Result of the reconcile() operation
+ */
+export declare interface ReconcileResult {
+    /** Action taken: created, merged, or branched */
+    action: ReconcileAction;
+    /** The resulting fact (created, updated, or branched) */
+    fact: Fact;
+    /** Source record if source metadata was provided */
+    source?: FactSource;
+    /** Cosine similarity score of the best match */
+    similarity?: number;
+    /** The existing fact that was matched (for merge/branch) */
+    matchedFact?: Fact;
+}
+
+export declare const smrtFactsAssessClaimSupportPrompt: PromptDefinition;
+
+export declare const smrtFactsExtractArticleClaimsPrompt: PromptDefinition;
+
+export declare const smrtFactsExtractCandidatesPrompt: PromptDefinition;
+
+export declare const smrtFactsReconcilePrompt: PromptDefinition;
+
+/**
+ * Role of a subject entity in relation to a fact
+ */
+export declare type SubjectRole = 'subject' | 'object' | 'source' | 'location' | 'participant' | 'related';
+
+export { }