claude-presentation-master 7.4.0 → 8.0.0

package/dist/index.d.mts

@@ -19,12 +19,8 @@ interface PresentationConfig {
     format: OutputFormat[];
     /** Visual theme */
     theme?: ThemeName;
-    /** Minimum QA score required (0-100, default: 95) */
+    /** Minimum QA score required (0-100, default: 80) */
     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 */
@@ -146,9 +142,9 @@ interface VisualQAResults {
     /** Screenshots of each slide */
     screenshots: Buffer[];
     /** Per-slide visual scores */
-    perSlide: SlideVisualScore[];
+    perSlide: SlideVisualScore$1[];
 }
-interface SlideVisualScore {
+interface SlideVisualScore$1 {
     slideIndex: number;
     whitespace: number;
     balance: number;
@@ -348,6 +344,11 @@ interface ContentSection$1 {
         label: string;
         context?: string;
     }>;
+    /** Sub-sections for parent-child patterns (e.g., "Three Pillars" with 3 children) */
+    subSections?: Array<{
+        title: string;
+        content: string;
+    }>;
 }
 interface ContentAnalysis$1 {
     /** Detected presentation type */
@@ -505,8 +506,8 @@ interface StoryStructure {
  *
  * Features:
  * - KB-driven slide generation
- * - 7-dimension quality scoring
- * - Iterative auto-fix loop until threshold met
+ * - Visual quality evaluation (Playwright-based)
+ * - Honest scoring based on actual rendered output
  * - Comprehensive audit trail
  */
 
@@ -528,9 +529,9 @@ declare class PresentationEngine {
      */
     generate(config: PresentationConfig): Promise<PresentationResult>;
     /**
-     * Build QA results structure from 7-dimension scoring.
+     * Build QA results structure from visual quality evaluation.
      */
-    private buildQAResultsFrom7Dimension;
+    private buildQAResultsFromVisual;
     /**
      * Validate presentation configuration.
      */
@@ -634,7 +635,8 @@ declare class KnowledgeGateway {
      */
     getModeForType(type: PresentationType): 'keynote' | 'business';
     /**
-     * Get word limits for the specified mode
+     * Get word limits for the specified mode.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getWordLimits(mode: 'keynote' | 'business'): {
         min: number;
@@ -642,14 +644,16 @@ declare class KnowledgeGateway {
         ideal: number;
     };
     /**
-     * Get bullet point limits
+     * Get bullet point limits.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getBulletLimits(mode: 'keynote' | 'business'): {
         maxBullets: number;
         maxWordsPerBullet: number;
     };
     /**
-     * Get whitespace percentage requirement
+     * Get whitespace percentage requirement.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getWhitespaceRequirement(mode: 'keynote' | 'business'): number;
     /**
@@ -697,21 +701,24 @@ declare class KnowledgeGateway {
      */
     getExpertPrinciples(expertName: string): unknown;
     /**
-     * Get Duarte's glance test requirements
+     * Get Duarte's glance test requirements.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getDuarteGlanceTest(): {
         wordLimit: number;
         timeSeconds: number;
     };
     /**
-     * Get Miller's Law constraints
+     * Get Miller's Law constraints.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getMillersLaw(): {
         minItems: number;
         maxItems: number;
     };
     /**
-     * Get cognitive load constraints
+     * Get cognitive load constraints.
+     * READS FROM KB - NO HARDCODED VALUES.
      */
     getCognitiveLoadLimits(): {
         maxItemsPerChunk: number;
@@ -810,6 +817,11 @@ declare class KnowledgeGateway {
      * Map a content pattern to the best allowed slide type.
      * CRITICAL: This is how SlideFactory decides which slide type to use.
      */
+    /**
+     * Map semantic slide types to structural types that SlideFactory can handle.
+     * This bridges the gap between KB's rich semantic types and code's structural types.
+     */
+    private normalizeToStructuralType;
     mapContentPatternToSlideType(pattern: {
         primaryPattern: string;
         hasBigNumber?: boolean;
@@ -821,6 +833,10 @@ declare class KnowledgeGateway {
         hasCode?: boolean;
         bulletCount?: number;
     }, allowedTypes: string[]): string;
+    /**
+     * Check if a structural type is allowed (directly or via semantic mapping)
+     */
+    private isTypeAllowed;
     /**
      * Get a specific slide template by name from the KB.
      */
@@ -948,6 +964,11 @@ interface ContentSection {
         label: string;
         context?: string;
     }>;
+    /** Sub-sections for parent-child patterns (e.g., "Three Pillars" with 3 children) */
+    subSections?: Array<{
+        title: string;
+        content: string;
+    }>;
 }
 interface ContentAnalysis {
     detectedType: PresentationType;
@@ -1009,6 +1030,11 @@ declare class ContentAnalyzer {
      * Extract sections from content (headers, bullets, content)
      */
     private extractSections;
+    /**
+     * Combine parent sections with their child sub-sections.
+     * Detects patterns like "Three Pillars" + 3 child sections and merges them.
+     */
+    private combineParentChildSections;
     /**
      * Extract SCQA structure (Barbara Minto)
      * CRITICAL: Answer must be clean prose, NOT bullet points
@@ -1071,26 +1097,32 @@ declare class ContentAnalyzer {
 }
 
 /**
- * SlideFactory - 100% KB-Driven Slide Creation (v7.1.0)
+ * SlideFactory - Expert-Driven Slide Creation (v8.0.0)
+ *
+ * PARADIGM SHIFT: This factory doesn't just TRUNCATE content to fit slides.
+ * It CRAFTS world-class slides using expert principles from the KB.
+ *
+ * v8.0.0 introduces ExpertGuidanceEngine integration:
+ * - Nancy Duarte: Sparkline narrative, STAR moments, Glance Test
+ * - Chris Anderson: One Idea Worth Spreading, Gift Giving
+ * - Carmine Gallo: Rule of Three, Headline Test
+ * - Garr Reynolds: Signal to Noise, Amplification Through Simplification
+ * - Edward Tufte: Data-Ink Ratio
+ * - Cole Knaflic: Context Creates Meaning
+ * - Barbara Minto: Pyramid Principle, SCQA, Answer First
  *
- * CRITICAL: This factory creates slides using ONLY the Knowledge Base.
- * ZERO hardcoded values. Every string and number comes from KB queries.
+ * Content is CRAFTED by:
+ * 1. Understanding the slide's PURPOSE (from ExpertGuidanceEngine)
+ * 2. Extracting the CORE INSIGHT (not just first N words)
+ * 3. Applying expert PRINCIPLES (not just word limits)
+ * 4. Creating slides that MOVE people (not just fit in boxes)
  *
- * All decisions flow from:
+ * All configuration from KB:
  * - 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
+ * - ExpertGuidanceEngine → principles for excellence
  *
- * @version 7.1.0
+ * @version 8.0.0
  */
 
 /**
@@ -1104,6 +1136,8 @@ declare class SlideFactory {
     private kb;
     private presentationType;
     private classifier;
+    private expertEngine;
+    private narrativeArc;
     private config;
     private usedContent;
     private usedTitles;
@@ -1128,11 +1162,30 @@ declare class SlideFactory {
     private createTimelineSlide;
     private createProcessSlide;
     private createThreeColumnSlide;
+    /**
+     * Create a three-points slide for exactly 3 key points.
+     * Used for content that fits the "rule of three" (Carmine Gallo).
+     */
+    private createThreePointsSlide;
     private createTwoColumnSlide;
     private createQuoteSlide;
     private createMetricsGridSlide;
     private createBulletSlide;
     private createSingleStatementSlide;
+    /**
+     * Create a title impact slide - emphasized statement with key takeaway.
+     * Used for section headers with strong conclusions.
+     */
+    private createTitleImpactSlide;
+    /**
+     * Create a data insight slide - for presenting key findings with context.
+     * Similar to big-number but works even without a prominent metric.
+     */
+    private createDataInsightSlide;
+    /**
+     * Create a detailed findings slide - bullet points with introductory context.
+     */
+    private createDetailedFindingsSlide;
     private createCodeSlide;
     private createCTASlide;
     private validateAndFixSlides;
@@ -1144,6 +1197,46 @@ declare class SlideFactory {
      * Check for anti-patterns from KB
      */
     private checkAntiPatterns;
+    /**
+     * Craft content using expert principles - NOT truncation.
+     *
+     * The old approach: "Take 100 words, chop to 15, add ellipsis"
+     * The new approach: "What would Nancy Duarte say is the ONE thing to remember?"
+     *
+     * @param content - The raw content to craft from
+     * @param slideType - The type of slide being created
+     * @param maxWords - Word budget from KB
+     * @returns Expertly crafted content that serves the slide's purpose
+     */
+    private craftExpertContent;
+    /**
+     * Chris Anderson's "One Idea Worth Spreading"
+     * Extract the single most valuable insight from content.
+     */
+    private extractCoreIdea;
+    /**
+     * Extract the key phrase from a sentence - the part that matters most.
+     */
+    private extractKeyPhrase;
+    /**
+     * Nancy Duarte's "STAR Moment" - Something They'll Always Remember
+     * Find the most dramatic, unexpected element.
+     */
+    private extractDramaticElement;
+    /**
+     * Edward Tufte / Cole Knaflic - Extract data insight with context
+     */
+    private extractDataInsight;
+    /**
+     * Garr Reynolds - Signal to Noise
+     * Extract the ONE insight, eliminate everything else.
+     */
+    private extractSingleInsight;
+    /**
+     * Chris Anderson - Gift Giving
+     * What can they DO tomorrow?
+     */
+    private extractActionableStep;
     /**
      * Create a title for a slide - uses action titles for business mode per KB
      */
@@ -1486,261 +1579,100 @@ declare class QAEngine {
 }
 
 /**
- * Seven-Dimension Presentation Scorer
+ * VisualQualityEvaluator - Evaluates presentations like a human expert.
+ *
+ * THIS IS NOT A LINTER. This evaluates:
+ * - Is this slide visually compelling?
+ * - Does the presentation tell a coherent story?
+ * - Would an executive be impressed?
+ * - Does it look like McKinsey made it?
  *
- * Comprehensive scoring across all quality dimensions using Knowledge Base rules.
- * Each dimension scored 0-100, overall score is weighted average.
+ * Uses Playwright to render and screenshot each slide, then evaluates
+ * the ACTUAL visual output, not just data structures.
  *
- * 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
+ * @version 9.0.0
  */
-
-interface DimensionScore {
-    name: string;
-    score: number;
-    weight: number;
-    issues: DimensionIssue[];
-    details: Record<string, unknown>;
-}
-interface DimensionIssue {
+interface SlideVisualScore {
     slideIndex: number;
-    dimension: string;
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    currentValue?: unknown;
-    expectedValue?: unknown;
-    autoFixable: boolean;
-    fixSuggestion?: string;
-}
-interface SevenDimensionResult {
+    slideType: string;
+    visualImpact: number;
+    visualImpactNotes: string;
+    contentClarity: number;
+    contentClarityNotes: string;
+    professionalPolish: number;
+    professionalPolishNotes: string;
+    themeCoherence: number;
+    themeCoherenceNotes: string;
+    totalScore: number;
+    screenshotPath?: string;
+}
+interface PresentationQualityScore {
     overallScore: number;
-    dimensions: {
-        layout: DimensionScore;
-        contrast: DimensionScore;
-        graphics: DimensionScore;
-        content: DimensionScore;
-        clarity: DimensionScore;
-        effectiveness: DimensionScore;
-        consistency: DimensionScore;
+    narrativeFlow: {
+        score: number;
+        hasStrongOpening: boolean;
+        hasCompellingMiddle: boolean;
+        hasMemorableClose: boolean;
+        storyArcComplete: boolean;
+        notes: string;
     };
-    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;
+    visualConsistency: {
+        score: number;
+        colorPaletteConsistent: boolean;
+        typographyConsistent: boolean;
+        layoutPatternsConsistent: boolean;
+        professionalLook: boolean;
+        notes: string;
     };
-    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;
+    contentQuality: {
+        score: number;
+        messagesAreClear: boolean;
+        appropriateDepth: boolean;
+        noOverload: boolean;
+        actionableInsights: boolean;
+        notes: string;
+    };
+    executiveReadiness: {
+        score: number;
+        wouldImpress: boolean;
+        readyForBoardroom: boolean;
+        compelling: boolean;
+        shareworthy: boolean;
+        notes: string;
+    };
+    slideScores: SlideVisualScore[];
+    verdict: 'world-class' | 'professional' | 'acceptable' | 'needs-work' | 'poor';
+    verdictExplanation: string;
+    topIssues: string[];
+    topStrengths: string[];
 }
-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>;
+declare class VisualQualityEvaluator {
+    private browser;
+    private page;
+    private screenshotDir;
+    constructor(screenshotDir?: string);
     /**
-     * Generate a comprehensive report.
+     * Evaluate a presentation's visual quality.
+     * This opens the HTML in a real browser and evaluates each slide.
      */
-    private generateReport;
-}
-/**
- * Create an IterativeQAEngine instance.
- */
-declare function createIterativeQAEngine(mode: 'keynote' | 'business', presentationType: PresentationType, config: PresentationConfig): IterativeQAEngine;
+    evaluate(htmlPath: string): Promise<PresentationQualityScore>;
+    private launchBrowser;
+    private closeBrowser;
+    private getSlideCount;
+    private evaluateSlide;
+    private scoreSlide;
+    private inferSlideType;
+    private evaluateNarrativeFlow;
+    private evaluateVisualConsistency;
+    private evaluateContentQuality;
+    private evaluateExecutiveReadiness;
+    private determineVerdict;
+    private explainVerdict;
+    private extractTopIssuesAndStrengths;
+    generateReport(result: PresentationQualityScore): string;
+    private scoreBar;
+}
+declare function evaluatePresentation(htmlPath: string, screenshotDir?: string): Promise<PresentationQualityScore>;
 
 /**
  * Reveal.js Generator - HTML Presentation Output
@@ -2178,17 +2110,22 @@ declare function generate(config: PresentationConfig): Promise<PresentationResul
  * @param options - Validation options
  * @returns QA validation results
  */
-declare function validate(presentation: string | Buffer, options?: {
-    mode?: 'keynote' | 'business';
+/**
+ * Validate an existing HTML presentation using visual quality evaluation.
+ * This uses Playwright to render the presentation and evaluate it visually.
+ *
+ * @param htmlPath - Path to the HTML presentation file
+ * @param options - Validation options
+ * @returns Visual quality evaluation results
+ */
+declare function validate(htmlPath: string, options?: {
+    screenshotDir?: string;
     threshold?: number;
-    strictMode?: boolean;
-}): Promise<QAResults & {
-    score: number;
-}>;
+}): Promise<PresentationQualityScore>;
 /**
  * Get the version of the package.
  */
-declare const VERSION = "7.1.0";
+declare const VERSION = "9.0.0";
 /**
  * Default export for convenience.
  */
@@ -2200,4 +2137,4 @@ declare const _default: {
     VERSION: string;
 };
 
-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, type LegacySlide, 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 SevenDimensionQAResult, 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 };
+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 ContentPattern, ContentPatternClassifier, 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, type LegacySlide, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode$1 as PresentationMode, type PresentationQualityScore, type PresentationResult, type PresentationType, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type ScoringWeights, type SevenDimensionQAResult, 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, VisualQualityEvaluator, createDefaultChartProvider, createDefaultImageProvider, createSlideFactory, _default as default, evaluatePresentation, generate, getKnowledgeGateway, initSlideGenerator, validate };