claude-presentation-master 6.1.1 → 7.2.0

package/dist/index.d.mts

@@ -21,6 +21,10 @@ interface PresentationConfig {
     theme?: ThemeName;
     /** Minimum QA score required (0-100, default: 95) */
     qaThreshold?: number;
+    /** Maximum iterations for auto-fix loop (default: 5) */
+    maxIterations?: number;
+    /** Use iterative QA with 7-dimension scoring and auto-fix (default: true) */
+    useIterativeQA?: boolean;
     /** Skip QA validation (NOT RECOMMENDED) */
     skipQA?: boolean;
     /** Presentation title */
@@ -37,6 +41,10 @@ interface PresentationConfig {
     customCSS?: string;
     /** Custom Handlebars templates */
     customTemplates?: Record<string, string>;
+    /** Local images available for use */
+    images?: string[];
+    /** Base path for resolving image paths */
+    imageBasePath?: string;
 }
 type SlideType = 'title' | 'agenda' | 'section-divider' | 'thank-you' | 'big-idea' | 'single-statement' | 'big-number' | 'full-image' | 'quote' | 'two-column' | 'three-column' | 'bullet-points' | 'screenshot' | 'screenshot-left' | 'screenshot-right' | 'comparison' | 'timeline' | 'process' | 'metrics-grid' | 'pricing' | 'team' | 'features' | 'chart' | 'table' | 'social-proof' | 'case-study' | 'cta';
 interface Slide {
@@ -243,16 +251,29 @@ interface PresentationMetadata {
     generatedAt: string;
     /** Presentation mode */
     mode: PresentationMode$1;
+    /** Detected/specified presentation type */
+    presentationType?: PresentationType$1;
     /** Total slide count */
     slideCount: number;
     /** Total word count */
     wordCount: number;
+    /** Total words (alias for wordCount) */
+    totalWords?: number;
     /** Average words per slide */
     avgWordsPerSlide: number;
     /** Estimated presentation duration (minutes) */
     estimatedDuration: number;
     /** Themes/frameworks used */
     frameworks: string[];
+    /** QA iterations used */
+    qaIterations?: number;
+    /** Max iterations configured */
+    qaMaxIterations?: number;
+    /** 7-dimension scores */
+    dimensionScores?: Record<string, {
+        score: number;
+        weight: number;
+    }>;
 }
 interface ContentSection$1 {
     /** Section header text */
@@ -322,22 +343,121 @@ declare class TemplateNotFoundError extends Error {
     templatePath: string;
     constructor(templatePath: string, message?: string);
 }
+/**
+ * Content pattern detected from a section
+ * Used to match content to appropriate slide types
+ */
+interface ContentPattern {
+    /** Section has a big number ($X, X%, Xx) */
+    hasBigNumber: boolean;
+    /** Extracted big number value */
+    bigNumberValue?: string;
+    /** Section has comparison language (vs, before/after) */
+    hasComparison: boolean;
+    /** Section has timeline markers (Phase, Week, Q1) */
+    hasTimeline: boolean;
+    /** Section has process/steps (Step 1, Pillar) */
+    hasProcess: boolean;
+    /** Section has 3+ metrics */
+    hasMetrics: boolean;
+    /** Section is a quote */
+    hasQuote: boolean;
+    /** Section has code blocks */
+    hasCode: boolean;
+    /** Number of bullets in section */
+    bulletCount: number;
+    /** Word count of section */
+    wordCount: number;
+    /** Primary detected pattern name */
+    primaryPattern: 'big_number' | 'comparison' | 'timeline' | 'process' | 'metrics' | 'quote' | 'code' | 'bullets' | 'prose';
+}
+/**
+ * Validation rules from KB for a presentation type
+ */
+interface ValidationRules {
+    wordsPerSlide: {
+        min: number;
+        max: number;
+        ideal: number;
+    };
+    whitespace: {
+        min: number;
+        ideal: number;
+    };
+    bulletsPerSlide: {
+        max: number;
+    };
+    slidesPerIdea?: number;
+    actionTitlesRequired: boolean;
+    sourcesRequired: boolean;
+    calloutsRequired?: boolean;
+    denseDataAllowed?: boolean;
+    codeBlocksAllowed?: boolean;
+    diagramsRequired?: boolean;
+}
+/**
+ * Typography specifications from KB
+ */
+interface TypographyRules {
+    titles: string;
+    body: string;
+    maxFonts: number;
+    actionTitle?: string;
+    sectionHeaders?: string;
+    dataLabels?: string;
+    code?: string;
+}
+/**
+ * Scoring weights from KB for QA
+ */
+interface ScoringWeights {
+    visualQuality: number;
+    contentQuality: number;
+    expertCompliance: number;
+    accessibility: number;
+}
+/**
+ * Result of validating a slide against KB rules
+ */
+interface SlideValidationResult {
+    valid: boolean;
+    violations: string[];
+    warnings: string[];
+    wordCount: number;
+    bulletCount: number;
+    slideType: string;
+}
+/**
+ * Story structure from KB
+ */
+interface StoryStructure {
+    framework: 'scqa' | 'sparkline' | 'pyramid' | 'hero_journey';
+    requiredElements: string[];
+    optionalElements: string[];
+    antiPatterns: string[];
+}
 
 /**
  * Presentation Engine - Main Orchestrator
  *
  * Coordinates content analysis, slide generation, and QA validation
  * to produce world-class presentations.
+ *
+ * Features:
+ * - KB-driven slide generation
+ * - 7-dimension quality scoring
+ * - Iterative auto-fix loop until threshold met
+ * - Comprehensive audit trail
  */
 
 declare class PresentationEngine {
     private contentAnalyzer;
-    private slideFactory;
     private templateEngine;
     private scoreCalculator;
     private qaEngine;
     private htmlGenerator;
     private pptxGenerator;
+    private kb;
     constructor();
     /**
      * Generate a presentation from content.
@@ -346,6 +466,10 @@ declare class PresentationEngine {
      * @returns Presentation result with outputs, QA results, and score
      */
     generate(config: PresentationConfig): Promise<PresentationResult>;
+    /**
+     * Build QA results structure from 7-dimension scoring.
+     */
+    private buildQAResultsFrom7Dimension;
     /**
      * Validate presentation configuration.
      */
@@ -550,6 +674,189 @@ declare class KnowledgeGateway {
      * Get the full knowledge base (for advanced queries)
      */
     getRawKB(): any;
+    /**
+     * Get allowed slide types for a specific presentation type.
+     * CRITICAL: SlideFactory must ONLY use types from this list.
+     */
+    getAllowedSlideTypes(type: PresentationType): string[];
+    /**
+     * Get validation rules for a specific presentation type.
+     * Returns word limits, bullet limits, whitespace requirements, etc.
+     */
+    getValidationRules(type: PresentationType): {
+        wordsPerSlide: {
+            min: number;
+            max: number;
+            ideal: number;
+        };
+        whitespace: {
+            min: number;
+            ideal: number;
+        };
+        bulletsPerSlide: {
+            max: number;
+        };
+        actionTitlesRequired: boolean;
+        sourcesRequired: boolean;
+        calloutsRequired?: boolean;
+        denseDataAllowed?: boolean;
+        codeBlocksAllowed?: boolean;
+        diagramsRequired?: boolean;
+    };
+    /**
+     * Get required elements that MUST be in the deck for this type.
+     */
+    getRequiredElements(type: PresentationType): string[];
+    /**
+     * Get anti-patterns to avoid for this presentation type.
+     */
+    getAntiPatternsForType(type: PresentationType): string[];
+    /**
+     * Get typography specifications for this presentation type.
+     */
+    getTypographyForType(type: PresentationType): {
+        titles: string;
+        body: string;
+        maxFonts: number;
+        actionTitle?: string;
+        sectionHeaders?: string;
+        dataLabels?: string;
+        code?: string;
+    };
+    /**
+     * Get CSS variables recipe for this presentation type.
+     */
+    getCSSVariablesForType(type: PresentationType): string;
+    /**
+     * Get scoring weights for QA evaluation for this type.
+     */
+    getScoringWeights(type: PresentationType): {
+        visualQuality: number;
+        contentQuality: number;
+        expertCompliance: number;
+        accessibility: number;
+    };
+    /**
+     * Get story structure framework for this presentation type.
+     */
+    getStoryStructure(type: PresentationType): {
+        framework: string;
+        requiredElements: string[];
+        optionalElements: string[];
+    };
+    /**
+     * Map a content pattern to the best allowed slide type.
+     * CRITICAL: This is how SlideFactory decides which slide type to use.
+     */
+    mapContentPatternToSlideType(pattern: {
+        primaryPattern: string;
+        hasBigNumber?: boolean;
+        hasComparison?: boolean;
+        hasTimeline?: boolean;
+        hasProcess?: boolean;
+        hasMetrics?: boolean;
+        hasQuote?: boolean;
+        hasCode?: boolean;
+        bulletCount?: number;
+    }, allowedTypes: string[]): string;
+    /**
+     * Get a specific slide template by name from the KB.
+     */
+    getSlideTemplateByName(name: string): {
+        name: string;
+        purpose: string;
+        elements?: string[];
+        components?: string[];
+        wordLimit: number;
+    } | undefined;
+    /**
+     * Get slide defaults for structural slides (titles, messages, labels).
+     * CRITICAL: SlideFactory must use these instead of hardcoded strings.
+     */
+    getSlideDefaults(type: PresentationType): {
+        agenda: {
+            title: string;
+        };
+        thankYou: {
+            title: string;
+            subtitle: string;
+        };
+        cta: {
+            title: string;
+            message: string;
+            fallback: string;
+        };
+        metricsGrid: {
+            title: string;
+            maxMetrics: number;
+        };
+        code: {
+            label: string;
+            maxChars: number;
+        };
+        comparison: {
+            leftLabel: string;
+            rightLabel: string;
+            optionLabels: string[];
+        };
+        column: {
+            labelTemplate: string;
+        };
+        subtitle: {
+            maxWords: number;
+        };
+        context: {
+            maxWords: number;
+        };
+        step: {
+            maxWords: number;
+        };
+        columnContent: {
+            maxWords: number;
+        };
+    };
+    /**
+     * Get SCQA framework titles from KB (for business mode).
+     */
+    getSCQATitles(type: PresentationType): {
+        situation: string;
+        complication: string;
+        question: string;
+        answer: string;
+    };
+    /**
+     * Get Sparkline framework titles from KB (for keynote mode).
+     */
+    getSparklineTitles(type: PresentationType): {
+        whatIs: string;
+        whatCouldBe: string;
+        callToAdventure: string;
+        newBliss: string;
+    };
+    /**
+     * Get insight markers for detecting action titles.
+     * These are words/phrases that indicate an insight vs a topic.
+     */
+    getInsightMarkers(): string[];
+    /**
+     * Get word limit for a specific slide element type.
+     */
+    getWordLimitForElement(type: PresentationType, element: 'title' | 'subtitle' | 'bullet' | 'body' | 'quote' | 'step'): number;
+    /**
+     * Validate a slide against KB rules for the given presentation type.
+     */
+    validateSlideAgainstKB(slide: {
+        type: string;
+        wordCount: number;
+        bulletCount: number;
+        hasActionTitle?: boolean;
+        hasSource?: boolean;
+    }, type: PresentationType): {
+        valid: boolean;
+        violations: string[];
+        warnings: string[];
+        fixes: Record<string, any>;
+    };
 }
 /**
  * Get or create the KnowledgeGateway instance
@@ -619,6 +926,7 @@ declare class ContentAnalyzer {
     analyze(content: string, contentType: string): Promise<ContentAnalysis>;
     /**
      * Parse content based on type
+     * CRITICAL: Strip code blocks FIRST to prevent code from becoming slides
      */
     private parseContent;
     /**
@@ -635,6 +943,7 @@ declare class ContentAnalyzer {
     private extractSections;
     /**
      * Extract SCQA structure (Barbara Minto)
+     * CRITICAL: Answer must be clean prose, NOT bullet points
      */
     private extractSCQA;
     /**
@@ -662,9 +971,17 @@ declare class ContentAnalyzer {
     private extractKeyMessages;
     /**
      * Extract data points (metrics with values)
-     * IMPROVED: Smarter label extraction that understands markdown tables
+     * REWRITTEN: Proper markdown table parsing and meaningful label extraction
      */
     private extractDataPoints;
+    /**
+     * Extract metrics from a parsed markdown table
+     */
+    private extractMetricsFromTable;
+    /**
+     * Clean a metric label to ensure it's complete and meaningful
+     */
+    private cleanMetricLabel;
     /**
      * Extract a meaningful label from a line containing a metric
      */
@@ -681,116 +998,220 @@ declare class ContentAnalyzer {
 }
 
 /**
- * Slide Factory - Creates Slides from Content Analysis
+ * SlideFactory - 100% KB-Driven Slide Creation (v7.1.0)
  *
- * Generates slide structures based on:
- * - Presentation mode (keynote vs business)
- * - Content analysis results
- * - Expert methodology recommendations
+ * CRITICAL: This factory creates slides using ONLY the Knowledge Base.
+ * ZERO hardcoded values. Every string and number comes from KB queries.
+ *
+ * All decisions flow from:
+ * - kb.getSlideDefaults(type) → structural slide titles/labels
+ * - kb.getSCQATitles(type) → SCQA framework titles
+ * - kb.getSparklineTitles(type) → Sparkline framework titles
+ * - kb.getValidationRules(type) → word limits, bullet limits
+ * - kb.getAllowedSlideTypes(type) → which slide types can be used
+ * - kb.getInsightMarkers() → action title detection
+ * - kb.getTypographyForType(type) → font specifications
+ * - kb.getRecommendedPalette(type) → color palette
+ * - kb.getAntiPatternsForType(type) → what to avoid
+ * - kb.getRequiredElements(type) → mandatory slides
+ * - kb.getDuarteGlanceTest() → 3-second test limits
+ * - kb.getMillersLaw() → 7±2 items rule
+ *
+ * @version 7.1.0
  */
 
+/**
+ * KB-Driven SlideFactory (v7.1.0)
+ *
+ * Usage:
+ *   const factory = new SlideFactory(kb, 'consulting_deck');
+ *   const slides = await factory.createSlides(analysis);
+ */
 declare class SlideFactory {
-    private readonly templates;
+    private kb;
+    private presentationType;
+    private classifier;
+    private config;
     private usedContent;
-    constructor();
+    private usedTitles;
+    constructor(kb: KnowledgeGateway, type: PresentationType);
     /**
-     * Check if content has already been used (deduplication)
+     * Load ALL configuration from KB - ZERO hardcoded values after this.
      */
-    private isContentUsed;
+    private loadKBConfig;
     /**
-     * Create slides from analyzed content.
-     *
-     * ARCHITECTURE (per KB expert methodologies):
-     * 1. Title slide - always first
-     * 2. Agenda slide - business mode only with 3+ sections
-     * 3. SCQA slides - Situation, Complication (per Minto)
-     * 4. Content slides - from sections with bullets/content
-     * 5. Metrics slide - if data points exist
-     * 6. Solution slide - SCQA answer
-     * 7. STAR moments - only if high-quality (per Duarte)
-     * 8. CTA slide - if call to action exists
-     * 9. Thank you slide - always last
+     * Create all slides from content analysis.
+     * This is the main entry point - orchestrates the entire slide creation process.
      */
-    createSlides(analysis: ContentAnalysis$1, mode: PresentationMode$1): Promise<Slide[]>;
+    createSlides(analysis: ContentAnalysis$1): Promise<Slide[]>;
+    private createSlideByType;
+    private createTitleSlide;
+    private createAgendaSlide;
+    private createThankYouSlide;
+    private addSCQASlides;
+    private addSparklineSlides;
+    private createBigNumberSlide;
+    private createComparisonSlide;
+    private createTimelineSlide;
+    private createProcessSlide;
+    private createThreeColumnSlide;
+    private createTwoColumnSlide;
+    private createQuoteSlide;
+    private createMetricsGridSlide;
+    private createBulletSlide;
+    private createSingleStatementSlide;
+    private createCodeSlide;
+    private createCTASlide;
+    private validateAndFixSlides;
     /**
-     * Create a slide from a section with bullets
+     * Check that required elements exist in the deck (from KB)
      */
-    private createSectionBulletSlide;
+    private checkRequiredElements;
     /**
-     * Create a slide from a section with body content
+     * Check for anti-patterns from KB
      */
-    private createSectionContentSlide;
+    private checkAntiPatterns;
     /**
-     * Extract first sentence from text
+     * Create a title for a slide - uses action titles for business mode per KB
      */
-    private extractFirstSentence;
+    private createTitle;
     /**
-     * Create a metrics slide from data points
+     * Create an action title (Minto/McKinsey style)
+     * Title should communicate the conclusion, not the topic
      */
-    private createMetricsSlide;
+    private createActionTitle;
     /**
-     * Create a title slide.
+     * Check if text contains an insight (not just a topic) - uses KB markers
      */
-    private createTitleSlide;
+    private isInsightful;
     /**
-     * Create an agenda slide.
+     * Check if a title is an action title
      */
-    private createAgendaSlide;
+    private isActionTitle;
     /**
-     * Create a context/situation slide.
+     * Count words in a slide
      */
-    private createContextSlide;
+    private countWords;
     /**
-     * Create a problem/complication slide.
+     * Truncate text to word limit at sentence boundaries
      */
-    private createProblemSlide;
+    private truncateText;
     /**
-     * Create a key message slide.
+     * Clean text by removing content markers and normalizing
      */
-    private createMessageSlide;
+    private cleanText;
     /**
-     * Create a STAR moment slide.
+     * Clean metric labels (strip table syntax)
      */
-    private createStarMomentSlide;
+    private cleanMetricLabel;
     /**
-     * Create a solution/answer slide.
+     * Normalize a key for deduplication
      */
-    private createSolutionSlide;
+    private normalizeKey;
+}
+/**
+ * Create a SlideFactory instance (convenience function)
+ */
+declare function createSlideFactory(kb: KnowledgeGateway, type: PresentationType): SlideFactory;
+
+/**
+ * Content Pattern Classifier
+ *
+ * Analyzes content sections to detect patterns that determine slide type selection.
+ * This classifier is used by SlideFactory to match content to KB-allowed slide types.
+ *
+ * @version 7.0.0
+ */
+
+declare class ContentPatternClassifier {
+    private readonly patterns;
     /**
-     * Create a call-to-action slide.
+     * Classify a content section to determine its primary pattern.
+     * Returns a ContentPattern object used by SlideFactory to select slide type.
      */
-    private createCTASlide;
+    classify(section: ContentSection$1): ContentPattern;
     /**
-     * Create a thank you slide.
+     * Check if bullets appear to be numbered/ordered items
      */
-    private createThankYouSlide;
+    private hasNumberedItems;
+    /**
+     * Extract the big number value from content for display
+     */
+    extractBigNumber(content: string): {
+        value: string;
+        context: string;
+    } | null;
     /**
-     * Initialize slide templates with constraints.
+     * Extract comparison elements from content
      */
-    private initializeTemplates;
+    extractComparison(section: ContentSection$1): {
+        left: string;
+        right: string;
+    } | null;
     /**
-     * Clean text by removing all markdown and content markers.
-     * CRITICAL: Must strip all formatting to prevent garbage in slides
+     * Extract timeline/process steps from content
      */
-    private cleanText;
+    extractSteps(section: ContentSection$1): Array<{
+        label: string;
+        description: string;
+    }>;
+    /**
+     * Determine if content is suitable for a three-column layout
+     * (3 pillars, 3 key points, etc.)
+     */
+    isSuitableForThreeColumn(section: ContentSection$1): boolean;
     /**
-     * Truncate text to max length at sentence boundary when possible.
-     * CRITICAL: Never cut mid-number (99.5% should not become 99.)
+     * Check if content should be displayed as a quote slide
      */
-    private truncate;
+    isQuoteContent(section: ContentSection$1): {
+        isQuote: boolean;
+        attribution?: string;
+    };
+}
+
+/**
+ * SlideGenerator - Orchestrates slide creation using KB-driven SlideFactory
+ *
+ * This generator orchestrates the slide creation process:
+ * - Initializes KnowledgeGateway
+ * - Creates SlideFactory with KB and presentation type
+ * - Delegates all slide creation to SlideFactory
+ * - SlideFactory handles all KB queries for slide decisions
+ *
+ * @version 7.0.0 - Now uses KB-driven SlideFactory
+ */
+
+declare class SlideGenerator {
+    private kb;
+    private factory;
+    private mode;
+    private presentationType;
+    initialize(): Promise<void>;
     /**
-     * Extract an action title from a message.
+     * Generate slides from analyzed content using KB-driven SlideFactory.
+     *
+     * @version 7.0.0 - Now delegates ALL slide creation to SlideFactory
+     * SlideFactory queries KB for every decision:
+     * - Allowed slide types per presentation type
+     * - Word limits per type
+     * - Bullet limits per type
+     * - Content pattern to slide type mapping
+     * - Slide validation against KB rules
      */
-    private extractActionTitle;
+    generate(analysis: ContentAnalysis$1, type?: PresentationType): Promise<Slide[]>;
     /**
-     * Extract bullet points from text.
+     * Convert new Slide format to legacy format for backwards compatibility
      */
-    private extractBullets;
+    private convertToLegacyFormat;
     /**
-     * Remove a statistic from text and clean thoroughly.
+     * Map slide type to template name for backwards compatibility
      */
-    private removeStatistic;
+    private mapTypeToTemplate;
 }
+/**
+ * Initialize and return a SlideGenerator instance
+ */
+declare function initSlideGenerator(): Promise<SlideGenerator>;
 
 /**
  * Template Engine - Handlebars Template Rendering
@@ -977,6 +1398,263 @@ declare class QAEngine {
     private closeBrowser;
 }
 
+/**
+ * Seven-Dimension Presentation Scorer
+ *
+ * Comprehensive scoring across all quality dimensions using Knowledge Base rules.
+ * Each dimension scored 0-100, overall score is weighted average.
+ *
+ * Dimensions:
+ * 1. Layout (15%) - Whitespace, visual balance, slide structure
+ * 2. Contrast (15%) - WCAG compliance, text readability
+ * 3. Graphics (10%) - Image quality, placement, relevance
+ * 4. Content (20%) - Word limits, bullet counts, structure
+ * 5. Clarity (15%) - Message focus, information density
+ * 6. Effectiveness (15%) - Expert methodology compliance
+ * 7. Consistency (10%) - Style uniformity, design coherence
+ */
+
+interface DimensionScore {
+    name: string;
+    score: number;
+    weight: number;
+    issues: DimensionIssue[];
+    details: Record<string, unknown>;
+}
+interface DimensionIssue {
+    slideIndex: number;
+    dimension: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    currentValue?: unknown;
+    expectedValue?: unknown;
+    autoFixable: boolean;
+    fixSuggestion?: string;
+}
+interface SevenDimensionResult {
+    overallScore: number;
+    dimensions: {
+        layout: DimensionScore;
+        contrast: DimensionScore;
+        graphics: DimensionScore;
+        content: DimensionScore;
+        clarity: DimensionScore;
+        effectiveness: DimensionScore;
+        consistency: DimensionScore;
+    };
+    issues: DimensionIssue[];
+    passed: boolean;
+    threshold: number;
+}
+declare class SevenDimensionScorer {
+    private kb;
+    private mode;
+    private presentationType;
+    constructor(mode: 'keynote' | 'business', presentationType: PresentationType);
+    /**
+     * Score a presentation across all 7 dimensions.
+     */
+    score(slides: Slide[], html: string, threshold?: number): Promise<SevenDimensionResult>;
+    /**
+     * Score layout dimension (whitespace, visual balance, structure)
+     */
+    private scoreLayout;
+    /**
+     * Score contrast dimension (WCAG compliance, readability)
+     */
+    private scoreContrast;
+    /**
+     * Score graphics dimension (images, placement, relevance)
+     */
+    private scoreGraphics;
+    /**
+     * Score content dimension (word limits, bullet counts, structure)
+     * This is critical - must use KB rules exactly.
+     */
+    private scoreContent;
+    /**
+     * Score clarity dimension (message focus, information density)
+     */
+    private scoreClarity;
+    /**
+     * Score effectiveness dimension (expert methodology compliance)
+     */
+    private scoreEffectiveness;
+    /**
+     * Score consistency dimension (style uniformity, design coherence)
+     */
+    private scoreConsistency;
+    /**
+     * Count words in a slide.
+     */
+    private countWords;
+    /**
+     * Get a formatted report of the scoring results.
+     */
+    formatReport(result: SevenDimensionResult): string;
+}
+
+/**
+ * AutoFix Engine
+ *
+ * KB-driven automatic fixing of presentation issues.
+ * Uses Knowledge Base rules to determine correct values and apply fixes.
+ *
+ * Key Principles:
+ * 1. All fixes are driven by KB rules, not hardcoded values
+ * 2. Fixes are applied to slide data, not raw HTML (for reliability)
+ * 3. Each fix is logged for transparency
+ * 4. Only auto-fixable issues are addressed
+ */
+
+interface FixResult {
+    slideIndex: number;
+    dimension: string;
+    originalValue: unknown;
+    newValue: unknown;
+    description: string;
+    applied: boolean;
+}
+interface AutoFixResult {
+    slidesFixed: Slide[];
+    fixesApplied: FixResult[];
+    fixesSkipped: FixResult[];
+    summary: string;
+}
+declare class AutoFixEngine {
+    private kb;
+    private mode;
+    private presentationType;
+    constructor(mode: 'keynote' | 'business', presentationType: PresentationType);
+    /**
+     * Apply automatic fixes to slides based on scoring results.
+     */
+    fix(slides: Slide[], scoringResult: SevenDimensionResult): Promise<AutoFixResult>;
+    /**
+     * Apply a single fix based on the issue.
+     */
+    private applyFix;
+    /**
+     * Fix content-related issues (word count, bullet count).
+     */
+    private fixContentIssue;
+    /**
+     * Fix clarity-related issues (key message length, title length).
+     */
+    private fixClarityIssue;
+    /**
+     * Fix layout-related issues.
+     */
+    private fixLayoutIssue;
+    /**
+     * Fix consistency-related issues.
+     */
+    private fixConsistencyIssue;
+    /**
+     * Fix contrast-related issues.
+     * Note: These are CSS fixes, typically handled at generation time.
+     */
+    private fixContrastIssue;
+    /**
+     * Condense text to approximately maxWords.
+     * Uses smart truncation that preserves meaning.
+     */
+    private condenseText;
+    /**
+     * Convert text to Title Case.
+     */
+    private toTitleCase;
+    /**
+     * Count words in a slide.
+     */
+    private countWords;
+    /**
+     * Count elements in a slide.
+     */
+    private countElements;
+    /**
+     * Generate a summary of fixes applied.
+     */
+    private generateSummary;
+}
+/**
+ * Create an AutoFixEngine instance.
+ */
+declare function createAutoFixEngine(mode: 'keynote' | 'business', presentationType: PresentationType): AutoFixEngine;
+
+/**
+ * Iterative QA Engine
+ *
+ * Orchestrates the generate-score-fix-regenerate loop until quality threshold is met.
+ * This is the core integration that makes the NPM tool self-correcting.
+ *
+ * Process:
+ * 1. Generate initial presentation
+ * 2. Score across 7 dimensions
+ * 3. If score < threshold AND iterations < max:
+ *    a. Apply auto-fixes to slides
+ *    b. Regenerate HTML
+ *    c. Re-score
+ *    d. Repeat until threshold met or max iterations
+ * 4. Return final result with full audit trail
+ */
+
+interface IterationRecord {
+    iteration: number;
+    score: number;
+    dimensionScores: {
+        layout: number;
+        contrast: number;
+        graphics: number;
+        content: number;
+        clarity: number;
+        effectiveness: number;
+        consistency: number;
+    };
+    fixesApplied: number;
+    timestamp: Date;
+}
+interface IterativeQAResult {
+    finalScore: number;
+    passed: boolean;
+    threshold: number;
+    iterations: IterationRecord[];
+    totalIterations: number;
+    maxIterations: number;
+    slides: Slide[];
+    html: string;
+    finalScoring: SevenDimensionResult;
+    autoFixSummary: string;
+    report: string;
+}
+interface IterativeQAOptions {
+    minScore: number;
+    maxIterations: number;
+    verbose: boolean;
+}
+declare class IterativeQAEngine {
+    private kb;
+    private scorer;
+    private fixer;
+    private generator;
+    private mode;
+    private presentationType;
+    private config;
+    constructor(mode: 'keynote' | 'business', presentationType: PresentationType, config: PresentationConfig);
+    /**
+     * Run the iterative QA process.
+     */
+    run(initialSlides: Slide[], initialHtml: string, options?: Partial<IterativeQAOptions>): Promise<IterativeQAResult>;
+    /**
+     * Generate a comprehensive report.
+     */
+    private generateReport;
+}
+/**
+ * Create an IterativeQAEngine instance.
+ */
+declare function createIterativeQAEngine(mode: 'keynote' | 'business', presentationType: PresentationType, config: PresentationConfig): IterativeQAEngine;
+
 /**
  * Reveal.js Generator - HTML Presentation Output
  *
@@ -1411,7 +2089,7 @@ declare function validate(presentation: string | Buffer, options?: {
 /**
  * Get the version of the package.
  */
-declare const VERSION = "6.0.0";
+declare const VERSION = "7.1.0";
 /**
  * Default export for convenience.
  */
@@ -1423,4 +2101,4 @@ declare const _default: {
     VERSION: string;
 };
 
-export { type AccessibilityResults, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, type ColorPalette, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis$1 as ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContentSection$1 as ContentSection, type ContrastIssue, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeGateway, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode$1 as PresentationMode, type PresentationResult, type PresentationType, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideContentScore, type SlideData, SlideFactory, type SlideTemplate, type SlideType, type SlideVisualScore, type SparklineStructure, TemplateEngine, TemplateNotFoundError, type ThemeName, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeGateway, validate };
+export { type AccessibilityResults, AutoFixEngine, type AutoFixResult, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, type ColorPalette, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis$1 as ContentAnalysis, ContentAnalyzer, type ContentPattern, ContentPatternClassifier, type ContentQAResults, type ContentSection$1 as ContentSection, type ContrastIssue, type DimensionIssue, type DimensionScore, type ExpertQAResults, type ExpertValidation, type FixResult, type FontSizeIssue, type GlanceTestResult, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, type IterationRecord, IterativeQAEngine, type IterativeQAOptions, type IterativeQAResult, KnowledgeGateway, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode$1 as PresentationMode, type PresentationResult, type PresentationType, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type ScoringWeights, type SevenDimensionResult, SevenDimensionScorer, type SignalNoiseResult, type Slide, type SlideContentScore, type SlideData, SlideFactory, SlideGenerator, type SlideTemplate, type SlideType, type SlideValidationResult, type SlideVisualScore, type SparklineStructure, type StoryStructure, TemplateEngine, TemplateNotFoundError, type ThemeName, type TypographyRules, UnsplashImageProvider, VERSION, ValidationError, type ValidationRules, type VisualQAResults, createAutoFixEngine, createDefaultChartProvider, createDefaultImageProvider, createIterativeQAEngine, createSlideFactory, _default as default, generate, getKnowledgeGateway, initSlideGenerator, validate };