claude-presentation-master 4.3.0 → 4.4.0

package/dist/index.d.ts

@@ -1,237 +1,269 @@
 /**
  * Claude Presentation Master - Type Definitions
- *
- * Clean rewrite: All types for KB-driven presentation generation.
- * Every decision comes from the Knowledge Base - no hardcoded fallbacks.
- */
-/**
- * The 7 distinct presentation types, each with its own validation rules.
- * These come from KB path: presentation_types.<type>
- */
-type PresentationType = 'ted_keynote' | 'sales_pitch' | 'consulting_deck' | 'investment_banking' | 'investor_pitch' | 'technical_presentation' | 'all_hands';
-/**
- * Legacy mode for backwards compatibility
+ * @module types
  */
 type PresentationMode = 'keynote' | 'business';
 type OutputFormat = 'html' | 'pptx';
-type SlideType$1 = 'title' | 'title_impact' | 'agenda' | 'section_divider' | 'thank_you' | 'single_statement' | 'big_idea' | 'big_number' | 'full_image' | 'quote' | 'star_moment' | 'call_to_action' | 'three_points' | 'bullet_points' | 'two_column' | 'three_column' | 'comparison' | 'timeline' | 'process' | 'metrics_grid' | 'data_insight' | 'problem_statement' | 'solution_overview' | 'social_proof' | 'testimonial' | 'pricing' | 'demo_screenshot' | 'executive_summary_scr' | 'mece_breakdown' | 'recommendation' | 'risks_mitigation' | 'next_steps' | 'credentials' | 'valuation_summary' | 'football_field' | 'comparable_companies' | 'precedent_transactions' | 'dcf_summary' | 'waterfall_bridge' | 'sources_uses' | 'situation_overview' | 'risk_factors' | 'process_timeline';
+type ThemeName = 'default' | 'light-corporate' | 'modern-tech' | 'minimal' | 'warm' | 'creative';
+interface PresentationConfig {
+    /** Input content (Markdown, JSON, YAML, or plain text) */
+    content: string;
+    /** Content format */
+    contentType: 'markdown' | 'json' | 'yaml' | 'text';
+    /** Presentation mode: keynote (6-25 words/slide) or business (40-80 words/slide) */
+    mode: PresentationMode;
+    /** Output formats to generate */
+    format: OutputFormat[];
+    /** Visual theme */
+    theme?: ThemeName;
+    /** Minimum QA score required (0-100, default: 95) */
+    qaThreshold?: number;
+    /** Skip QA validation (NOT RECOMMENDED) */
+    skipQA?: boolean;
+    /** Presentation title */
+    title: string;
+    /** Author name */
+    author?: string;
+    /** Subject/description */
+    subject?: string;
+    /** Output directory */
+    output?: string;
+    /** Minify HTML output */
+    minify?: boolean;
+    /** Custom CSS to inject */
+    customCSS?: string;
+    /** Custom Handlebars templates */
+    customTemplates?: Record<string, 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 {
     /** Slide index (0-based) */
     index: number;
-    /** Slide type from KB */
-    type: SlideType$1;
-    /** Slide content */
+    /** Slide type */
+    type: SlideType;
+    /** Slide data for template rendering */
     data: SlideData;
-    /** Slide-level score (must be >= 95) */
-    score?: SlideScore;
+    /** CSS classes to apply */
+    classes?: string[];
+    /** Custom styles */
+    styles?: Record<string, string>;
     /** Speaker notes */
     notes?: string;
 }
 interface SlideData {
-    /** Main title (action title for consulting, emotional for keynote) */
+    /** Main title */
     title?: string;
     /** Subtitle */
     subtitle?: string;
-    /** Body text */
+    /** Body content */
     body?: string;
     /** Bullet points */
     bullets?: string[];
-    /** Key message / takeaway */
+    /** Key message */
     keyMessage?: string;
+    /** Images */
+    images?: ImageData[];
+    /** Metrics/KPIs */
+    metrics?: MetricData[];
     /** Quote text */
     quote?: string;
     /** Quote attribution */
     attribution?: string;
-    /** Metrics for metrics_grid */
-    metrics?: MetricData$1[];
-    /** Source citation (required for consulting/IB) */
+    /** Source citation */
     source?: string;
-    /** Callout text (for data slides) */
-    callout?: string;
-    /** Background image path (local file or URL) */
-    image?: string;
     /** Additional custom data */
     [key: string]: unknown;
 }
-interface MetricData$1 {
+interface ImageData {
+    src: string;
+    alt: string;
+    caption?: string;
+}
+interface MetricData {
     value: string | number;
     label: string;
     change?: string;
     trend?: 'up' | 'down' | 'neutral';
 }
-interface SlideScore {
-    /** Total score (0-100) - must be >= 95 */
-    total: number;
-    /** Visual quality score (weighted per type) */
-    visual: CategoryScore;
-    /** Content quality score (weighted per type) */
-    content: CategoryScore;
-    /** Expert compliance score (weighted per type) */
-    expert: CategoryScore;
-    /** Accessibility score (weighted per type) */
-    accessibility: CategoryScore;
-    /** Did this slide pass? */
+interface QAResults {
+    /** Visual quality results */
+    visual: VisualQAResults;
+    /** Content quality results */
+    content: ContentQAResults;
+    /** Expert methodology compliance */
+    expert: ExpertQAResults;
+    /** Accessibility compliance */
+    accessibility: AccessibilityResults;
+    /** Overall pass/fail */
     passed: boolean;
-    /** Specific violations found */
-    violations: Violation[];
-}
-interface CategoryScore {
-    /** Raw score (0-100) */
-    score: number;
-    /** Weight for this category (from KB) */
-    weight: number;
-    /** Weighted contribution to total */
-    weighted: number;
-    /** Checks that passed */
-    passed: string[];
-    /** Checks that failed */
-    failed: string[];
-}
-interface Violation {
-    /** Severity level */
-    severity: 'critical' | 'major' | 'minor';
-    /** Category */
-    category: 'visual' | 'content' | 'expert' | 'accessibility';
-    /** KB path that was violated */
-    kbPath: string;
-    /** What was expected (from KB) */
-    expected: string;
-    /** What was found */
-    actual: string;
-    /** How to fix it */
-    fix: string;
+    /** List of issues found */
+    issues: QAIssue[];
 }
-interface DeckScore {
-    /** Overall deck score (0-100) */
-    total: number;
-    /** Individual slide scores */
-    slideScores: SlideScore[];
-    /** Holistic checks */
-    holistic: HolisticScore;
-    /** Did the deck pass? */
+interface VisualQAResults {
+    /** Whitespace percentage (target: 35%+ keynote, 25%+ business) */
+    whitespacePercentage: number;
+    /** Layout balance score (0-1) */
+    layoutBalance: number;
+    /** Contrast ratio (target: 4.5+) */
+    contrastRatio: number;
+    /** Number of font families used (target: ≤2) */
+    fontFamilies: number;
+    /** Number of colors used */
+    colorCount: number;
+    /** Screenshots of each slide */
+    screenshots: Buffer[];
+    /** Per-slide visual scores */
+    perSlide: SlideVisualScore[];
+}
+interface SlideVisualScore {
+    slideIndex: number;
+    whitespace: number;
+    balance: number;
+    contrast: number;
     passed: boolean;
-    /** Deck-level violations */
-    violations: Violation[];
+    issues: string[];
 }
-interface HolisticScore {
-    /** Narrative flow (Sparkline, SCQA) */
-    narrativeFlow: number;
-    /** Visual consistency */
-    visualConsistency: number;
-    /** Has required elements (STAR moment, CTA, etc.) */
-    requiredElements: number;
-    /** No anti-patterns */
-    antiPatternFree: number;
+interface ContentQAResults {
+    /** Per-slide content analysis */
+    perSlide: SlideContentScore[];
+    /** Glance test results */
+    glanceTest: GlanceTestResult[];
+    /** Signal-to-noise ratio results */
+    signalNoise: SignalNoiseResult[];
+    /** One idea per slide validation */
+    oneIdea: OneIdeaResult[];
+}
+interface SlideContentScore {
+    slideIndex: number;
+    wordCount: number;
+    withinLimit: boolean;
+    hasActionTitle: boolean;
+    issues: string[];
 }
-interface KBPresentationType {
-    id: PresentationType;
-    name: string;
-    description: string;
-    use_for: string[];
-    primary_experts: string[];
-    validation_rules: KBValidationRules;
-    slide_types_allowed: string[];
-    required_elements: string[];
-    anti_patterns: string[];
-    color_palette: string;
-    typography: KBTypography;
-    scoring_weights: KBScoringWeights;
+interface GlanceTestResult {
+    slideIndex: number;
+    keyMessage: string;
+    wordCount: number;
+    readingTime: number;
+    passed: boolean;
+    recommendation?: string;
 }
-interface KBValidationRules {
-    words_per_slide: {
-        min: number;
-        max: number;
-        ideal: number;
-    };
-    whitespace: {
-        min: number;
-        ideal: number;
-        max?: number;
-    };
-    bullets_per_slide: {
-        max: number;
-    };
-    action_titles_required: boolean;
-    sources_required: boolean;
-    callouts_required?: boolean;
-    dense_data_allowed?: boolean;
+interface SignalNoiseResult {
+    slideIndex: number;
+    signalCount: number;
+    noiseCount: number;
+    signalRatio: number;
+    passed: boolean;
+    noiseElements: string[];
 }
-interface KBTypography {
-    titles?: string;
-    body?: string;
-    action_title?: string;
-    section_headers?: string;
-    data_labels?: string;
-    max_fonts: number;
+interface OneIdeaResult {
+    slideIndex: number;
+    ideaCount: number;
+    mainIdea: string;
+    passed: boolean;
+    conflictingIdeas?: string[];
+}
+interface ExpertQAResults {
+    /** Nancy Duarte validation */
+    duarte: ExpertValidation;
+    /** Garr Reynolds validation */
+    reynolds: ExpertValidation;
+    /** Carmine Gallo validation */
+    gallo: ExpertValidation;
+    /** Chris Anderson validation */
+    anderson: ExpertValidation;
+}
+interface ExpertValidation {
+    expertName: string;
+    principlesChecked: string[];
+    passed: boolean;
+    score: number;
+    violations: string[];
+}
+interface AccessibilityResults {
+    /** WCAG compliance level achieved */
+    wcagLevel: 'A' | 'AA' | 'AAA' | 'FAIL';
+    /** Contrast issues found */
+    contrastIssues: ContrastIssue[];
+    /** Font size issues */
+    fontSizeIssues: FontSizeIssue[];
+    /** Focus state coverage */
+    focusCoverage: number;
+    /** Color-blind safety */
+    colorBlindSafe: boolean;
+}
+interface ContrastIssue {
+    slideIndex: number;
+    element: string;
+    foreground: string;
+    background: string;
+    ratio: number;
+    required: number;
 }
-interface KBScoringWeights {
-    visual_quality: number;
-    content_quality: number;
-    expert_compliance: number;
-    accessibility: number;
+interface FontSizeIssue {
+    slideIndex: number;
+    element: string;
+    actualSize: number;
+    minimumSize: number;
+}
+interface QAIssue {
+    /** Issue severity */
+    severity: 'error' | 'warning' | 'info';
+    /** Issue category */
+    category: 'visual' | 'content' | 'expert' | 'accessibility';
+    /** Slide index (if applicable) */
+    slideIndex?: number;
+    /** Issue description */
+    message: string;
+    /** Suggested fix */
+    suggestion?: string;
 }
-interface KBScoringRubric {
-    total_points: number;
-    passing_threshold: number;
-    categories: {
-        visual_quality: KBScoringCategory;
-        content_quality: KBScoringCategory;
-        expert_compliance: KBScoringCategory;
-        accessibility: KBScoringCategory;
+interface PresentationResult {
+    /** Generated outputs */
+    outputs: {
+        html?: string;
+        pptx?: Buffer;
     };
+    /** QA validation results */
+    qaResults: QAResults;
+    /** Overall QA score (0-100) */
+    score: number;
+    /** Presentation metadata */
+    metadata: PresentationMetadata;
 }
-interface KBScoringCategory {
-    weight: number;
-    checks: Record<string, KBCheck>;
-}
-interface KBCheck {
-    points: number;
-    description: string;
-    validation?: string;
-}
-interface KBExpert {
-    name: string;
-    core_principles: Record<string, KBPrinciple>;
-}
-interface KBPrinciple {
-    description: string;
-    rules?: string[];
-    examples?: string[];
+interface PresentationMetadata {
+    /** Presentation title */
+    title: string;
+    /** Author */
+    author: string;
+    /** Generation timestamp */
+    generatedAt: string;
+    /** Presentation mode */
+    mode: PresentationMode;
+    /** Total slide count */
+    slideCount: number;
+    /** Total word count */
+    wordCount: number;
+    /** Average words per slide */
+    avgWordsPerSlide: number;
+    /** Estimated presentation duration (minutes) */
+    estimatedDuration: number;
+    /** Themes/frameworks used */
+    frameworks: string[];
 }
 interface ContentAnalysis {
-    /** Detected presentation type */
-    detectedType: PresentationType;
-    /** Extracted title */
-    title: string;
-    /** Sections found */
-    sections: ContentSection[];
-    /** Key messages */
+    /** SCQA structure extracted */
+    scqa: SCQAStructure;
+    /** Sparkline narrative arc */
+    sparkline: SparklineStructure;
+    /** Key messages identified */
     keyMessages: string[];
-    /** Data points (metrics, percentages) */
-    dataPoints: DataPoint[];
-    /** SCQA structure if detected */
-    scqa?: SCQAStructure;
-    /** Sparkline moments */
-    sparkline?: SparklineStructure;
-}
-interface ContentSection {
-    /** Section header */
-    header: string;
-    /** Header level (1-6) */
-    level: number;
-    /** Raw content */
-    content: string;
-    /** Extracted bullets */
-    bullets: string[];
-    /** Metrics in this section */
-    metrics: DataPoint[];
-}
-interface DataPoint {
-    value: string;
-    numericValue?: number;
-    type: 'currency' | 'percentage' | 'number' | 'time';
-    context: string;
-    label?: string;
+    /** Generated action titles */
+    titles: string[];
+    /** STAR moments identified */
+    starMoments: string[];
+    /** Estimated slide count */
+    estimatedSlideCount: number;
 }
 interface SCQAStructure {
     situation: string;
@@ -242,1802 +274,936 @@ interface SCQAStructure {
 interface SparklineStructure {
     whatIs: string[];
     whatCouldBe: string[];
-    starMoment?: string;
     callToAdventure: string;
 }
-interface PresentationResult {
-    /** Generated outputs */
-    outputs: {
-        html?: string;
-        pptx?: Buffer;
-    };
-    /** Slides generated */
-    slides: Slide[];
-    /** Final deck score */
-    score: DeckScore;
-    /** Metadata */
-    metadata: PresentationMetadata;
+declare class ValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[], message?: string);
 }
-interface PresentationMetadata {
-    title: string;
-    author: string;
-    presentationType: PresentationType;
-    generatedAt: string;
-    slideCount: number;
-    totalWords: number;
-    avgWordsPerSlide: number;
-    kbVersion: string;
+declare class QAFailureError extends Error {
+    score: number;
+    threshold: number;
+    qaResults: QAResults;
+    constructor(score: number, threshold: number, qaResults: QAResults, message?: string);
+    getIssues(): string[];
+}
+declare class TemplateNotFoundError extends Error {
+    templatePath: string;
+    constructor(templatePath: string, message?: string);
 }
 
 /**
- * KnowledgeGateway - Single Point of Access to the Knowledge Base
+ * Presentation Engine - Main Orchestrator
  *
- * CRITICAL DESIGN PRINCIPLE: NO FALLBACKS
- * If data is missing from KB, we FAIL with a clear error.
- * Every decision in this application comes from the KB.
+ * Coordinates content analysis, slide generation, and QA validation
+ * to produce world-class presentations.
  */
 
-/**
- * Result wrapper that includes KB path for debugging
- */
-interface KBResult<T> {
-    value: T;
-    kbPath: string;
-}
-/**
- * KnowledgeGateway - The ONLY way to access KB data
- */
-declare class KnowledgeGateway {
-    private data;
-    private loaded;
-    private version;
-    /**
-     * Load the knowledge base from YAML.
-     * MUST be called before any queries.
-     */
-    load(): Promise<void>;
-    /**
-     * Get KB version
-     */
-    getVersion(): string;
-    /**
-     * Get complete presentation type configuration.
-     * @throws KBQueryError if type not found
-     */
-    getPresentationType(type: PresentationType): KBResult<KBPresentationType>;
-    /**
-     * Get validation rules for a presentation type.
-     * @throws KBQueryError if rules not found
-     */
-    getValidationRules(type: PresentationType): KBResult<KBValidationRules>;
-    /**
-     * Get word limits for a presentation type.
-     */
-    getWordLimits(type: PresentationType): KBResult<{
-        min: number;
-        max: number;
-        ideal: number;
-    }>;
-    /**
-     * Get whitespace requirements.
-     */
-    getWhitespaceRules(type: PresentationType): KBResult<{
-        min: number;
-        ideal: number;
-        max?: number;
-    }>;
-    /**
-     * Get scoring weights for a presentation type.
-     */
-    getScoringWeights(type: PresentationType): KBResult<KBScoringWeights>;
-    /**
-     * Get allowed slide types for a presentation type.
-     */
-    getAllowedSlideTypes(type: PresentationType): KBResult<string[]>;
-    /**
-     * Get required elements for a presentation type.
-     */
-    getRequiredElements(type: PresentationType): KBResult<string[]>;
-    /**
-     * Get anti-patterns to avoid for a presentation type.
-     */
-    getAntiPatterns(type: PresentationType): KBResult<string[]>;
-    /**
-     * Get the scoring rubric.
-     */
-    getScoringRubric(): KBResult<KBScoringRubric>;
-    /**
-     * Get passing threshold (default: 95).
-     */
-    getPassingThreshold(): KBResult<number>;
-    /**
-     * Get expert methodology.
-     */
-    getExpert(name: string): KBResult<KBExpert>;
+declare class PresentationEngine {
+    private contentAnalyzer;
+    private slideFactory;
+    private templateEngine;
+    private scoreCalculator;
+    private qaEngine;
+    private htmlGenerator;
+    private pptxGenerator;
+    constructor();
     /**
-     * Get Nancy Duarte's glance test rules.
+     * Generate a presentation from content.
+     *
+     * @param config - Presentation configuration
+     * @returns Presentation result with outputs, QA results, and score
      */
-    getGlanceTest(): KBResult<{
-        description: string;
-        word_limit: number;
-    }>;
+    generate(config: PresentationConfig): Promise<PresentationResult>;
     /**
-     * Get Duarte's Sparkline framework.
+     * Validate presentation configuration.
      */
-    getSparkline(): KBResult<Record<string, unknown>>;
+    private validateConfig;
     /**
-     * Get Minto's SCQA framework.
+     * Validate slide structure before generation.
      */
-    getSCQA(): KBResult<Record<string, unknown>>;
+    private validateStructure;
     /**
-     * Get Miller's Law (7±2 items).
+     * Count words in a slide.
      */
-    getMillersLaw(): KBResult<{
-        principle: string;
-        application: string[];
-    }>;
+    private countWords;
     /**
-     * Get accessibility requirements.
+     * Build presentation metadata.
      */
-    getAccessibilityRules(): KBResult<Record<string, unknown>>;
+    private buildMetadata;
     /**
-     * Get contrast ratio requirements.
+     * Detect which expert frameworks were applied.
      */
-    getContrastRequirements(): KBResult<{
-        normal_text: string;
-        large_text: string;
-    }>;
+    private detectFrameworks;
+}
+
+/**
+ * Content Analyzer - Extracts Structure from Raw Content
+ *
+ * Uses expert methodologies to analyze content and extract:
+ * - SCQA structure (Barbara Minto)
+ * - Sparkline narrative arc (Nancy Duarte)
+ * - Key messages (Rule of Three)
+ * - STAR moments
+ * - Action titles
+ */
+
+declare class ContentAnalyzer {
+    private readonly situationSignals;
+    private readonly complicationSignals;
+    private readonly questionSignals;
+    private readonly answerSignals;
+    private readonly whatIsSignals;
+    private readonly whatCouldBeSignals;
     /**
-     * Get minimum font sizes.
+     * Analyze content and extract structural elements.
      */
-    getFontSizeRequirements(): KBResult<Record<string, string>>;
+    analyze(content: string, contentType: string): Promise<ContentAnalysis>;
     /**
-     * Get Tufte's data-ink ratio rules.
+     * Parse content based on its type.
      */
-    getDataInkRules(): KBResult<Record<string, unknown>>;
+    private parseContent;
     /**
-     * Get chartjunk to avoid.
+     * Parse markdown content to plain text (preserving structure hints).
      */
-    getChartjunk(): KBResult<string[]>;
+    private parseMarkdown;
     /**
-     * Get Cialdini's 6 Principles of Influence.
+     * Parse JSON content.
      */
-    getCialdiniPrinciples(): KBResult<Record<string, unknown>>;
+    private parseJSON;
     /**
-     * Get specific Cialdini principle by name.
+     * Parse YAML content.
      */
-    getCialdiniPrinciple(name: string): KBResult<Record<string, unknown>>;
+    private parseYAML;
     /**
-     * Get all Gestalt principles.
+     * Flatten object to text.
      */
-    getGestaltPrinciples(): KBResult<Record<string, unknown>>;
+    private flattenObject;
     /**
-     * Get specific Gestalt principle by name.
+     * Split text into paragraphs.
      */
-    getGestaltPrinciple(name: string): KBResult<Record<string, unknown>>;
+    private splitIntoParagraphs;
     /**
-     * Get Gestalt proximity principle (for layout checks).
+     * Split text into sentences.
      */
-    getGestaltProximity(): KBResult<Record<string, unknown>>;
+    private splitIntoSentences;
     /**
-     * Get Gestalt similarity principle (for consistency checks).
+     * Extract SCQA structure (Barbara Minto's Pyramid Principle).
      */
-    getGestaltSimilarity(): KBResult<Record<string, unknown>>;
+    private extractSCQA;
     /**
-     * Get Gestalt figure-ground principle (for visual impact checks).
+     * Extract Sparkline structure (Nancy Duarte).
      */
-    getGestaltFigureGround(): KBResult<Record<string, unknown>>;
+    private extractSparkline;
     /**
-     * Query any KB path directly.
-     * @throws KBQueryError if path not found
+     * Extract key messages (max 3 - Rule of Three).
      */
-    queryRequired<T>(path: string): KBResult<T>;
+    private extractKeyMessages;
     /**
-     * Query any KB path directly (optional - returns null if not found).
+     * Generate action titles (McKinsey-style).
      */
-    queryOptional<T>(path: string): KBResult<T | null>;
+    private generateActionTitles;
     /**
-     * Ensure KB is loaded.
+     * Transform a statement into an action title.
      */
-    private ensureLoaded;
+    private transformToActionTitle;
     /**
-     * Query a dotted path in the KB.
+     * Identify STAR moments (Something They'll Always Remember).
      */
-    private query;
+    private identifyStarMoments;
     /**
-     * Create a KB query error.
+     * Estimate slide count based on content.
      */
-    private error;
+    private estimateSlideCount;
+    private containsSignals;
+    private extractRelevantSentence;
+    private truncateToSentence;
+    private truncateToWords;
+    private capitalizeFirst;
 }
-/**
- * Get the singleton KnowledgeGateway instance.
- */
-declare function getKB(): KnowledgeGateway;
-/**
- * Initialize and return the KB (async).
- */
-declare function initKB(): Promise<KnowledgeGateway>;
 
 /**
- * ContentAnalyzer - Parse and Analyze Input Content
+ * Slide Factory - Creates Slides from Content Analysis
  *
- * Parses markdown/text input and extracts:
- * - Sections with headers
- * - Bullets and key points
- * - Data points (metrics, percentages, currencies)
- * - Detects presentation type from content signals
- * - Identifies SCQA structure if present
- * - Identifies Sparkline moments
+ * Generates slide structures based on:
+ * - Presentation mode (keynote vs business)
+ * - Content analysis results
+ * - Expert methodology recommendations
  */
 
-declare class ContentAnalyzer {
-    private kb;
-    private initialized;
+declare class SlideFactory {
+    private readonly templates;
     constructor();
-    initialize(): Promise<void>;
     /**
-     * Analyze content and return structured analysis.
+     * Create slides from analyzed content.
      */
-    analyze(content: string, contentType?: 'markdown' | 'text'): Promise<ContentAnalysis>;
+    createSlides(analysis: ContentAnalysis, mode: PresentationMode): Promise<Slide[]>;
     /**
-     * Parse content into sections based on headers.
+     * Create a title slide.
      */
-    private parseSections;
+    private createTitleSlide;
     /**
-     * Extract title from content.
+     * Create an agenda slide.
      */
-    private extractTitle;
+    private createAgendaSlide;
     /**
-     * Extract bullet points from content.
-     * Strips markdown formatting (**bold**, *italic*, `code`) from bullet text.
+     * Create a context/situation slide.
      */
-    private extractBullets;
+    private createContextSlide;
+    /**
+     * Create a problem/complication slide.
+     */
+    private createProblemSlide;
     /**
-     * Strip markdown formatting from text.
-     * Converts **bold**, *italic*, `code`, [links](url) to plain text.
+     * Create a key message slide.
      */
-    private stripMarkdown;
+    private createMessageSlide;
     /**
-     * Extract data points (metrics, percentages, currencies, numbers).
+     * Create a STAR moment slide.
      */
-    private extractDataPoints;
+    private createStarMomentSlide;
     /**
-     * Get surrounding context for a data point.
+     * Create a solution/answer slide.
      */
-    private getContext;
+    private createSolutionSlide;
     /**
-     * Parse numeric value from string (handles M/B/K suffixes).
+     * Create a call-to-action slide.
      */
-    private parseNumericValue;
+    private createCTASlide;
     /**
-     * Extract key messages from sections.
+     * Create a thank you slide.
      */
-    private extractKeyMessages;
+    private createThankYouSlide;
     /**
-     * Detect presentation type based on content signals.
+     * Initialize slide templates with constraints.
      */
-    private detectPresentationType;
+    private initializeTemplates;
     /**
-     * Identify SCQA (Situation, Complication, Question, Answer) structure.
+     * Truncate text to max length at word boundary.
      */
-    private identifySCQA;
+    private truncate;
     /**
-     * Identify Sparkline (What Is / What Could Be) structure.
+     * Extract an action title from a message.
      */
-    private identifySparkline;
+    private extractActionTitle;
+    /**
+     * Extract bullet points from text.
+     */
+    private extractBullets;
+    /**
+     * Remove a statistic from text.
+     */
+    private removeStatistic;
 }
-declare function getContentAnalyzer(): ContentAnalyzer;
-declare function initContentAnalyzer(): Promise<ContentAnalyzer>;
 
 /**
- * SlideGenerator - Generate Slides with Visual Intent
- *
- * Takes ContentAnalysis and generates slides with:
- * - Appropriate slide types based on content
- * - Visual intent (emphasis, layout hints)
- * - Respect for KB word limits and rules
- * - SCQA/Sparkline narrative structure when detected
+ * Template Engine - Handlebars Template Rendering
  *
- * DESIGN PHILOSOPHY:
- * - All type-specific rules (word limits, allowed slide types) come from KB
- * - Defensive fallbacks exist for edge cases (e.g., bullet limit defaults to 5)
- * - Slide structure decisions (agenda, section dividers) are algorithmic
+ * Renders slide data into HTML using Handlebars templates.
+ * Supports custom templates and helper functions.
  */
 
-declare class SlideGenerator {
-    private kb;
-    private vds;
-    private initialized;
-    private wordLimits;
-    private bulletLimit;
-    private allowedSlideTypes;
-    private createdSlideTitles;
-    private sectionDividerCount;
-    private readonly maxSectionDividers;
+interface TemplateConfig {
+    customTemplates?: Record<string, string>;
+    theme?: ThemeName;
+}
+declare class TemplateEngine {
+    private handlebars;
+    private templates;
+    private partials;
     constructor();
-    initialize(): Promise<void>;
-    /**
-     * Generate slides from content analysis.
-     */
-    generate(analysis: ContentAnalysis, presentationType: PresentationType): Promise<Slide[]>;
-    private loadRulesForType;
     /**
-     * Create title slide.
+     * Render a slide to HTML.
      */
-    private createTitleSlide;
-    /**
-     * Create agenda slide.
-     */
-    private createAgendaSlide;
-    /**
-     * Create SCQA slides (Situation, Complication, Question, Answer).
-     */
-    private createSCQASlides;
-    /**
-     * Create slides for a content section.
-     */
-    private createSectionSlides;
-    /**
-     * Create metrics grid slide from data points.
-     */
-    private createMetricsSlide;
-    /**
-     * Create metrics grid slide from a section.
-     */
-    private createMetricsGridSlide;
-    /**
-     * Create STAR moment slide (Something They'll Always Remember).
-     */
-    private createStarMomentSlide;
-    /**
-     * Create call to action slide.
-     */
-    private createCallToActionSlide;
-    /**
-     * Create thank you / closing slide.
-     */
-    private createThankYouSlide;
-    /**
-     * Determine the best slide type for a section.
-     */
-    private determineSlideType;
-    /**
-     * Check if presentation type favors minimal slides.
-     */
-    private isMinimalType;
+    render(slide: Slide, config?: TemplateConfig): string;
     /**
-     * Strip all markdown syntax from text for clean slide content.
-     * This is called on ALL text going into slides to prevent raw markdown.
+     * Render multiple slides.
      */
-    private stripMarkdownSyntax;
+    renderAll(slides: Slide[], config?: TemplateConfig): string[];
     /**
-     * Clean bullets - strip markdown and preserve COMPLETE, MEANINGFUL sentences.
-     * Business presentations need full context. Never truncate mid-thought.
-     * Reasonable limit: 20 words per bullet allows complete ideas.
+     * Prepare template context with computed properties.
      */
-    private cleanBullets;
+    private prepareContext;
     /**
-     * Truncate text to word limit, stripping markdown first.
-     * Preserves complete sentences. Business content needs room to breathe.
+     * Build CSS class list for slide.
      */
-    private truncateToWordLimit;
+    private buildClassList;
     /**
-     * Extract a key statement from content (first sentence or bold text).
+     * Build inline style string.
      */
-    private extractKeyStatement;
+    private buildStyleString;
     /**
-     * Extract a key message from title and body for single_statement slides.
-     * Returns a concise, impactful message that provides substance.
+     * Register Handlebars helpers.
      */
-    private extractKeyMessage;
+    private registerHelpers;
     /**
-     * Extract a label from context (nearby text around a data point).
-     * CRITICAL: Strip all markdown table syntax first to avoid garbage labels.
+     * Register reusable partials.
      */
-    private extractLabelFromContext;
+    private registerPartials;
     /**
-     * Detect trend from context (up, down, neutral).
+     * Compile built-in templates.
      */
-    private detectTrend;
+    private compileTemplates;
     /**
-     * Split array into chunks.
+     * Render fallback for unknown slide types.
      */
-    private chunkArray;
+    private renderFallback;
     /**
-     * Generate meaningful titles for chunked bullet lists.
-     * Instead of "Title (continued)", create contextual subtitles.
+     * Convert camelCase to kebab-case.
      */
-    private generateChunkTitles;
-    /**
-     * Extract a meaningful subtitle from bullet content.
-     */
-    private extractSubtitleFromBullets;
+    private kebabCase;
 }
-declare function getSlideGenerator(): SlideGenerator;
-declare function initSlideGenerator(): Promise<SlideGenerator>;
 
 /**
- * SlideGenerator V2 - Simple, Correct, No Garbage
+ * Score Calculator - QA Score Computation
  *
- * Philosophy:
- * 1. Don't be clever - if it's hard, don't do it
- * 2. Preserve source truth - tables stay tables, bullets stay complete
- * 3. Fail loudly - reject garbage, don't score it 93/100
- * 4. Content is the hero - never truncate meaning
- *
- * This replaces the 945-line monster that produced garbage.
+ * Calculates presentation quality scores based on:
+ * - Visual quality (35%)
+ * - Content quality (30%)
+ * - Expert methodology compliance (25%)
+ * - Accessibility (10%)
  */
 
-interface SlideV2 {
-    index: number;
-    type: SlideType;
-    title: string;
-    content: SlideContent;
-    notes?: string;
-}
-type SlideType = 'title' | 'section' | 'bullets' | 'table' | 'metrics' | 'statement' | 'call_to_action' | 'thank_you';
-interface SlideContent {
-    bullets?: string[];
-    table?: TableData;
-    metrics?: MetricData[];
-    statement?: string;
-    subtext?: string;
-    body?: string;
-    source?: string;
-}
-interface TableData {
-    headers: string[];
-    rows: string[][];
-    caption?: string;
-}
-interface MetricData {
-    value: string;
-    label: string;
-    trend?: 'up' | 'down' | 'neutral';
+interface ScoreBreakdown {
+    visual: number;
+    content: number;
+    expert: number;
+    accessibility: number;
+    total: number;
+    penalties: number;
+    details: ScoreDetail[];
 }
-interface ModeConfig {
-    maxBulletsPerSlide: number;
-    maxWordsPerSlide: number;
-    minBulletsToKeep: number;
+interface ScoreDetail {
+    category: string;
+    check: string;
+    score: number;
+    maxScore: number;
+    notes?: string;
 }
-declare class SlideGeneratorV2 {
-    private config;
-    private presentationType;
-    /**
-     * Create a slide generator with default configs.
-     * For KB-driven configs, use createSlideGeneratorV2WithConfig() instead.
-     */
-    constructor(presentationType?: PresentationType);
+declare class ScoreCalculator {
+    private readonly weights;
     /**
-     * Override config with KB-loaded values at runtime.
+     * Calculate overall QA score from results.
      */
-    setConfig(config: ModeConfig): void;
+    calculate(results: QAResults): number;
     /**
-     * Get current config (useful for debugging).
+     * Get detailed score breakdown.
      */
-    getConfig(): ModeConfig;
+    getBreakdown(results: QAResults): ScoreBreakdown;
     /**
-     * Generate slides from markdown content.
-     * Simple, correct, no garbage.
+     * Calculate visual quality score.
      */
-    generate(markdown: string, title?: string): SlideV2[];
+    private calculateVisualScore;
     /**
-     * Extract title from first H1 token.
+     * Calculate content quality score.
      */
-    private extractTitle;
+    private calculateContentScore;
     /**
-     * Split tokens into sections based on H2 headers.
+     * Calculate expert methodology compliance score.
      */
-    private splitIntoSections;
+    private calculateExpertScore;
     /**
-     * Process section content into slides.
-     * RULES:
-     * 1. Tables ALWAYS become table slides - NEVER extract to metrics
-     * 2. Empty sections are SKIPPED - no blank divider slides
-     * 3. H3 headings become individual slides with ACTION TITLES (critical for consulting)
-     * 4. Sections with minimal content are combined into statement slides
+     * Calculate accessibility compliance score.
      */
-    private processSectionContent;
+    private calculateAccessibilityScore;
     /**
-     * Split tokens into subsections based on H3 headers.
-     * H3 headers become ACTION TITLES for consulting decks.
+     * Calculate penalties from issues.
      */
-    private splitIntoSubsections;
+    private calculatePenalties;
     /**
-     * Process a subsection (H3) into a slide.
-     * The H3 title IS the action title.
+     * Get human-readable grade from score.
      */
-    private processSubsection;
+    getGrade(score: number): string;
     /**
-     * Create a table slide - render the table as-is, no extraction.
+     * Get pass/fail status.
      */
-    private createTableSlide;
+    isPassing(score: number, threshold?: number): boolean;
     /**
-     * Create bullet slides from list content.
-     * RULES:
-     * 1. NEVER truncate bullets
-     * 2. NEVER create slides with only 1-2 bullets (orphan slides)
-     * 3. If there are fewer than minBulletsToKeep bullets, combine them into a statement slide
+     * Format score for display.
      */
-    private createBulletSlides;
+    formatScore(score: number): string;
     /**
-     * Split bullets into chunks without creating orphan slides.
-     * If the last chunk would have fewer than minBullets, steal from previous chunk.
+     * Generate summary report.
      */
-    private splitBulletsWithoutOrphans;
-    /**
-     * Get complete text from a list item, including nested content.
-     * NEVER truncate.
-     */
-    private getCompleteItemText;
-    /**
-     * Check if section has significant paragraph content.
-     */
-    private hasSignificantParagraphs;
-    /**
-     * Create a content slide from paragraphs.
-     */
-    private createContentSlide;
-    /**
-     * Extract a key statement from tokens.
-     */
-    private extractStatement;
-    /**
-     * VALIDATE ALL SLIDES - Fail loudly on garbage.
-     */
-    private validateSlides;
+    generateReport(results: QAResults): string;
 }
-declare function createSlideGeneratorV2(type?: PresentationType): SlideGeneratorV2;
 
 /**
- * Renderer V2 - KB-Driven Visual Excellence
+ * QA Engine - Real Visual Quality Validation
  *
- * Renders slides to HTML and PDF with:
- * - Tables as actual tables (not mangled metrics)
- * - Complete bullets (never truncated)
- * - Clean professional CSS (no random stock photos)
- * - Color palettes loaded from Knowledge Base per presentation type
- * - Typography and spacing from KB
- * - Automatic PDF generation alongside HTML
+ * Unlike fake validation systems, this engine ACTUALLY tests:
+ * - Visual quality using Playwright screenshots + Canvas API
+ * - Layout balance and whitespace distribution
+ * - WCAG contrast compliance
+ * - Expert methodology adherence
  */
 
-type ThemeStyle = 'light' | 'dark';
-declare class RendererV2 {
-    private theme;
-    private presentationType;
-    private kb;
-    /**
-     * Create renderer with theme loaded from Knowledge Base.
-     * @param presentationType - The type of deck being created (determines palette)
-     * @param kb - Knowledge Base gateway (optional, will use global if not provided)
-     */
-    constructor(presentationType?: PresentationType, kb?: KnowledgeGateway);
+declare class QAEngine {
+    private browser;
     /**
-     * Load theme configuration from Knowledge Base.
-     * Falls back to hardcoded values only if KB fails.
+     * Validate a presentation.
      */
-    private loadThemeFromKB;
+    validate(presentation: string | Buffer, options?: {
+        mode?: 'keynote' | 'business';
+        strictMode?: boolean;
+        threshold?: number;
+    }): Promise<QAResults>;
     /**
-     * Default palette mapping per presentation type (used if KB doesn't specify).
+     * Calculate overall QA score.
      */
-    private getDefaultPaletteName;
+    calculateScore(results: QAResults): number;
     /**
-     * Render slides to complete HTML document.
+     * Create empty QA results (for when QA is skipped).
      */
-    render(slides: SlideV2[], title?: string): string;
+    createEmptyResults(): QAResults;
+    private runVisualTests;
+    private runContentTests;
+    private runExpertTests;
+    private createExpertResult;
+    private runAccessibilityTests;
+    private calculateVisualScore;
+    private calculateContentScore;
+    private calculateExpertScore;
+    private calculateA11yScore;
+    private collectIssues;
+    private initBrowser;
+    private closeBrowser;
+}
+
+/**
+ * Reveal.js Generator - HTML Presentation Output
+ *
+ * Generates complete Reveal.js presentations with:
+ * - Responsive layouts
+ * - Animations
+ * - Speaker notes
+ * - Custom themes
+ * - Chart.js integration
+ * - Mermaid diagrams
+ */
+
+declare class RevealJsGenerator {
+    private templateEngine;
+    private defaultRevealConfig;
+    constructor();
     /**
-     * Render slides to both HTML and PDF files.
-     * Always generates both formats for easy sharing.
+     * Generate complete Reveal.js HTML presentation.
      */
-    renderToFiles(slides: SlideV2[], outputPath: string, title?: string): Promise<{
-        htmlPath: string;
-        pdfPath: string;
-    }>;
+    generate(slides: Slide[], config: PresentationConfig): Promise<string>;
     /**
-     * Render slides directly to PDF using Puppeteer.
-     * Creates a printable PDF with one slide per page.
+     * Build the complete HTML document.
      */
-    renderToPDF(slides: SlideV2[], outputPath: string, title?: string): Promise<Uint8Array>;
+    private buildDocument;
     /**
-     * Render HTML optimized for PDF printing (no reveal.js, static pages).
+     * Get base styles for slides.
      */
-    private renderForPrint;
+    private getBaseStyles;
     /**
-     * Light theme print HTML (professional, white background).
+     * Get theme-specific styles.
      */
-    private getLightPrintHTML;
+    private getThemeStyles;
     /**
-     * Dark theme print HTML (legacy).
+     * Get animation styles.
      */
-    private getDarkPrintHTML;
+    private getAnimationStyles;
     /**
-     * Render slide content (shared between HTML and PDF renderers).
+     * Escape HTML entities.
      */
-    private renderSlideContent;
+    private escapeHtml;
     /**
-     * Render a single slide.
+     * Basic HTML minification.
      */
-    private renderSlide;
+    private minifyHtml;
+}
+
+/**
+ * PowerPoint Generator - PPTX Presentation Output
+ *
+ * Generates PowerPoint presentations using PptxGenJS with:
+ * - Professional layouts
+ * - Embedded charts
+ * - Images
+ * - Consistent styling
+ */
+
+declare class PowerPointGenerator {
+    private chartProvider;
     /**
-     * Title slide - big, bold, centered.
+     * Generate a PowerPoint presentation.
      */
-    private renderTitleSlide;
+    generate(slides: Slide[], config: PresentationConfig): Promise<Buffer>;
     /**
-     * Section divider - transition slide.
+     * Add a slide to the presentation.
      */
-    private renderSectionSlide;
+    private addSlide;
     /**
-     * Bullet slide - the workhorse.
+     * Add title slide.
      */
-    private renderBulletSlide;
+    private addTitleSlide;
     /**
-     * Table slide - render tables properly.
+     * Add big idea / single statement slide.
      */
-    private renderTableSlide;
+    private addBigIdeaSlide;
     /**
-     * Render a table as clean HTML.
+     * Add big number slide.
      */
-    private renderTable;
+    private addBigNumberSlide;
     /**
-     * Metrics slide - big numbers with labels.
+     * Add quote slide.
      */
-    private renderMetricsSlide;
+    private addQuoteSlide;
     /**
-     * Statement slide - single powerful message.
+     * Add bullet points slide.
      */
-    private renderStatementSlide;
+    private addBulletSlide;
     /**
-     * Call to action slide.
+     * Add two-column slide.
      */
-    private renderCTASlide;
+    private addTwoColumnSlide;
     /**
-     * Thank you slide.
+     * Add metrics grid slide.
      */
-    private renderThankYouSlide;
+    private addMetricsSlide;
     /**
-     * Format bullet text - handle bold, arrows, etc.
+     * Add metrics to a slide at specified position.
      */
-    private formatBulletText;
+    private addMetricsToSlide;
     /**
-     * Escape HTML special characters.
+     * Add thank you slide.
      */
-    private escapeHtml;
+    private addThankYouSlide;
     /**
-     * Generate CSS with colors from Knowledge Base.
+     * Add agenda slide.
      */
-    private getCSS;
+    private addAgendaSlide;
     /**
-     * Generate CSS variables from KB palette.
+     * Add section divider slide.
      */
-    private getCSSVariables;
+    private addSectionDividerSlide;
     /**
-     * Lighten or darken a hex color.
+     * Add default slide (fallback).
      */
-    private lightenColor;
+    private addDefaultSlide;
     /**
-     * Light theme CSS (consulting style) with KB palette colors.
+     * Add image placeholder.
      */
-    private getLightThemeCSS;
+    private addImagePlaceholder;
     /**
-     * Dark theme CSS with KB palette colors.
+     * Convert layout position to PptxGenJS text props.
      */
-    private getDarkThemeCSS;
+    private positionToProps;
 }
-/**
- * Create a renderer with theme matched to the presentation type.
- *
- * @param presentationType - Type of deck (consulting_deck, keynote, etc.)
- * @param themeOverride - Optional explicit theme to use instead of auto-mapping
- *
- * Theme mapping:
- * - consulting_deck, board_presentation, internal_update → McKinsey (white, professional)
- * - keynote, sales_pitch, technical → Dark (dramatic)
- * - training, workshop, all_hands → Minimal (clean, readable)
- * - product_demo, investor_pitch → Startup (modern dark)
- * - executive_briefing → Corporate (professional)
- */
-declare function createRendererV2(presentationType?: PresentationType, kb?: KnowledgeGateway): RendererV2;
 
 /**
- * VisualQAEngine - REAL Visual Quality Assurance
- *
- * This is NOT a rule checker. This SEES the actual rendered presentation.
+ * Image Provider - Pluggable Image Generation
  *
- * How it works:
- * 1. Playwright renders the HTML presentation
- * 2. Screenshots each slide at 1920x1080
- * 3. Analyzes screenshots with:
- *    - Pixel-based whitespace calculation
- *    - Color contrast checking (WCAG)
- *    - Text density measurement
- *    - Visual balance assessment
- * 4. Vision API for qualitative "would you present this?" check
- * 5. Scores against KB criteria
- * 6. Provides specific visual feedback
- * 7. Loops until 95+ or max iterations
- *
- * This is the REAL QA that evaluates what the audience SEES.
+ * Provides multiple strategies for obtaining images:
+ * - Local: User-provided paths/URLs
+ * - Placeholder: Uses picsum.photos (no API key)
+ * - Unsplash: Free API (50 req/hour, optional key)
+ * - AI: Claude Code integration (when available)
  */
-
-interface VisualSlideAnalysis {
-    slideIndex: number;
-    title: string;
-    screenshot: Buffer;
-    whitespacePercentage: number;
-    textDensity: number;
-    colorContrast: number;
-    visualBalance: number;
-    glanceTestPassed: boolean;
-    hierarchyClear: boolean;
-    professionalLook: boolean;
-    score: number;
-    issues: VisualIssue[];
-    passed: boolean;
-}
-interface VisualIssue {
-    severity: 'critical' | 'major' | 'minor';
-    category: 'whitespace' | 'contrast' | 'density' | 'balance' | 'hierarchy' | 'professional';
-    issue: string;
-    measurement?: number;
-    threshold?: number;
-    fix: string;
+interface ImageRequest {
+    /** Description of desired image */
+    description: string;
+    /** Desired width */
+    width?: number;
+    /** Desired height */
+    height?: number;
+    /** Style hints (e.g., 'professional', 'minimal', 'vibrant') */
+    style?: string;
+    /** Category for filtering (e.g., 'business', 'technology', 'nature') */
+    category?: string;
+}
+interface ImageResult {
+    /** URL or data URI of the image */
+    src: string;
+    /** Alt text for accessibility */
+    alt: string;
+    /** Attribution if required */
+    attribution?: string;
+    /** Whether this is a placeholder */
+    isPlaceholder?: boolean;
 }
-interface VisualDeckAnalysis {
-    slides: VisualSlideAnalysis[];
-    overallScore: number;
-    passed: boolean;
-    consistency: number;
-    deckIssues: string[];
-    summary: string;
+interface ImageProvider {
+    /** Provider name */
+    name: string;
+    /** Check if provider is available */
+    isAvailable(): Promise<boolean>;
+    /** Get an image matching the request */
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    /** Get multiple images */
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
 }
-interface RemediationFeedback {
-    slideIndex: number;
-    currentScore: number;
-    targetScore: number;
-    specificFixes: string[];
-    visualProblems: string[];
-}
-interface QALoopResult {
-    finalScore: number;
-    passed: boolean;
-    iterations: number;
-    initialScore: number;
-    improvements: string[];
-    finalAnalysis: VisualDeckAnalysis;
-}
-declare class VisualQAEngine {
-    private kb;
-    private browser;
-    private initialized;
-    private minWhitespace;
-    private minContrast;
-    private maxWordsPerSlide;
-    private targetScore;
-    constructor();
-    /**
-     * Initialize Playwright browser.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Load quality thresholds from Knowledge Base.
-     */
-    private loadKBThresholds;
-    /**
-     * Capture screenshots of all slides in a presentation.
-     */
-    captureSlides(html: string): Promise<Buffer[]>;
-    /**
-     * Analyze a single slide screenshot.
-     */
-    analyzeSlide(screenshot: Buffer, slideIndex: number, slideTitle: string, presentationType: PresentationType): Promise<VisualSlideAnalysis>;
-    /**
-     * Analyze entire deck visually.
-     */
-    analyzeDeck(html: string, slides: SlideV2[], presentationType: PresentationType): Promise<VisualDeckAnalysis>;
-    /**
-     * Generate remediation feedback for failing slides.
-     */
-    generateRemediationFeedback(analysis: VisualDeckAnalysis): RemediationFeedback[];
-    /**
-     * Run the full QA loop until passing or max iterations.
-     */
-    runQALoop(generateFn: () => Promise<{
-        html: string;
-        slides: SlideV2[];
-    }>, remediateFn: (feedback: RemediationFeedback[]) => Promise<void>, presentationType: PresentationType, maxIterations?: number): Promise<QALoopResult>;
-    /**
-     * Close browser and cleanup.
-     */
-    cleanup(): Promise<void>;
-    /**
-     * Measure whitespace percentage from screenshot.
-     * Uses actual pixel analysis.
-     */
-    private measureWhitespace;
-    /**
-     * Measure color contrast ratio.
-     */
-    private measureContrast;
-    /**
-     * Measure text density (approximation based on non-background pixels).
-     */
-    private measureTextDensity;
-    /**
-     * Measure visual balance (how evenly distributed is the content).
-     * Uses a 3x3 grid to properly detect centered layouts (common in keynotes).
-     */
-    private measureBalance;
-    /**
-     * Check if there's clear visual hierarchy.
-     */
-    private checkHierarchy;
-    private getTypeThresholds;
-    private detectBackgroundColor;
-    private detectTextColor;
-    private isSimilarColor;
-    private relativeLuminance;
-    private calculateConsistency;
-    private variance;
-}
-declare function getVisualQAEngine(): VisualQAEngine;
-declare function initVisualQAEngine(): Promise<VisualQAEngine>;
-
 /**
- * PresentationEngineV2 - Knowledge-Driven Excellence
- *
- * This engine orchestrates the ENTIRE presentation creation flow:
- * 1. Analyze content to detect presentation type
- * 2. Load design specs from Knowledge Base (YAML)
- * 3. Generate slides following expert methodologies
- * 4. Enhance with images (optional, needs API key)
- * 5. Review ruthlessly (must score 95/100+)
- * 6. Output ONLY if quality passes
- *
- * DESIGN PHILOSOPHY:
- * - The Knowledge Base (YAML) is the single source of truth for all design decisions
- * - Uses KnowledgeGateway.queryRequired() for critical paths (throws on missing data)
- * - Defensive fallbacks exist only for:
- *   1. Optional fields that may not exist in older KB versions
- *   2. Type coercion safety (undefined → default string)
- *   3. Map lookups that might fail for new palette names
- * - Critical errors (missing presentation types, validation rules) will throw
+ * Local Image Provider - Uses user-provided images
  */
-
-interface DesignSpecs {
-    wordsPerSlide: {
-        min: number;
-        max: number;
-        ideal: number;
-    };
-    whitespace: {
-        min: number;
-        max?: number;
-        ideal: number;
-    };
-    bulletPoints: {
-        max: number;
-    };
-    fonts: {
-        title: string;
-        body: string;
-        maxFonts: number;
-    };
-    theme: ThemeStyle;
-    structure: string;
-    experts: string[];
-    actionTitlesRequired: boolean;
-    sourcesRequired: boolean;
-    scoringWeights: {
-        visual_quality: number;
-        content_quality: number;
-        expert_compliance: number;
-        accessibility: number;
-    };
-}
-interface SlideReview {
-    slideIndex: number;
-    title: string;
-    score: number;
-    issues: string[];
-    suggestions: string[];
-    passed: boolean;
-}
-interface DeckReview {
-    overallScore: number;
-    slideReviews: SlideReview[];
-    deckIssues: string[];
-    flow: 'excellent' | 'good' | 'needs_work' | 'poor';
-    passed: boolean;
-    summary: string;
+declare class LocalImageProvider implements ImageProvider {
+    name: string;
+    private images;
+    constructor(imageMap?: Record<string, string>);
+    isAvailable(): Promise<boolean>;
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
+    private getPlaceholderUrl;
+    /** Register an image for later use */
+    registerImage(name: string, src: string): void;
 }
-interface EngineOptions {
-    /** Override detected presentation type */
-    presentationType?: PresentationType;
-    /** Override theme selection */
-    themeOverride?: ThemeStyle;
-    /** API key for image generation (optional) */
-    imageApiKey?: string;
-    /** Minimum quality score (default: 95) */
-    minScore?: number;
-    /** Enable verbose logging */
-    verbose?: boolean;
-    /** Maximum remediation attempts per slide */
-    maxRemediationAttempts?: number;
-    /** Run visual QA analysis using Playwright screenshots (default: false) */
-    runVisualQA?: boolean;
-    /**
-     * Use V1's richer slide generation pipeline (default: true)
-     * V1 creates agenda, section dividers, SCQA structure, metrics, STAR moments, call-to-action
-     * V2 is minimalist - just sections parsed from markdown
-     */
-    useRichPipeline?: boolean;
+/**
+ * Placeholder Image Provider - Uses picsum.photos (no API key needed)
+ */
+declare class PlaceholderImageProvider implements ImageProvider {
+    name: string;
+    isAvailable(): Promise<boolean>;
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
+    private hashString;
 }
-interface EngineResult {
-    slides: SlideV2[];
-    html: string;
-    pdfPath?: string;
-    presentationType: PresentationType;
-    designSpecs: DesignSpecs;
-    review: DeckReview;
-    warnings: string[];
-    /** Visual QA analysis (only present if runVisualQA option is true) */
-    visualQA?: VisualDeckAnalysis;
+/**
+ * Unsplash Image Provider - Uses Unsplash API (free tier: 50 req/hour)
+ */
+declare class UnsplashImageProvider implements ImageProvider {
+    name: string;
+    private accessKey?;
+    private baseUrl;
+    constructor(accessKey?: string);
+    isAvailable(): Promise<boolean>;
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
+    private getSourceImage;
+    private delay;
 }
-declare class PresentationEngineV2 {
-    private options;
-    private kb;
-    constructor(options?: EngineOptions);
-    private log;
-    /**
-     * Generate a world-class presentation from markdown content.
-     * Follows knowledge base specs and demands 95+ quality score.
-     *
-     * CRITICAL: All specs come from the Knowledge Base YAML at runtime.
-     * No hardcoded fallbacks - if KB is missing data, we fail loudly.
-     */
-    generate(markdown: string, title?: string): Promise<EngineResult>;
-    /**
-     * Detect presentation type from content analysis.
-     */
-    private detectPresentationType;
-    /**
-     * Should we recommend images for this presentation?
-     */
-    private shouldRecommendImages;
-    /**
-     * Ruthlessly review the deck against knowledge base criteria.
-     */
-    private reviewDeck;
-    /**
-     * Review a single slide against quality criteria.
-     */
-    private reviewSlide;
-    /**
-     * Check if title is an action/insight title vs. just a topic.
-     */
-    private isActionTitle;
-    /**
-     * Assess the flow and narrative structure of the deck.
-     */
-    private assessFlow;
-    /**
-     * Attempt to remediate failing slides.
-     */
-    private remediateSlides;
-    /**
-     * Count words in a slide.
-     */
-    private countWords;
+/**
+ * Composite Image Provider - Tries providers in order
+ */
+declare class CompositeImageProvider implements ImageProvider {
+    name: string;
+    private providers;
+    constructor(providers: ImageProvider[]);
+    isAvailable(): Promise<boolean>;
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
 }
-declare function createPresentationEngineV2(options?: EngineOptions): PresentationEngineV2;
 /**
- * Generate a presentation with automatic type detection and ruthless quality control.
- * Throws if quality score is below 95/100.
+ * Create default image provider chain
  */
-declare function generatePresentation(markdown: string, options?: EngineOptions & {
-    title?: string;
-    outputPath?: string;
-}): Promise<EngineResult>;
+declare function createDefaultImageProvider(options?: {
+    localImages?: Record<string, string>;
+    unsplashKey?: string;
+}): ImageProvider;
 
 /**
- * VisualDesignSystem - KB-Driven Visual Design Configuration
+ * Chart Provider - Pluggable Chart Generation
  *
- * CRITICAL: ALL design decisions come from the Knowledge Base.
- * This module queries KB for colors, typography, gradients, layouts.
- * NO hardcoded fallbacks.
+ * Provides multiple strategies for creating charts:
+ * - ChartJS: Embedded in HTML (no API needed)
+ * - QuickChart: Remote rendering (no API key needed)
+ * - Mermaid: Diagrams and flowcharts (no API needed)
  */
-
-interface ColorPalette {
-    name: string;
-    background: string;
-    primary: string;
-    secondary: string;
-    accent: string;
-    text: string;
-    useCase: string;
-    contrastRatio: string;
-}
-interface Typography {
-    titles: string;
-    headlines?: string;
-    body: string;
-    maxFonts: number;
-    fontPairing?: string;
-    actionTitle?: string;
-    sectionHeaders?: string;
-    dataLabels?: string;
-}
-interface LayoutRules {
-    whitespace: string;
-    wordsPerSlide: string;
-    elementsPerSlide?: string;
-    requiresActionTitles?: boolean;
-    requiresSources?: boolean;
-    requiresCallouts?: boolean;
+type ChartType = 'bar' | 'line' | 'pie' | 'doughnut' | 'radar' | 'polarArea' | 'scatter' | 'bubble';
+interface ChartDataset {
+    label: string;
+    data: number[];
+    backgroundColor?: string | string[];
+    borderColor?: string | string[];
+    borderWidth?: number;
+}
+interface ChartData {
+    labels: string[];
+    datasets: ChartDataset[];
+}
+interface ChartRequest {
+    /** Chart type */
+    type: ChartType;
+    /** Chart data */
+    data: ChartData;
+    /** Chart title */
+    title?: string;
+    /** Width in pixels */
+    width?: number;
+    /** Height in pixels */
+    height?: number;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Animation enabled (HTML only) */
+    animated?: boolean;
+    /** Color palette to use */
+    palette?: 'default' | 'professional' | 'vibrant' | 'monochrome';
+}
+interface ChartResult {
+    /** HTML for embedding (Chart.js canvas) */
+    html?: string;
+    /** Image URL for static contexts (PPTX) */
+    imageUrl?: string;
+    /** Base64 data URI */
+    dataUri?: string;
+    /** Chart title for accessibility */
+    title: string;
 }
-interface GradientDefinition {
+interface ChartProvider {
+    /** Provider name */
     name: string;
-    css: string;
-    angle?: number;
-    stops: Array<{
-        color: string;
-        position: string;
-    }>;
+    /** Check if provider is available */
+    isAvailable(): Promise<boolean>;
+    /** Generate a chart */
+    generateChart(request: ChartRequest): Promise<ChartResult>;
 }
-interface SlideLayout {
+/**
+ * Chart.js Provider - Generates embedded Chart.js HTML
+ * No API needed - runs in browser
+ */
+declare class ChartJsProvider implements ChartProvider {
     name: string;
-    purpose: string;
-    elements: string[];
-    wordLimit?: number;
-    grid?: {
-        columns: number;
-        rows?: number;
-        gap: string;
-    };
-}
-interface VisualTheme {
-    presentationType: PresentationType;
-    mode: 'keynote' | 'business';
-    palette: ColorPalette;
-    typography: Typography;
-    layout: LayoutRules;
-    gradients: GradientDefinition[];
-    cssVariables: Record<string, string>;
-}
-declare class VisualDesignSystem {
-    private kb;
-    private initialized;
-    constructor();
-    /**
-     * Initialize the design system (loads KB)
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get complete visual theme for a presentation type.
-     */
-    getTheme(type: PresentationType): Promise<VisualTheme>;
-    /**
-     * Determine mode (keynote vs business) for a presentation type.
-     */
-    private getModeForType;
-    /**
-     * Get color palette for presentation type from KB.
-     */
-    private getPaletteForType;
-    /**
-     * Get typography rules for mode from KB.
-     */
-    private getTypographyForMode;
-    /**
-     * Get layout rules for mode from KB.
-     */
-    private getLayoutRulesForMode;
-    /**
-     * Get gradient definitions for presentation type.
-     */
-    private getGradientsForType;
-    /**
-     * Build CSS custom properties for the theme.
-     */
-    private buildCSSVariables;
-    /**
-     * Get slide layout templates from KB.
-     */
-    getSlideLayouts(type: PresentationType): Promise<SlideLayout[]>;
-    /**
-     * Generate complete CSS for the theme.
-     */
-    generateCSS(theme: VisualTheme): string;
-    private lightenColor;
-    private darkenColor;
-    private hexToRgb;
-    /**
-     * Get contrasting text color for a given background color.
-     * Returns white or black based on luminance.
-     */
-    private getContrastColor;
+    isAvailable(): Promise<boolean>;
+    generateChart(request: ChartRequest): Promise<ChartResult>;
 }
-declare function getVisualDesignSystem(): VisualDesignSystem;
-declare function initVisualDesignSystem(): Promise<VisualDesignSystem>;
-
 /**
- * SlideQualityReviewer - THE HEART OF THE QUALITATIVE REVIEW SYSTEM
- *
- * This is NOT a mechanical checker. It evaluates REAL quality.
- * A slide ONLY passes at 95+ if:
- * 1. You would personally present it without changes
- * 2. It follows expert principles (Duarte, Reynolds, Tufte)
- * 3. It looks professionally designed
- * 4. It clearly communicates its message
- * 5. It fits the overall presentation
- *
- * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
+ * QuickChart Provider - Uses quickchart.io for image generation
+ * No API key needed - free service
  */
-
-type QualityLevel = 'excellent' | 'good' | 'acceptable' | 'poor' | 'failing';
-interface QualitativeAssessment {
-    /** Score (0-100) */
-    score: number;
-    /** Quality level */
-    level: QualityLevel;
-    /** WHY this score - specific reasoning */
-    reasoning: string;
-    /** KB reference for this assessment */
-    kbReference?: string;
-}
-interface QualitativeSlideReview {
-    /** Overall qualitative score (0-100, must be >= 95) */
-    score: number;
-    /** Would you be proud to present this? */
-    wouldPresent: boolean;
-    /** Detailed qualitative assessments */
-    assessments: {
-        visualImpact: QualitativeAssessment;
-        contentClarity: QualitativeAssessment;
-        layoutBalance: QualitativeAssessment;
-        typographyHierarchy: QualitativeAssessment;
-        whitespaceUsage: QualitativeAssessment;
-        colorHarmony: QualitativeAssessment;
-        audienceAppropriate: QualitativeAssessment;
-    };
-    /** Specific issues found */
-    issues: QualityIssue[];
-    /** What would make this slide better */
-    improvements: string[];
-}
-interface QualityIssue {
-    severity: 'critical' | 'major' | 'minor';
-    category: 'visual' | 'content' | 'layout' | 'typography' | 'accessibility';
-    issue: string;
-    fix: string;
-    kbReference?: string;
-}
-declare class SlideQualityReviewer {
-    private kb;
-    private initialized;
-    private wordLimits;
-    private whitespaceRules;
-    private bulletLimit;
-    private glanceTestSeconds;
-    private assessmentWeights;
-    private _loggedWeights;
-    private hasCialdini;
-    private hasGestalt;
-    private hasTufteDataInk;
-    private chartjunkToAvoid;
-    constructor();
-    initialize(): Promise<void>;
-    /**
-     * Review a slide qualitatively.
-     */
-    review(slide: Slide, presentationType: PresentationType): Promise<QualitativeSlideReview>;
-    /**
-     * Convert qualitative review to SlideScore format.
-     */
-    toSlideScore(review: QualitativeSlideReview): SlideScore;
-    private loadRulesForType;
-    /**
-     * Visual Impact (25%): Does this slide command attention appropriately?
-     */
-    private assessVisualImpact;
-    /**
-     * Content Clarity (20%): Can you understand the message in 3 seconds?
-     */
-    private assessContentClarity;
-    /**
-     * Get all text content from a slide for analysis.
-     */
-    private getAllTextContent;
-    /**
-     * Layout Balance (15%): Is visual weight distributed appropriately?
-     */
-    private assessLayoutBalance;
-    /**
-     * Typography Hierarchy (15%): Is there clear primary/secondary/tertiary hierarchy?
-     */
-    private assessTypographyHierarchy;
-    /**
-     * Whitespace Usage (10%): Is whitespace used purposefully?
-     */
-    private assessWhitespaceUsage;
-    /**
-     * Color Harmony (10%): Do colors work together within the theme?
-     */
-    private assessColorHarmony;
-    /**
-     * Audience Appropriateness (5%): Is the visual style right for this audience?
-     */
-    private assessAudienceAppropriate;
-    private isMinimalType;
-    private isDenseType;
-    private countWords;
-    private countLongWords;
-    /**
-     * Detect raw markdown syntax that should have been rendered to HTML.
-     * Returns array of issue descriptions.
-     */
-    private detectRawMarkdown;
-    /**
-     * Check if slide type is appropriate for its content.
-     * Returns issue description if mismatched.
-     */
-    private checkSlideTypeMismatch;
-    private scoreToLevel;
-    private collectIssues;
-    private mapAssessmentToCategory;
-    private mapIssueCategory;
-    private generateImprovements;
-    private createCategoryScore;
+declare class QuickChartProvider implements ChartProvider {
+    name: string;
+    private baseUrl;
+    isAvailable(): Promise<boolean>;
+    generateChart(request: ChartRequest): Promise<ChartResult>;
 }
-declare function getSlideQualityReviewer(): SlideQualityReviewer;
-declare function initSlideQualityReviewer(): Promise<SlideQualityReviewer>;
-
 /**
- * DeckQualityReviewer - HOLISTIC DECK QUALITY REVIEW
- *
- * After all slides pass individual review, this evaluates the deck as a whole:
- * 1. Narrative Flow (30%) - Does it tell a coherent story?
- * 2. Visual Consistency (25%) - Is the same theme applied throughout?
- * 3. Pacing & Rhythm (20%) - Is there variety and appropriate density?
- * 4. Opening & Closing (15%) - Are first/last slides the strongest?
- * 5. Overall Impression (10%) - Would you hire/invest based on this?
- *
- * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
+ * Mermaid Provider - Generates diagrams using Mermaid.js
+ * No API needed - renders in browser
  */
-
-type DeckQualityLevel = 'excellent' | 'good' | 'acceptable' | 'poor' | 'failing';
-interface DeckAssessment {
-    /** Score (0-100) */
-    score: number;
-    /** Quality level */
-    level: DeckQualityLevel;
-    /** WHY this score - specific reasoning */
-    reasoning: string;
-    /** KB reference for this assessment */
-    kbReference?: string;
-}
-interface QualitativeDeckReview {
-    /** Overall deck score (0-100, must be >= 95) */
-    score: number;
-    /** Would this deck impress the target audience? */
-    wouldImpress: boolean;
-    /** Detailed assessments */
-    assessments: {
-        narrativeFlow: DeckAssessment;
-        visualConsistency: DeckAssessment;
-        pacingRhythm: DeckAssessment;
-        openingClosing: DeckAssessment;
-        overallImpression: DeckAssessment;
-    };
-    /** Individual slide reviews */
-    slideReviews: QualitativeSlideReview[];
-    /** Deck-level issues */
-    issues: DeckIssue[];
-    /** Deck-level improvements */
-    improvements: string[];
-}
-interface DeckIssue {
-    severity: 'critical' | 'major' | 'minor';
-    category: 'narrative' | 'visual' | 'pacing' | 'structure';
-    issue: string;
-    fix: string;
-    affectedSlides?: number[];
-    kbReference?: string;
-}
-declare class DeckQualityReviewer {
-    private kb;
-    private slideReviewer;
-    private initialized;
-    private requiredElements;
-    private antiPatterns;
-    private hasSparkline;
-    private hasSCQA;
-    constructor();
-    initialize(): Promise<void>;
-    /**
-     * Review the entire deck qualitatively.
-     */
-    review(slides: Slide[], presentationType: PresentationType): Promise<QualitativeDeckReview>;
-    /**
-     * Convert qualitative review to DeckScore format.
-     */
-    toDeckScore(review: QualitativeDeckReview): DeckScore;
-    private loadRulesForType;
-    /**
-     * Narrative Flow (30%): Does the presentation tell a coherent story?
-     */
-    private assessNarrativeFlow;
-    /**
-     * Visual Consistency (25%): Is the same theme applied throughout?
-     */
-    private assessVisualConsistency;
+declare class MermaidProvider implements ChartProvider {
+    name: string;
+    isAvailable(): Promise<boolean>;
+    generateChart(request: ChartRequest): Promise<ChartResult>;
     /**
-     * Pacing & Rhythm (20%): Is there variety in slide types and density?
+     * Generate a Mermaid diagram
      */
-    private assessPacingRhythm;
+    generateDiagram(definition: string, title?: string): Promise<ChartResult>;
     /**
-     * Opening & Closing (15%): Are the first and last slides the strongest?
+     * Generate flowchart from steps
      */
-    private assessOpeningClosing;
+    generateFlowchart(steps: {
+        id: string;
+        label: string;
+        next?: string[];
+    }[]): string;
     /**
-     * Overall Impression (10%): Would you hire/invest based on this?
+     * Generate timeline from events
      */
-    private assessOverallImpression;
-    private scoreToLevel;
-    private calculateVariance;
-    private getMissingRequiredElements;
-    private collectDeckIssues;
-    private mapAssessmentToCategory;
-    private mapDeckCategory;
-    private generateDeckImprovements;
-    private calculateRequiredElementsScore;
-    private calculateAntiPatternScore;
+    generateTimeline(events: {
+        date: string;
+        title: string;
+    }[]): string;
 }
-declare function getDeckQualityReviewer(): DeckQualityReviewer;
-declare function initDeckQualityReviewer(): Promise<DeckQualityReviewer>;
-
 /**
- * Remediator - Fix Failing Slides
- *
- * When a slide fails qualitative review (< 95), this module attempts to fix it.
- * Maximum 3 remediation attempts per slide.
- *
- * Remediation strategies are based on the specific quality issues identified:
- * - Visual Impact: Increase title prominence, add visual elements
- * - Content Clarity: Reduce word count, simplify messaging
- * - Layout Balance: Redistribute content, improve alignment
- * - Typography Hierarchy: Adjust text sizes, create clearer hierarchy
- * - Whitespace Usage: Remove content or split slide
- * - Color Harmony: Ensure colors match theme
- * - Audience Appropriateness: Adjust density for audience
- *
- * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
+ * Composite Chart Provider
  */
-
-interface RemediationResult {
-    /** Was remediation successful? */
-    success: boolean;
-    /** Original slide */
-    originalSlide: Slide;
-    /** Remediated slide (or original if failed) */
-    remediatedSlide: Slide;
-    /** Number of attempts made */
-    attempts: number;
-    /** Final score after remediation */
-    finalScore: number;
-    /** Review after remediation */
-    finalReview: QualitativeSlideReview;
-    /** Actions taken during remediation */
-    actions: RemediationAction[];
-    /** Why remediation failed (if it did) */
-    failureReason?: string;
-}
-interface RemediationAction {
-    /** What was done */
-    action: string;
-    /** Which issue it addressed */
-    targetIssue: string;
-    /** Score before this action */
-    scoreBefore: number;
-    /** Score after this action */
-    scoreAfter: number;
-    /** Was this action effective? */
-    effective: boolean;
-}
-declare class Remediator {
-    private kb;
-    private reviewer;
-    private initialized;
-    private wordLimits;
-    private bulletLimit;
-    private maxAttempts;
-    private targetScore;
+declare class CompositeChartProvider implements ChartProvider {
+    name: string;
+    private htmlProvider;
+    private imageProvider;
+    private mermaidProvider;
     constructor();
-    initialize(): Promise<void>;
-    /**
-     * Attempt to remediate a failing slide.
-     */
-    remediate(slide: Slide, presentationType: PresentationType, initialReview: QualitativeSlideReview): Promise<RemediationResult>;
-    /**
-     * Batch remediate multiple slides.
-     */
-    remediateBatch(slides: Slide[], reviews: QualitativeSlideReview[], presentationType: PresentationType): Promise<RemediationResult[]>;
-    private loadRulesForType;
-    private prioritizeIssues;
-    private applyFix;
-    private fixVisualIssue;
-    private fixContentIssue;
-    private fixLayoutIssue;
-    private fixTypographyIssue;
-    private fixAccessibilityIssue;
-    private cloneSlide;
-    private truncateToWords;
-    private isMinimalType;
-    private countWords;
+    isAvailable(): Promise<boolean>;
+    generateChart(request: ChartRequest): Promise<ChartResult>;
+    generateDiagram(definition: string, title?: string): Promise<ChartResult>;
+    generateFlowchart(steps: {
+        id: string;
+        label: string;
+        next?: string[];
+    }[]): string;
+    generateTimeline(events: {
+        date: string;
+        title: string;
+    }[]): string;
 }
-declare function getRemediator(): Remediator;
-declare function initRemediator(): Promise<Remediator>;
+/**
+ * Create default chart provider
+ */
+declare function createDefaultChartProvider(): CompositeChartProvider;
 
 /**
- * Renderer - Premium HTML/PPTX Output Generation
+ * Knowledge Base - RuVector Expert Principles Loader
  *
- * Renders slides to high-quality outputs:
- * - HTML: Reveal.js with premium CSS from KB
- * - PPTX: PowerPoint (future implementation)
+ * Loads and provides access to the 6,300+ line expert knowledge base
+ * containing methodologies from 40+ presentation experts.
  *
- * ALL styling comes from the Knowledge Base and VisualDesignSystem.
- * NO hardcoded styles.
+ * This runs WITHOUT any API - it's static data bundled with the package.
  */
-
-interface RenderOptions {
-    /** Presentation title */
-    title: string;
-    /** Author name */
-    author?: string;
-    /** Presentation type */
-    presentationType: PresentationType;
-    /** Metadata */
-    metadata?: PresentationMetadata;
-    /** Local images to use as backgrounds */
-    images?: string[];
-    /** Base path for resolving relative image paths */
-    imageBasePath?: string;
+interface ExpertPrinciple {
+    name: string;
+    description: string;
+    validation?: string[];
+    examples?: string[];
 }
-interface RenderResult {
-    html?: string;
-    pptx?: Buffer;
+interface ExpertMethodology {
+    name: string;
+    principles: ExpertPrinciple[];
+    slideTypes?: string[];
+    wordLimits?: {
+        min?: number;
+        max?: number;
+    };
 }
-declare class Renderer {
-    private kb;
-    private vds;
-    private initialized;
-    private readonly slideImageKeywords;
-    constructor();
-    initialize(): Promise<void>;
-    /**
-     * Render slides to specified formats.
-     */
-    render(slides: Slide[], formats: OutputFormat[], options: RenderOptions): Promise<RenderResult>;
-    private renderHTML;
-    private generateCSS;
-    private renderSlide;
-    private renderTitleSlide;
-    private renderSectionDivider;
-    private renderMetricsSlide;
-    private renderQuoteSlide;
-    private renderStarMomentSlide;
-    private renderCTASlide;
-    private renderThankYouSlide;
-    private renderTwoColumnSlide;
-    private renderThreeColumnSlide;
-    private renderContentSlide;
-    private renderPPTX;
-    private formatCSSVariables;
-    private escapeHTML;
-    /**
-     * Generate a background image URL based on slide type and content.
-     * Priority: 1) slide.data.image, 2) local images array, 3) NO RANDOM STOCK PHOTOS
-     *
-     * IMPORTANT: Random stock photos destroy credibility. A photo of flowers behind
-     * a financial slide makes you look incompetent. Only use images that are:
-     * - Explicitly provided by the user
-     * - Actually relevant to the content
-     * Otherwise, rely on clean gradients via CSS.
-     */
-    private getBackgroundImageUrl;
-    /**
-     * Resolve an image path - handles relative paths, absolute paths, and URLs.
-     */
-    private resolveImagePath;
-    /**
-     * Generate fallback image URL using Picsum with smart seeding.
-     */
-    private getFallbackImageUrl;
+interface AutomatedQA {
+    scoringRubric: {
+        totalPoints: number;
+        passingThreshold: number;
+        categories: Record<string, {
+            weight: number;
+            checks: Record<string, unknown>;
+        }>;
+    };
+}
+declare class KnowledgeBase {
+    private data;
+    private loaded;
     /**
-     * Convert markdown syntax to HTML.
-     * Handles: bold, italic, code, links, and basic formatting.
-     * Called BEFORE escapeHTML to preserve markdown-generated HTML tags.
+     * Load the knowledge base from the bundled YAML file.
      */
-    private renderMarkdown;
+    load(): Promise<void>;
     /**
-     * Clean up broken/truncated markdown that can't be properly rendered.
-     * Removes partial code blocks, inline tables, etc.
+     * Get expert methodology by name.
      */
-    private cleanBrokenMarkdown;
+    getExpert(name: string): ExpertMethodology | undefined;
     /**
-     * Render markdown tables to HTML tables.
+     * Get all expert names.
      */
-    private renderMarkdownTables;
+    getExpertNames(): string[];
     /**
-     * Build an HTML table from markdown table rows.
+     * Get framework recommendation for audience.
      */
-    private buildHTMLTable;
-}
-declare function getRenderer(): Renderer;
-declare function initRenderer(): Promise<Renderer>;
-
-/**
- * NanoBanana Pro Image Generation Provider
- *
- * Integrates with Google Gemini's image generation capabilities via NanoBanana Pro.
- * Generates high-quality hero images, concept illustrations, and visual assets
- * for presentation slides.
- *
- * Requires: GOOGLE_AI_API_KEY environment variable
- *
- * Usage:
- *   const provider = createNanoBananaProvider();
- *   if (await provider.isAvailable()) {
- *     const imageUrl = await provider.generateHeroImage('AI revolution');
- *   }
- */
-interface ImageGenerationRequest {
-    /** The concept or topic to visualize */
-    concept: string;
-    /** Image style/type */
-    style: 'hero' | 'concept' | 'icon' | 'background' | 'diagram';
-    /** Presentation type for context */
-    presentationType?: string;
-    /** Aspect ratio */
-    aspectRatio?: '16:9' | '4:3' | '1:1' | '9:16';
-    /** Color scheme preference */
-    colorScheme?: 'dark' | 'light' | 'vibrant' | 'muted';
-}
-interface ImageGenerationResult {
-    /** Whether generation succeeded */
-    success: boolean;
-    /** Generated image URL or base64 data */
-    imageUrl?: string;
-    /** Base64 encoded image data */
-    imageData?: string;
-    /** MIME type of the image */
-    mimeType?: string;
-    /** Error message if failed */
-    error?: string;
-    /** Prompt used for generation */
-    promptUsed?: string;
-}
-interface NanoBananaConfig {
-    /** Google AI API key (defaults to GOOGLE_AI_API_KEY env var) */
-    apiKey?: string;
-    /** Model to use (defaults to gemini-2.0-flash-exp for image generation) */
-    model?: string;
-    /** Timeout in milliseconds */
-    timeout?: number;
-    /** Enable verbose logging */
-    verbose?: boolean;
-}
-/**
- * NanoBanana Pro image generation provider.
- * Uses Google Gemini's image generation capabilities.
- */
-declare class NanoBananaProvider {
-    readonly name = "NanoBanana Pro";
-    private apiKey;
-    private model;
-    private timeout;
-    private verbose;
-    constructor(config?: NanoBananaConfig);
+    getFrameworkForAudience(audience: string): {
+        primaryFramework: string;
+        secondaryFramework?: string;
+        slideTypes: string[];
+    } | undefined;
     /**
-     * Check if NanoBanana is available (API key present).
+     * Get framework recommendation for goal.
      */
-    isAvailable(): Promise<boolean>;
+    getFrameworkForGoal(goal: string): {
+        primaryFramework: string;
+        secondaryFramework?: string;
+        slideTypes: string[];
+    } | undefined;
     /**
-     * Generate a hero image for a slide.
+     * Get QA scoring rubric.
      */
-    generateHeroImage(concept: string): Promise<ImageGenerationResult>;
+    getScoringRubric(): AutomatedQA['scoringRubric'] | undefined;
     /**
-     * Generate a concept illustration.
+     * Get mode configuration (keynote or business).
      */
-    generateConceptImage(concept: string): Promise<ImageGenerationResult>;
+    getModeConfig(mode: 'keynote' | 'business'): unknown;
     /**
-     * Generate an icon or symbol.
+     * Get slide type configuration.
      */
-    generateIcon(concept: string): Promise<ImageGenerationResult>;
+    getSlideType(type: string): unknown;
     /**
-     * Generate a background image.
+     * Get the knowledge base version.
      */
-    generateBackground(concept: string, colorScheme?: 'dark' | 'light'): Promise<ImageGenerationResult>;
+    getVersion(): string;
     /**
-     * Generate an image based on request parameters.
+     * Validate a slide against expert principles.
      */
-    generate(request: ImageGenerationRequest): Promise<ImageGenerationResult>;
+    validateAgainstExpert(expertName: string, slideData: {
+        wordCount: number;
+        hasActionTitle: boolean;
+        bulletCount: number;
+    }): {
+        passed: boolean;
+        violations: string[];
+    };
     /**
-     * Build an optimized prompt for image generation.
+     * Ensure knowledge base is loaded.
      */
-    private buildPrompt;
+    private ensureLoaded;
     /**
-     * Call the Gemini API for image generation.
+     * Get default data if YAML can't be loaded.
      */
-    private callGeminiAPI;
+    private getDefaultData;
 }
 /**
- * Create a new NanoBanana provider instance.
+ * Get the knowledge base singleton.
  */
-declare function createNanoBananaProvider(config?: NanoBananaConfig): NanoBananaProvider;
+declare function getKnowledgeBase(): KnowledgeBase;
+
 /**
- * Get a pre-built prompt for a specific image type.
- * Useful for customization or debugging.
+ * Claude Presentation Master
+ *
+ * Generate world-class presentations using expert methodologies from
+ * Duarte, Reynolds, Gallo, and Anderson. Enforces rigorous quality
+ * standards through real visual validation.
+ *
+ * @packageDocumentation
+ * @module claude-presentation-master
+ * @author Stuart Kerr <stuart@isovision.ai>
+ * @license MIT
  */
-declare function getNanoBananaPrompt(style: 'hero' | 'concept' | 'icon' | 'background' | 'diagram', concept: string, presentationType?: string): string;
 
 /**
- * CodeQualityValidator - Detects Hardcoded Values in Source Code
+ * Generate a presentation from content.
  *
- * This validator scans TypeScript/JavaScript source files for hardcoded CSS values,
- * colors, and dimensions that should be coming from the Knowledge Base.
+ * @example
+ * ```typescript
+ * import { generate } from '@isovision/claude-presentation-master';
  *
- * RATIONALE: ALL styling decisions must come from the KB. Hardcoded values:
- * 1. Break the single-source-of-truth principle
- * 2. Make theme changes inconsistent
- * 3. Bypass QA validation
- * 4. Create maintenance nightmares
+ * const result = await generate({
+ *   content: '# My Presentation\n\n...',
+ *   contentType: 'markdown',
+ *   mode: 'keynote',
+ *   format: ['html', 'pptx'],
+ *   qaThreshold: 95,
+ *   title: 'My Amazing Presentation'
+ * });
  *
- * This validator catches these careless errors at build/test time.
- */
-interface HardcodedViolation {
-    file: string;
-    line: number;
-    column: number;
-    type: 'color' | 'dimension' | 'font' | 'shadow' | 'rgba' | 'gradient';
-    value: string;
-    context: string;
-    severity: 'error' | 'warning';
-    suggestion: string;
-}
-interface ValidationResult {
-    passed: boolean;
-    violations: HardcodedViolation[];
-    summary: {
-        totalFiles: number;
-        filesWithViolations: number;
-        totalViolations: number;
-        byType: Record<string, number>;
-        bySeverity: Record<string, number>;
-    };
-}
-declare class CodeQualityValidator {
-    private srcDir;
-    private violations;
-    constructor(srcDir: string);
-    /**
-     * Validate all TypeScript files in the source directory.
-     */
-    validate(): Promise<ValidationResult>;
-    /**
-     * Validate a single file for hardcoded values.
-     */
-    private validateFile;
-    private checkForHexColors;
-    private checkForRgbaColors;
-    private checkForDimensions;
-    private checkForGradients;
-    private findTypeScriptFiles;
-    private shouldSkipFile;
-    private isExemptLine;
-    private buildResult;
-    /**
-     * Format validation results for console output.
-     */
-    formatResults(result: ValidationResult): string;
-}
-/**
- * Run code quality validation on the source directory.
+ * console.log(`Score: ${result.score}/100`);
+ * ```
+ *
+ * @param config - Presentation configuration
+ * @returns Presentation result with outputs, QA results, and score
+ * @throws {ValidationError} If input validation fails
+ * @throws {QAFailureError} If QA score is below threshold
  */
-declare function validateCodeQuality(srcDir: string): Promise<ValidationResult>;
+declare function generate(config: PresentationConfig): Promise<PresentationResult>;
 /**
- * Run validation and print results to console.
- */
-declare function runCodeQualityCheck(srcDir: string): Promise<boolean>;
-
-/**
- * Claude Presentation Master - Main API
+ * Validate an existing presentation.
+ *
+ * @example
+ * ```typescript
+ * import { validate } from '@isovision/claude-presentation-master';
+ * import fs from 'fs';
  *
- * Entry point for the qualitative-first presentation engine.
- * Every slide must score 95/100 based on REAL qualitative excellence.
+ * const html = fs.readFileSync('presentation.html', 'utf-8');
+ * const result = await validate(html, { mode: 'keynote' });
  *
- * Flow:
- * 1. ContentAnalyzer -> Parse and detect structure
- * 2. SlideGenerator -> Generate slides with visual intent
- * 3. SlideQualityReviewer -> Qualitative review per slide (must pass 95)
- * 4. Remediator -> Fix failing slides (3 attempts max)
- * 5. DeckQualityReviewer -> Holistic deck review (must pass 95)
- * 6. Renderer -> Premium HTML/PPTX output
+ * console.log(`Score: ${result.score}/100`);
+ * console.log(`Passed: ${result.passed}`);
+ * ```
  *
- * DESIGN PHILOSOPHY:
- * - The Knowledge Base (YAML) is the source of truth for all design decisions
- * - Critical paths use queryRequired() which throws on missing data
- * - Defensive fallbacks exist for optional fields and type safety
- * - Both V1 (generate) and V2 (generatePresentation) APIs use the same KB
+ * @param presentation - HTML string or file buffer
+ * @param options - Validation options
+ * @returns QA validation results
  */
-
-declare const VERSION = "4.2.0";
-interface GenerateOptions {
-    /** Input content (Markdown, text, etc.) */
-    content: string;
-    /** Content type */
-    contentType?: 'markdown' | 'text';
-    /** Output formats to generate */
-    format?: OutputFormat[];
-    /** Output directory */
-    outputDir?: string;
-    /** Presentation title (optional, will be detected from content) */
-    title?: string;
-    /** Author name */
-    author?: string;
-    /** Explicit presentation type (optional, will be detected from content) */
-    presentationType?: PresentationType;
-    /** Legacy mode (maps to presentation type) */
-    mode?: PresentationMode;
-    /** Minimum score threshold (default: 95) */
-    qaThreshold?: number;
-    /** Skip remediation (fail fast) */
-    skipRemediation?: boolean;
-    /** Verbose logging */
-    verbose?: boolean;
-    /** Local images to use as backgrounds (paths relative to output or absolute URLs) */
-    images?: string[];
-    /** Base path for resolving relative image paths */
-    imageBasePath?: string;
-}
-interface GenerateResult {
-    /** Generated outputs */
-    outputs: {
-        html?: string;
-        pptx?: Buffer;
-    };
-    /** Final slides */
-    slides: Slide[];
-    /** Overall score (0-100) */
+declare function validate(presentation: string | Buffer, options?: {
+    mode?: 'keynote' | 'business';
+    threshold?: number;
+    strictMode?: boolean;
+}): Promise<QAResults & {
     score: number;
-    /** Detailed deck score */
-    deckScore?: QualitativeDeckReview | undefined;
-    /** Metadata */
-    metadata: {
-        title: string;
-        author: string;
-        presentationType: PresentationType;
-        generatedAt: string;
-        slideCount: number;
-        totalWords: number;
-        avgWordsPerSlide: number;
-    };
-    /** Remediation results (if any slides were fixed) */
-    remediations?: RemediationResult[] | undefined;
-    /** Any warnings (non-fatal issues) */
-    warnings?: string[] | undefined;
-}
+}>;
 /**
- * Generate a presentation from content.
- *
- * This is the main entry point. It orchestrates:
- * 1. Content analysis
- * 2. Slide generation
- * 3. Qualitative review (95/100 threshold)
- * 4. Remediation (3 attempts per failing slide)
- * 5. Deck-level review
- * 6. Rendering to HTML/PPTX
+ * Get the version of the package.
+ */
+declare const VERSION = "1.0.0";
+/**
+ * Default export for convenience.
  */
-declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+declare const _default: {
+    generate: typeof generate;
+    validate: typeof validate;
+    PresentationEngine: typeof PresentationEngine;
+    QAEngine: typeof QAEngine;
+    VERSION: string;
+};
 
-export { CodeQualityValidator, type ValidationResult as CodeValidationResult, type ContentAnalysis, ContentAnalyzer, DeckQualityReviewer, type DeckScore, type GenerateOptions, type GenerateResult, type HardcodedViolation, type ImageGenerationRequest, type ImageGenerationResult, KnowledgeGateway, type MetricData, type NanoBananaConfig, NanoBananaProvider, type OutputFormat, PresentationEngineV2, type PresentationMetadata, type PresentationMode, type PresentationResult, type PresentationType, type QALoopResult, type QualitativeDeckReview, type QualitativeSlideReview, type RemediationFeedback, type RemediationResult, Remediator, Renderer, RendererV2, type Slide, type SlideContent as SlideContentV2, SlideGenerator, SlideGeneratorV2, SlideQualityReviewer, type SlideScore, type SlideType as SlideTypeV2, type SlideV2, type TableData, VERSION, type Violation, type VisualDeckAnalysis, VisualDesignSystem, VisualQAEngine, type VisualSlideAnalysis, createNanoBananaProvider, createPresentationEngineV2, createRendererV2, createSlideGeneratorV2, generate, generatePresentation, getContentAnalyzer, getDeckQualityReviewer, getKB, getNanoBananaPrompt, getRemediator, getRenderer, getSlideGenerator, getSlideQualityReviewer, getVisualDesignSystem, getVisualQAEngine, initContentAnalyzer, initDeckQualityReviewer, initKB, initRemediator, initRenderer, initSlideGenerator, initSlideQualityReviewer, initVisualDesignSystem, initVisualQAEngine, runCodeQualityCheck, validateCodeQuality };
+export { type AccessibilityResults, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContrastIssue, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeBase, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationResult, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideVisualScore, type SparklineStructure, TemplateEngine, TemplateNotFoundError, type ThemeName, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeBase, validate };