claude-presentation-master 2.1.2 → 3.6.0

package/dist/index.d.ts

@@ -1,276 +1,249 @@
-import PptxGenJS from 'pptxgenjs';
-
 /**
  * Claude Presentation Master - Type Definitions
- * @module types
- */
-/**
- * Legacy presentation mode (for backwards compatibility)
- * @deprecated Use PresentationType for granular control
+ *
+ * Clean rewrite: All types for KB-driven presentation generation.
+ * Every decision comes from the Knowledge Base - no hardcoded fallbacks.
  */
-type PresentationMode = 'keynote' | 'business';
 /**
- * Granular presentation types with distinct validation rules.
- * Each type is a "swim lane" with its own word limits, expert methodologies,
- * and scoring weights. These are mutually exclusive.
+ * 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';
-type OutputFormat = 'html' | 'pptx';
-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';
-    /**
-     * Legacy presentation mode (backwards compatible)
-     * @deprecated Use `presentationType` for granular control
-     */
-    mode: PresentationMode;
-    /**
-     * Granular presentation type with distinct validation rules.
-     * If specified, this overrides `mode` for validation purposes.
-     */
-    presentationType?: PresentationType;
-    /** Target audience (used for auto-detecting presentation type) */
-    audience?: 'board_of_directors' | 'sales_prospect' | 'investors_vcs' | 'general_audience_keynote' | 'technical_team' | 'all_hands_meeting';
-    /** Presentation goal (used for auto-detecting presentation type) */
-    goal?: 'get_approval' | 'inform_educate' | 'persuade_sell' | 'inspire_motivate' | 'report_results' | 'raise_funding';
-    /** 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>;
-}
 /**
- * Validation rules specific to a presentation type.
- * Loaded from the knowledge base.
+ * Legacy mode for backwards compatibility
  */
-interface PresentationTypeRules {
-    id: PresentationType;
-    name: string;
-    description: string;
-    wordsPerSlide: {
-        min: number;
-        max: number;
-        ideal: number;
-    };
-    whitespace: {
-        min: number;
-        ideal: number;
-        max?: number;
-    };
-    bulletsPerSlide: {
-        max: number;
-    };
-    actionTitlesRequired: boolean;
-    sourcesRequired: boolean;
-    scoringWeights: {
-        visual_quality: number;
-        content_quality: number;
-        expert_compliance: number;
-        accessibility: number;
-    };
-}
-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';
+type PresentationMode = 'keynote' | 'business';
+type OutputFormat = 'html' | 'pptx';
+type SlideType = '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';
 interface Slide {
     /** Slide index (0-based) */
     index: number;
-    /** Slide type */
+    /** Slide type from KB */
     type: SlideType;
-    /** Slide data for template rendering */
+    /** Slide content */
     data: SlideData;
-    /** CSS classes to apply */
-    classes?: string[];
-    /** Custom styles */
-    styles?: Record<string, string>;
+    /** Slide-level score (must be >= 95) */
+    score?: SlideScore;
     /** Speaker notes */
     notes?: string;
 }
 interface SlideData {
-    /** Main title */
+    /** Main title (action title for consulting, emotional for keynote) */
     title?: string;
     /** Subtitle */
     subtitle?: string;
-    /** Body content */
+    /** Body text */
     body?: string;
     /** Bullet points */
     bullets?: string[];
-    /** Key message */
+    /** Key message / takeaway */
     keyMessage?: string;
-    /** Images */
-    images?: ImageData[];
-    /** Metrics/KPIs */
-    metrics?: MetricData[];
     /** Quote text */
     quote?: string;
     /** Quote attribution */
     attribution?: string;
-    /** Source citation */
+    /** Metrics for metrics_grid */
+    metrics?: MetricData[];
+    /** Source citation (required for consulting/IB) */
     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 ImageData {
-    src: string;
-    alt: string;
-    caption?: string;
-}
 interface MetricData {
     value: string | number;
     label: string;
     change?: string;
     trend?: 'up' | 'down' | 'neutral';
 }
-interface QAResults {
-    /** Visual quality results */
-    visual: VisualQAResults;
-    /** Content quality results */
-    content: ContentQAResults;
-    /** Expert methodology compliance */
-    expert: ExpertQAResults;
-    /** Accessibility compliance */
-    accessibility: AccessibilityResults;
-    /** Overall pass/fail */
+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? */
     passed: boolean;
-    /** List of issues found */
-    issues: QAIssue[];
+    /** Specific violations found */
+    violations: Violation[];
 }
-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;
+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;
+}
+interface DeckScore {
+    /** Overall deck score (0-100) */
+    total: number;
+    /** Individual slide scores */
+    slideScores: SlideScore[];
+    /** Holistic checks */
+    holistic: HolisticScore;
+    /** Did the deck pass? */
     passed: boolean;
-    issues: string[];
-}
-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[];
+    /** Deck-level violations */
+    violations: Violation[];
+}
+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 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 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 GlanceTestResult {
-    slideIndex: number;
-    keyMessage: string;
-    wordCount: number;
-    readingTime: number;
-    passed: boolean;
-    recommendation?: string;
+interface KBTypography {
+    titles?: string;
+    body?: string;
+    action_title?: string;
+    section_headers?: string;
+    data_labels?: string;
+    max_fonts: number;
+}
+interface KBScoringWeights {
+    visual_quality: number;
+    content_quality: number;
+    expert_compliance: number;
+    accessibility: number;
 }
-interface SignalNoiseResult {
-    slideIndex: number;
-    signalCount: number;
-    noiseCount: number;
-    signalRatio: number;
-    passed: boolean;
-    noiseElements: string[];
+interface KBScoringRubric {
+    total_points: number;
+    passing_threshold: number;
+    categories: {
+        visual_quality: KBScoringCategory;
+        content_quality: KBScoringCategory;
+        expert_compliance: KBScoringCategory;
+        accessibility: KBScoringCategory;
+    };
 }
-interface OneIdeaResult {
-    slideIndex: number;
-    ideaCount: number;
-    mainIdea: string;
-    passed: boolean;
-    conflictingIdeas?: string[];
+interface KBScoringCategory {
+    weight: number;
+    checks: Record<string, KBCheck>;
 }
-interface ExpertQAResults {
-    /** Nancy Duarte validation */
-    duarte: ExpertValidation;
-    /** Garr Reynolds validation */
-    reynolds: ExpertValidation;
-    /** Carmine Gallo validation */
-    gallo: ExpertValidation;
-    /** Chris Anderson validation */
-    anderson: ExpertValidation;
+interface KBCheck {
+    points: number;
+    description: string;
+    validation?: string;
 }
-interface ExpertValidation {
-    expertName: string;
-    principlesChecked: string[];
-    passed: boolean;
-    score: number;
-    violations: string[];
+interface KBExpert {
+    name: string;
+    core_principles: Record<string, KBPrinciple>;
 }
-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 KBPrinciple {
+    description: string;
+    rules?: string[];
+    examples?: string[];
 }
-interface ContrastIssue {
-    slideIndex: number;
-    element: string;
-    foreground: string;
-    background: string;
-    ratio: number;
-    required: number;
+interface ContentAnalysis {
+    /** Detected presentation type */
+    detectedType: PresentationType;
+    /** Extracted title */
+    title: string;
+    /** Sections found */
+    sections: ContentSection[];
+    /** Key messages */
+    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;
 }
-interface FontSizeIssue {
-    slideIndex: number;
-    element: string;
-    actualSize: number;
-    minimumSize: number;
+interface SCQAStructure {
+    situation: string;
+    complication: string;
+    question: string;
+    answer: string;
 }
-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 SparklineStructure {
+    whatIs: string[];
+    whatCouldBe: string[];
+    starMoment?: string;
+    callToAdventure: string;
 }
 interface PresentationResult {
     /** Generated outputs */
@@ -278,1786 +251,1191 @@ interface PresentationResult {
         html?: string;
         pptx?: Buffer;
     };
-    /** QA validation results */
-    qaResults: QAResults;
-    /** Overall QA score (0-100) */
-    score: number;
-    /** Presentation metadata */
+    /** Slides generated */
+    slides: Slide[];
+    /** Final deck score */
+    score: DeckScore;
+    /** Metadata */
     metadata: PresentationMetadata;
 }
 interface PresentationMetadata {
-    /** Presentation title */
     title: string;
-    /** Author */
     author: string;
-    /** Generation timestamp */
+    presentationType: PresentationType;
     generatedAt: string;
-    /** Presentation mode */
-    mode: PresentationMode;
-    /** Total slide count */
     slideCount: number;
-    /** Total word count */
-    wordCount: number;
-    /** Average words per slide */
+    totalWords: number;
     avgWordsPerSlide: number;
-    /** Estimated presentation duration (minutes) */
-    estimatedDuration: number;
-    /** Themes/frameworks used */
-    frameworks: string[];
-}
-interface ContentAnalysis {
-    /** SCQA structure extracted */
-    scqa: SCQAStructure;
-    /** Sparkline narrative arc */
-    sparkline: SparklineStructure;
-    /** Key messages identified */
-    keyMessages: string[];
-    /** Generated action titles */
-    titles: string[];
-    /** STAR moments identified */
-    starMoments: string[];
-    /** Estimated slide count */
-    estimatedSlideCount: number;
-}
-interface SCQAStructure {
-    situation: string;
-    complication: string;
-    question: string;
-    answer: string;
-}
-interface SparklineStructure {
-    whatIs: string[];
-    whatCouldBe: string[];
-    callToAdventure: string;
-}
-declare class ValidationError extends Error {
-    errors: string[];
-    constructor(errors: string[], message?: 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);
+    kbVersion: string;
 }
 
 /**
- * Score Calculator - QA Score Computation
+ * KnowledgeGateway - Single Point of Access to the Knowledge Base
  *
- * Calculates presentation quality scores based on:
- * - Visual quality (35%)
- * - Content quality (30%)
- * - Expert methodology compliance (25%)
- * - Accessibility (10%)
+ * 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.
  */
 
-interface ScoreBreakdown {
-    visual: number;
-    content: number;
-    expert: number;
-    accessibility: number;
-    total: number;
-    penalties: number;
-    details: ScoreDetail[];
-}
-interface ScoreDetail {
-    category: string;
-    check: string;
-    score: number;
-    maxScore: number;
-    notes?: string;
+/**
+ * Result wrapper that includes KB path for debugging
+ */
+interface KBResult<T> {
+    value: T;
+    kbPath: string;
 }
-declare class ScoreCalculator {
-    private readonly weights;
-    /**
-     * Calculate overall QA score from results.
-     */
-    calculate(results: QAResults): number;
-    /**
-     * Get detailed score breakdown.
-     */
-    getBreakdown(results: QAResults): ScoreBreakdown;
-    /**
-     * Calculate visual quality score.
-     */
-    private calculateVisualScore;
-    /**
-     * Calculate content quality score.
-     */
-    private calculateContentScore;
-    /**
-     * Calculate expert methodology compliance score.
-     */
-    private calculateExpertScore;
-    /**
-     * Calculate accessibility compliance score.
-     */
-    private calculateAccessibilityScore;
-    /**
-     * Calculate penalties from issues.
-     */
-    private calculatePenalties;
+/**
+ * KnowledgeGateway - The ONLY way to access KB data
+ */
+declare class KnowledgeGateway {
+    private data;
+    private loaded;
+    private version;
     /**
-     * Get human-readable grade from score.
+     * Load the knowledge base from YAML.
+     * MUST be called before any queries.
      */
-    getGrade(score: number): string;
+    load(): Promise<void>;
     /**
-     * Get pass/fail status.
+     * Get KB version
      */
-    isPassing(score: number, threshold?: number): boolean;
+    getVersion(): string;
     /**
-     * Format score for display.
+     * Get complete presentation type configuration.
+     * @throws KBQueryError if type not found
      */
-    formatScore(score: number): string;
+    getPresentationType(type: PresentationType): KBResult<KBPresentationType>;
     /**
-     * Generate summary report.
+     * Get validation rules for a presentation type.
+     * @throws KBQueryError if rules not found
      */
-    generateReport(results: QAResults): string;
-}
-
-/**
- * QA Engine - Real Visual Quality Validation
- *
- * 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
- */
-
-declare class QAEngine {
-    private browser;
+    getValidationRules(type: PresentationType): KBResult<KBValidationRules>;
     /**
-     * Validate a presentation.
+     * Get word limits for a presentation type.
      */
-    validate(presentation: string | Buffer, options?: {
-        mode?: 'keynote' | 'business';
-        strictMode?: boolean;
-        threshold?: number;
-    }): Promise<QAResults>;
+    getWordLimits(type: PresentationType): KBResult<{
+        min: number;
+        max: number;
+        ideal: number;
+    }>;
     /**
-     * Calculate overall QA score.
+     * Get whitespace requirements.
      */
-    calculateScore(results: QAResults): number;
+    getWhitespaceRules(type: PresentationType): KBResult<{
+        min: number;
+        ideal: number;
+        max?: number;
+    }>;
     /**
-     * Create empty QA results (for when QA is skipped).
+     * Get scoring weights for a presentation type.
      */
-    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;
-}
-
-/**
- * PowerPoint Validator - PPTX Quality Validation
- *
- * Validates PowerPoint presentations for:
- * - Layout correctness
- * - Content quality (word counts, readability)
- * - Formatting consistency (fonts, colors)
- * - Accessibility compliance
- * - Expert methodology adherence
- *
- * THIS IS A MANDATORY VALIDATION - NO PPTX EXPORT WITHOUT PASSING
- */
-
-interface PPTXValidationResult {
-    passed: boolean;
-    score: number;
-    issues: PPTXIssue[];
-    perSlide: SlideValidationResult[];
-    summary: ValidationSummary;
-}
-interface PPTXIssue {
-    severity: 'error' | 'warning' | 'info';
-    category: 'layout' | 'content' | 'formatting' | 'accessibility' | 'expert';
-    slideIndex?: number;
-    message: string;
-    suggestion?: string;
-}
-interface SlideValidationResult {
-    slideIndex: number;
-    type: string;
-    passed: boolean;
-    score: number;
-    issues: PPTXIssue[];
-    metrics: {
-        wordCount: number;
-        hasTitle: boolean;
-        hasContent: boolean;
-        estimatedReadingTime: number;
-        layoutScore: number;
-    };
-}
-interface ValidationSummary {
-    totalSlides: number;
-    passedSlides: number;
-    failedSlides: number;
-    totalErrors: number;
-    totalWarnings: number;
-    categories: {
-        layout: number;
-        content: number;
-        formatting: number;
-        accessibility: number;
-        expert: number;
-    };
-}
-declare class PPTXValidator {
+    getScoringWeights(type: PresentationType): KBResult<KBScoringWeights>;
     /**
-     * Validate a set of slides before PPTX generation.
-     * This validation is MANDATORY - export will fail if score < threshold.
+     * Get allowed slide types for a presentation type.
      */
-    validate(slides: Slide[], options: {
-        mode: 'keynote' | 'business';
-        threshold?: number;
-        strictMode?: boolean;
-    }): Promise<PPTXValidationResult>;
+    getAllowedSlideTypes(type: PresentationType): KBResult<string[]>;
     /**
-     * Validate a single slide.
+     * Get required elements for a presentation type.
      */
-    private validateSlide;
+    getRequiredElements(type: PresentationType): KBResult<string[]>;
     /**
-     * Validate cross-slide consistency.
+     * Get anti-patterns to avoid for a presentation type.
      */
-    private validateCrossSlide;
+    getAntiPatterns(type: PresentationType): KBResult<string[]>;
     /**
-     * Validate against expert methodologies.
+     * Get the scoring rubric.
      */
-    private validateExpertMethodologies;
+    getScoringRubric(): KBResult<KBScoringRubric>;
     /**
-     * Count words in slide content.
+     * Get passing threshold (default: 95).
      */
-    private countWords;
+    getPassingThreshold(): KBResult<number>;
     /**
-     * Check if slide has meaningful content.
+     * Get expert methodology.
      */
-    private hasContent;
+    getExpert(name: string): KBResult<KBExpert>;
     /**
-     * Count distinct ideas in a slide.
+     * Get Nancy Duarte's glance test rules.
      */
-    private countIdeas;
+    getGlanceTest(): KBResult<{
+        description: string;
+        word_limit: number;
+    }>;
     /**
-     * Calculate layout score for a slide.
+     * Get Duarte's Sparkline framework.
      */
-    private calculateLayoutScore;
+    getSparkline(): KBResult<Record<string, unknown>>;
     /**
-     * Calculate overall validation score.
+     * Get Minto's SCQA framework.
      */
-    private calculateScore;
+    getSCQA(): KBResult<Record<string, unknown>>;
     /**
-     * Build validation summary.
+     * Get Miller's Law (7±2 items).
      */
-    private buildSummary;
+    getMillersLaw(): KBResult<{
+        principle: string;
+        application: string[];
+    }>;
     /**
-     * Convert PPTX validation result to standard QAResults format.
+     * Get accessibility requirements.
      */
-    toQAResults(result: PPTXValidationResult, mode: 'keynote' | 'business'): QAResults;
-    private createExpertValidation;
+    getAccessibilityRules(): KBResult<Record<string, unknown>>;
     /**
-     * Generate human-readable validation report.
+     * Get contrast ratio requirements.
      */
-    generateReport(result: PPTXValidationResult): string;
-}
-
-/**
- * Auto-Remediation Engine
- *
- * Instead of blocking on QA failures, this engine automatically fixes issues
- * and iterates until the presentation passes quality thresholds.
- *
- * Philosophy: NEVER fail - always deliver a working, quality presentation.
- *
- * Remediation strategies:
- * - Too many words → Summarize/split slides
- * - Poor whitespace → Adjust layout
- * - Failed glance test → Shorten titles
- * - Too many bullets → Consolidate or split
- * - Missing structure → Add required slides
- * - Accessibility issues → Fix contrast/font sizes
- */
-
-interface RemediationChange {
-    slideIndex: number;
-    type: RemediationType;
-    description: string;
-    before?: string;
-    after?: string;
-}
-type RemediationType = 'word_reduction' | 'slide_split' | 'title_shortening' | 'bullet_consolidation' | 'layout_adjustment' | 'structure_addition' | 'font_size_increase' | 'content_enhancement' | 'whitespace_improvement';
-declare class AutoRemediation {
-    private changes;
+    getContrastRequirements(): KBResult<{
+        normal_text: string;
+        large_text: string;
+    }>;
     /**
-     * Automatically remediate slides until they pass QA.
+     * Get minimum font sizes.
      */
-    remediate(slides: Slide[], issues: QAIssue[] | PPTXIssue[], options: {
-        mode: 'keynote' | 'business';
-        targetScore: number;
-    }): Promise<Slide[]>;
+    getFontSizeRequirements(): KBResult<Record<string, string>>;
     /**
-     * Get the changes that were applied during remediation.
+     * Get Tufte's data-ink ratio rules.
      */
-    getChanges(): RemediationChange[];
+    getDataInkRules(): KBResult<Record<string, unknown>>;
     /**
-     * Remediate word count issues - the most common problem.
+     * Get chartjunk to avoid.
      */
-    private remediateWordCount;
+    getChartjunk(): KBResult<string[]>;
     /**
-     * Remediate glance test failures - title too long.
+     * Get Cialdini's 6 Principles of Influence.
      */
-    private remediateGlanceTest;
+    getCialdiniPrinciples(): KBResult<Record<string, unknown>>;
     /**
-     * Remediate bullet point issues.
+     * Get specific Cialdini principle by name.
      */
-    private remediateBullets;
+    getCialdiniPrinciple(name: string): KBResult<Record<string, unknown>>;
     /**
-     * Remediate structural issues - missing title slide, conclusion, etc.
+     * Get all Gestalt principles.
      */
-    private remediateStructure;
+    getGestaltPrinciples(): KBResult<Record<string, unknown>>;
     /**
-     * Remediate accessibility issues.
+     * Get specific Gestalt principle by name.
      */
-    private remediateAccessibility;
+    getGestaltPrinciple(name: string): KBResult<Record<string, unknown>>;
     /**
-     * Group issues by their primary type.
+     * Get Gestalt proximity principle (for layout checks).
      */
-    private groupIssuesByType;
+    getGestaltProximity(): KBResult<Record<string, unknown>>;
     /**
-     * Shorten text to approximately N words while preserving meaning.
+     * Get Gestalt similarity principle (for consistency checks).
      */
-    private shortenText;
+    getGestaltSimilarity(): KBResult<Record<string, unknown>>;
     /**
-     * Shorten a title to N words, keeping the key message.
+     * Get Gestalt figure-ground principle (for visual impact checks).
      */
-    private shortenTitle;
+    getGestaltFigureGround(): KBResult<Record<string, unknown>>;
     /**
-     * Consolidate bullets by combining related ones.
+     * Query any KB path directly.
+     * @throws KBQueryError if path not found
      */
-    private consolidateBullets;
+    queryRequired<T>(path: string): KBResult<T>;
     /**
-     * Reindex slides after insertion/deletion.
+     * Query any KB path directly (optional - returns null if not found).
      */
-    private reindexSlides;
+    queryOptional<T>(path: string): KBResult<T | null>;
     /**
-     * Count words in a slide.
+     * Ensure KB is loaded.
      */
-    private countWords;
+    private ensureLoaded;
     /**
-     * Deep clone slides array.
+     * Query a dotted path in the KB.
      */
-    private deepClone;
+    private query;
     /**
-     * Generate remediation report.
+     * Create a KB query error.
      */
-    generateReport(): string;
+    private error;
 }
-
 /**
- * Hallucination Detector
- *
- * Verifies that all facts, statistics, and claims in the presentation
- * are sourced from the original content. ZERO TOLERANCE for hallucinations.
- *
- * Checks:
- * - Numbers and statistics must appear in source content
- * - Company names must be in source content
- * - Dates and timelines must be verifiable
- * - Quotes must be exact matches
- * - Claims must be supported by source material
- *
- * Philosophy: If it's not in the source, it shouldn't be in the presentation.
+ * Get the singleton KnowledgeGateway instance.
  */
-
-interface FactCheckResult {
-    passed: boolean;
-    score: number;
-    totalFacts: number;
-    verifiedFacts: number;
-    unverifiedFacts: number;
-    issues: FactCheckIssue[];
-    warnings: FactCheckWarning[];
-}
-interface FactCheckIssue {
-    slideIndex: number;
-    slideTitle: string;
-    fact: string;
-    type: 'number' | 'statistic' | 'company' | 'date' | 'quote' | 'claim';
-    severity: 'error' | 'warning';
-    message: string;
-    suggestion: string;
-}
-interface FactCheckWarning {
-    slideIndex: number;
-    message: string;
-}
-declare class HallucinationDetector {
-    private numberPattern;
-    private percentagePattern;
-    private datePattern;
-    private companyPattern;
-    private quotePattern;
-    /**
-     * Check all slides against source content for hallucinations.
-     */
-    checkForHallucinations(slides: Slide[], sourceContent: string, analysis: ContentAnalysis): Promise<FactCheckResult>;
-    /**
-     * Generate a fact-check report.
-     */
-    generateReport(result: FactCheckResult): string;
-    /**
-     * Auto-remediate hallucinations by removing unverified facts.
-     */
-    remediate(slides: Slide[], result: FactCheckResult): Slide[];
-    private normalizeText;
-    private getSlideText;
-    private extractNumbers;
-    private extractCompanies;
-    private extractDates;
-    private isNumberInSource;
-    private isCompanyInSource;
-    private isDateInSource;
-    private isCommonWord;
-    private checkForUnsupportedClaims;
-    private getPlaceholder;
-}
+declare function getKB(): KnowledgeGateway;
+/**
+ * Initialize and return the KB (async).
+ */
+declare function initKB(): Promise<KnowledgeGateway>;
 
 /**
- * Presentation Engine - Main Orchestrator
- *
- * Coordinates content analysis, slide generation, and QA validation
- * to produce world-class presentations.
+ * ContentAnalyzer - Parse and Analyze Input Content
  *
- * PHILOSOPHY: NEVER FAIL - ALWAYS DELIVER
- *
- * Instead of blocking on QA failures, this engine:
- * 1. Validates the presentation
- * 2. If issues found, automatically remediates them
- * 3. Re-validates
- * 4. Repeats until it passes (max 5 iterations)
- * 5. ALWAYS delivers a working presentation
+ * 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
  */
 
-declare class PresentationEngine {
-    private contentAnalyzer;
-    private slideFactory;
-    private templateEngine;
-    private scoreCalculator;
-    private typeDetector;
-    private strategyFactory;
-    private qaEngine;
-    private pptxValidator;
-    private htmlLayoutValidator;
-    private autoRemediation;
-    private hallucinationDetector;
-    private htmlGenerator;
-    private pptxGenerator;
+declare class ContentAnalyzer {
+    private kb;
+    private initialized;
     constructor();
+    initialize(): Promise<void>;
     /**
-     * Generate a presentation from content.
-     *
-     * GUARANTEED DELIVERY:
-     * - Validates presentation quality
-     * - Automatically fixes any issues found
-     * - Iterates until quality threshold is met
-     * - ALWAYS returns a working presentation
-     *
-     * @param config - Presentation configuration
-     * @returns Presentation result with outputs, QA results, and score
+     * Analyze content and return structured analysis.
      */
-    generate(config: PresentationConfig): Promise<PresentationResult>;
+    analyze(content: string, contentType?: 'markdown' | 'text'): Promise<ContentAnalysis>;
     /**
-     * Validate slides and automatically remediate until they pass.
-     * Includes hallucination detection to ensure all facts are sourced.
+     * Parse content into sections based on headers.
      */
-    private validateAndRemediate;
+    private parseSections;
     /**
-     * Validate presentation configuration.
+     * Extract title from content.
      */
-    private validateConfig;
+    private extractTitle;
     /**
-     * Count words in a slide.
+     * Extract bullet points from content.
+     * Strips markdown formatting (**bold**, *italic*, `code`) from bullet text.
      */
-    private countWords;
+    private extractBullets;
     /**
-     * Build presentation metadata.
+     * Strip markdown formatting from text.
+     * Converts **bold**, *italic*, `code`, [links](url) to plain text.
      */
-    private buildMetadata;
+    private stripMarkdown;
     /**
-     * Detect which expert frameworks were applied.
+     * Extract data points (metrics, percentages, currencies, numbers).
      */
-    private detectFrameworks;
+    private extractDataPoints;
     /**
-     * Get QA Engine for external access.
+     * Get surrounding context for a data point.
      */
-    getQAEngine(): QAEngine;
+    private getContext;
     /**
-     * Get PPTX Validator for external access.
+     * Parse numeric value from string (handles M/B/K suffixes).
      */
-    getPPTXValidator(): PPTXValidator;
+    private parseNumericValue;
     /**
-     * Get Score Calculator for external access.
+     * Extract key messages from sections.
      */
-    getScoreCalculator(): ScoreCalculator;
+    private extractKeyMessages;
+    /**
+     * Detect presentation type based on content signals.
+     */
+    private detectPresentationType;
     /**
-     * Get Auto Remediation for external access.
+     * Identify SCQA (Situation, Complication, Question, Answer) structure.
      */
-    getAutoRemediation(): AutoRemediation;
+    private identifySCQA;
     /**
-     * Get Hallucination Detector for external access.
+     * Identify Sparkline (What Is / What Could Be) structure.
      */
-    getHallucinationDetector(): HallucinationDetector;
+    private identifySparkline;
 }
+declare function getContentAnalyzer(): ContentAnalyzer;
+declare function initContentAnalyzer(): Promise<ContentAnalyzer>;
 
 /**
- * Content Analyzer - Extracts Structure from Raw Content
+ * 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
  *
- * 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
+ * ALL decisions come from the Knowledge Base. NO hardcoded fallbacks.
  */
 
-declare class ContentAnalyzer {
-    private readonly situationSignals;
-    private readonly complicationSignals;
-    private readonly questionSignals;
-    private readonly answerSignals;
-    private readonly whatIsSignals;
-    private readonly whatCouldBeSignals;
-    /**
-     * Analyze content and extract structural elements.
-     */
-    analyze(content: string, contentType: string): Promise<ContentAnalysis>;
-    /**
-     * Parse content based on its type.
-     */
-    private parseContent;
-    /**
-     * Parse markdown content to plain text (preserving structure hints).
-     */
-    private parseMarkdown;
-    /**
-     * Parse JSON content.
-     */
-    private parseJSON;
-    /**
-     * Parse YAML content.
-     */
-    private parseYAML;
-    /**
-     * Flatten object to text.
-     */
-    private flattenObject;
-    /**
-     * Split text into paragraphs.
-     */
-    private splitIntoParagraphs;
-    /**
-     * Split text into sentences.
-     */
-    private splitIntoSentences;
+declare class SlideGenerator {
+    private kb;
+    private vds;
+    private initialized;
+    private wordLimits;
+    private bulletLimit;
+    private allowedSlideTypes;
+    constructor();
+    initialize(): Promise<void>;
     /**
-     * Extract SCQA structure (Barbara Minto's Pyramid Principle).
+     * Generate slides from content analysis.
      */
-    private extractSCQA;
+    generate(analysis: ContentAnalysis, presentationType: PresentationType): Promise<Slide[]>;
+    private loadRulesForType;
     /**
-     * Extract Sparkline structure (Nancy Duarte).
+     * Create title slide.
      */
-    private extractSparkline;
+    private createTitleSlide;
     /**
-     * Extract key messages (max 3 - Rule of Three).
+     * Create agenda slide.
      */
-    private extractKeyMessages;
+    private createAgendaSlide;
     /**
-     * Generate action titles (McKinsey-style).
+     * Create SCQA slides (Situation, Complication, Question, Answer).
      */
-    private generateActionTitles;
+    private createSCQASlides;
     /**
-     * Transform a statement into an action title.
+     * Create slides for a content section.
      */
-    private transformToActionTitle;
+    private createSectionSlides;
     /**
-     * Identify STAR moments (Something They'll Always Remember).
+     * Create metrics grid slide from data points.
      */
-    private identifyStarMoments;
+    private createMetricsSlide;
     /**
-     * Estimate slide count based on content.
+     * Create metrics grid slide from a section.
      */
-    private estimateSlideCount;
-    private containsSignals;
-    private extractRelevantSentence;
-    private truncateToSentence;
-    private truncateToWords;
-    private capitalizeFirst;
-}
-
-/**
- * Slide Factory - Creates Slides from Content Analysis
- *
- * Generates slide structures based on:
- * - Presentation mode (keynote vs business)
- * - Presentation type (7 specialized strategies)
- * - Content analysis results
- * - Expert methodology recommendations
- */
-
-declare class SlideFactory {
-    private readonly templates;
-    private readonly strategyFactory;
-    constructor();
+    private createMetricsGridSlide;
     /**
-     * Create slides from analyzed content.
-     * If presentationType is provided, uses the specialized strategy.
-     * Otherwise, falls back to mode-based generation.
+     * Create STAR moment slide (Something They'll Always Remember).
      */
-    createSlides(analysis: ContentAnalysis, mode: PresentationMode, presentationType?: PresentationType): Promise<Slide[]>;
+    private createStarMomentSlide;
     /**
-     * Create a title slide.
+     * Create call to action slide.
      */
-    private createTitleSlide;
+    private createCallToActionSlide;
     /**
-     * Create an agenda slide.
+     * Create thank you / closing slide.
      */
-    private createAgendaSlide;
+    private createThankYouSlide;
     /**
-     * Create a context/situation slide.
+     * Determine the best slide type for a section.
      */
-    private createContextSlide;
+    private determineSlideType;
     /**
-     * Create a problem/complication slide.
+     * Check if presentation type favors minimal slides.
      */
-    private createProblemSlide;
+    private isMinimalType;
     /**
-     * Create a key message slide.
+     * Strip all markdown syntax from text for clean slide content.
+     * This is called on ALL text going into slides to prevent raw markdown.
      */
-    private createMessageSlide;
+    private stripMarkdownSyntax;
     /**
-     * Create a STAR moment slide.
+     * Clean bullets - strip markdown and extract complete, meaningful phrases.
+     * CRITICAL: Never truncate mid-sentence. Keep bullets SHORT (3-5 words each).
+     * For sales_pitch with max 30 words: 4 bullets × 5 words = 20 words (leaves room for title)
      */
-    private createStarMomentSlide;
+    private cleanBullets;
     /**
-     * Create a solution/answer slide.
+     * Truncate text to word limit, stripping markdown first.
+     * NEVER adds "..." - just takes the complete words that fit.
      */
-    private createSolutionSlide;
+    private truncateToWordLimit;
     /**
-     * Create a call-to-action slide.
+     * Extract a key statement from content (first sentence or bold text).
      */
-    private createCTASlide;
+    private extractKeyStatement;
     /**
-     * Create a thank you slide.
+     * Extract a key message from title and body for single_statement slides.
+     * Returns a concise, impactful message that provides substance.
      */
-    private createThankYouSlide;
+    private extractKeyMessage;
     /**
-     * Initialize slide templates with constraints.
+     * Extract a label from context (nearby text around a data point).
      */
-    private initializeTemplates;
+    private extractLabelFromContext;
     /**
-     * Truncate text to max length at word boundary.
+     * Detect trend from context (up, down, neutral).
      */
-    private truncate;
+    private detectTrend;
     /**
-     * Extract an action title from a message.
+     * Split array into chunks.
      */
-    private extractActionTitle;
+    private chunkArray;
     /**
-     * Extract bullet points from text.
+     * Generate meaningful titles for chunked bullet lists.
+     * Instead of "Title (continued)", create contextual subtitles.
      */
-    private extractBullets;
+    private generateChunkTitles;
     /**
-     * Remove a statistic from text.
+     * Extract a meaningful subtitle from bullet content.
      */
-    private removeStatistic;
+    private extractSubtitleFromBullets;
 }
+declare function getSlideGenerator(): SlideGenerator;
+declare function initSlideGenerator(): Promise<SlideGenerator>;
 
 /**
- * Template Engine - Handlebars Template Rendering
+ * VisualDesignSystem - KB-Driven Visual Design Configuration
  *
- * Renders slide data into HTML using Handlebars templates.
- * Supports custom templates and helper functions.
+ * CRITICAL: ALL design decisions come from the Knowledge Base.
+ * This module queries KB for colors, typography, gradients, layouts.
+ * NO hardcoded fallbacks.
  */
 
-interface TemplateConfig {
-    customTemplates?: Record<string, string>;
-    theme?: ThemeName;
+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;
+}
+interface GradientDefinition {
+    name: string;
+    css: string;
+    angle?: number;
+    stops: Array<{
+        color: string;
+        position: string;
+    }>;
+}
+interface SlideLayout {
+    name: string;
+    purpose: string;
+    elements: string[];
+    wordLimit?: number;
+    grid?: {
+        columns: number;
+        rows?: number;
+        gap: string;
+    };
 }
-declare class TemplateEngine {
-    private handlebars;
-    private templates;
-    private partials;
+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();
     /**
-     * Render a slide to HTML.
+     * Initialize the design system (loads KB)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get complete visual theme for a presentation type.
      */
-    render(slide: Slide, config?: TemplateConfig): string;
+    getTheme(type: PresentationType): Promise<VisualTheme>;
     /**
-     * Render multiple slides.
+     * Determine mode (keynote vs business) for a presentation type.
      */
-    renderAll(slides: Slide[], config?: TemplateConfig): string[];
+    private getModeForType;
     /**
-     * Prepare template context with computed properties.
+     * Get color palette for presentation type from KB.
      */
-    private prepareContext;
+    private getPaletteForType;
     /**
-     * Build CSS class list for slide.
+     * Get typography rules for mode from KB.
      */
-    private buildClassList;
+    private getTypographyForMode;
     /**
-     * Build inline style string.
+     * Get layout rules for mode from KB.
      */
-    private buildStyleString;
+    private getLayoutRulesForMode;
     /**
-     * Register Handlebars helpers.
+     * Get gradient definitions for presentation type.
      */
-    private registerHelpers;
+    private getGradientsForType;
     /**
-     * Register reusable partials.
+     * Build CSS custom properties for the theme.
      */
-    private registerPartials;
+    private buildCSSVariables;
     /**
-     * Compile built-in templates.
+     * Get slide layout templates from KB.
      */
-    private compileTemplates;
+    getSlideLayouts(type: PresentationType): Promise<SlideLayout[]>;
     /**
-     * Render fallback for unknown slide types.
+     * Generate complete CSS for the theme.
      */
-    private renderFallback;
+    generateCSS(theme: VisualTheme): string;
+    private lightenColor;
+    private darkenColor;
+    private hexToRgb;
     /**
-     * Convert camelCase to kebab-case.
+     * Get contrasting text color for a given background color.
+     * Returns white or black based on luminance.
      */
-    private kebabCase;
+    private getContrastColor;
 }
+declare function getVisualDesignSystem(): VisualDesignSystem;
+declare function initVisualDesignSystem(): Promise<VisualDesignSystem>;
 
 /**
- * Accessibility Validator - WCAG Compliance Testing
+ * SlideQualityReviewer - THE HEART OF THE QUALITATIVE REVIEW SYSTEM
  *
- * Provides comprehensive accessibility validation using:
- * - Axe-core for automated WCAG testing
- * - Custom contrast ratio validation
- * - Font size compliance
- * - Keyboard navigation coverage
- * - Color-blind safety checks
+ * 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
  *
- * MANDATORY: All presentations must meet WCAG AA minimum.
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
  */
 
-interface A11yValidationResult {
-    passed: boolean;
-    wcagLevel: 'A' | 'AA' | 'AAA' | 'FAIL';
+type QualityLevel = 'excellent' | 'good' | 'acceptable' | 'poor' | 'failing';
+interface QualitativeAssessment {
+    /** Score (0-100) */
     score: number;
-    issues: A11yIssue[];
-    axeResults?: AxeResult[];
-    contrastIssues: ContrastIssue[];
-    fontSizeIssues: FontSizeIssue[];
-    keyboardIssues: KeyboardIssue[];
-    colorBlindSafe: boolean;
-}
-interface A11yIssue {
-    severity: 'critical' | 'serious' | 'moderate' | 'minor';
-    type: 'contrast' | 'font-size' | 'keyboard' | 'aria' | 'structure' | 'color';
-    slideIndex?: number;
-    element?: string;
-    message: string;
-    wcagCriteria?: string;
-    suggestion?: string;
-}
-interface AxeResult {
-    id: string;
-    impact: 'critical' | 'serious' | 'moderate' | 'minor';
-    description: string;
-    nodes: number;
-}
-interface KeyboardIssue {
-    slideIndex: number;
-    element: string;
+    /** 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;
-}
-declare class AccessibilityValidator {
-    private browser;
-    /**
-     * Validate accessibility of an HTML presentation.
-     */
-    validate(html: string, options?: {
-        targetLevel?: 'A' | 'AA' | 'AAA';
-        projectionMode?: boolean;
-    }): Promise<A11yValidationResult>;
-    /**
-     * Check color contrast compliance.
-     */
-    private checkContrast;
-    /**
-     * Check font size compliance.
-     */
-    private checkFontSizes;
+    fix: string;
+    kbReference?: string;
+}
+declare class SlideQualityReviewer {
+    private kb;
+    private initialized;
+    private wordLimits;
+    private whitespaceRules;
+    private bulletLimit;
+    private glanceTestSeconds;
+    private hasCialdini;
+    private hasGestalt;
+    private hasTufteDataInk;
+    private chartjunkToAvoid;
+    constructor();
+    initialize(): Promise<void>;
     /**
-     * Check keyboard navigation accessibility.
+     * Review a slide qualitatively.
      */
-    private checkKeyboardNavigation;
+    review(slide: Slide, presentationType: PresentationType): Promise<QualitativeSlideReview>;
     /**
-     * Check document structure accessibility.
+     * Convert qualitative review to SlideScore format.
      */
-    private checkStructure;
+    toSlideScore(review: QualitativeSlideReview): SlideScore;
+    private loadRulesForType;
     /**
-     * Check color-blind safety.
+     * Visual Impact (25%): Does this slide command attention appropriately?
      */
-    private checkColorBlindSafety;
+    private assessVisualImpact;
     /**
-     * Calculate contrast ratio between two colors.
+     * Content Clarity (20%): Can you understand the message in 3 seconds?
      */
-    private calculateContrastRatio;
+    private assessContentClarity;
     /**
-     * Calculate relative luminance of a color.
+     * Get all text content from a slide for analysis.
      */
-    private getRelativeLuminance;
+    private getAllTextContent;
     /**
-     * Determine WCAG compliance level.
+     * Layout Balance (15%): Is visual weight distributed appropriately?
      */
-    private determineWCAGLevel;
+    private assessLayoutBalance;
     /**
-     * Calculate accessibility score.
+     * Typography Hierarchy (15%): Is there clear primary/secondary/tertiary hierarchy?
      */
-    private calculateScore;
+    private assessTypographyHierarchy;
     /**
-     * Generate accessibility report.
+     * Whitespace Usage (10%): Is whitespace used purposefully?
      */
-    generateReport(result: A11yValidationResult): string;
-    private initBrowser;
-    private closeBrowser;
-}
-
-/**
- * HTML Layout Validator - Bulletproof Viewport Enforcement
- *
- * This validator TESTS rendered HTML presentations to VERIFY:
- * 1. No content overflows the slide boundaries
- * 2. All text is readable (not clipped)
- * 3. All elements fit within the viewport
- * 4. No horizontal scrolling is needed
- *
- * PHILOSOPHY: VERIFY, DON'T GUESS
- * - Uses Playwright to actually render the presentation
- * - Measures real DOM elements
- * - Checks computed styles
- * - Takes screenshots as evidence
- *
- * THIS IS MANDATORY - No HTML export without passing layout validation
- */
-interface LayoutValidationResult {
-    passed: boolean;
-    score: number;
-    issues: LayoutIssue[];
-    perSlide: SlideLayoutResult[];
-    screenshots?: Buffer[];
-}
-interface LayoutIssue {
-    severity: 'error' | 'warning' | 'info';
-    slideIndex: number;
-    element?: string;
-    message: string;
-    suggestion: string;
-    measurements?: {
-        elementWidth?: number;
-        elementHeight?: number;
-        viewportWidth?: number;
-        viewportHeight?: number;
-        overflow?: {
-            x: number;
-            y: number;
-        };
-    };
-}
-interface SlideLayoutResult {
-    slideIndex: number;
-    passed: boolean;
-    score: number;
-    issues: LayoutIssue[];
-    measurements: {
-        contentHeight: number;
-        viewportHeight: number;
-        contentWidth: number;
-        viewportWidth: number;
-        overflowY: number;
-        overflowX: number;
-        hasScrollbar: boolean;
-        clippedElements: string[];
-    };
-}
-declare class HTMLLayoutValidator {
-    private playwright;
+    private assessWhitespaceUsage;
     /**
-     * Validate HTML presentation layout using real browser rendering.
-     * This is the MANDATORY check before any HTML export.
+     * Color Harmony (10%): Do colors work together within the theme?
      */
-    validate(html: string): Promise<LayoutValidationResult>;
+    private assessColorHarmony;
     /**
-     * Validate a single slide's layout using Playwright.
+     * Audience Appropriateness (5%): Is the visual style right for this audience?
      */
-    private validateSlide;
+    private assessAudienceAppropriate;
+    private isMinimalType;
+    private isDenseType;
+    private countWords;
+    private countLongWords;
     /**
-     * Static HTML analysis fallback when Playwright isn't available.
-     * Analyzes CSS and HTML structure without rendering.
+     * Detect raw markdown syntax that should have been rendered to HTML.
+     * Returns array of issue descriptions.
      */
-    private validateStaticHTML;
+    private detectRawMarkdown;
     /**
-     * Generate remediation suggestions for layout issues.
+     * Check if slide type is appropriate for its content.
+     * Returns issue description if mismatched.
      */
-    generateRemediationPlan(result: LayoutValidationResult): string[];
+    private checkSlideTypeMismatch;
+    private scoreToLevel;
+    private collectIssues;
+    private mapAssessmentToCategory;
+    private mapIssueCategory;
+    private generateImprovements;
+    private createCategoryScore;
 }
+declare function getSlideQualityReviewer(): SlideQualityReviewer;
+declare function initSlideQualityReviewer(): Promise<SlideQualityReviewer>;
 
 /**
- * Presentation Type Detector
+ * DeckQualityReviewer - HOLISTIC DECK QUALITY REVIEW
  *
- * Determines the appropriate presentation type based on:
- * 1. Explicit presentationType configuration
- * 2. Audience specification
- * 3. Goal specification
- * 4. Keyword analysis of content
- * 5. Legacy mode fallback
+ * 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?
  *
- * Each presentation type has distinct validation rules that do not conflict.
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
  */
 
-/**
- * Validation rules for each presentation type
- */
-declare const PRESENTATION_TYPE_RULES: Record<PresentationType, PresentationTypeRules>;
-declare class TypeDetector {
-    /**
-     * Detect the presentation type from configuration.
-     * Priority:
-     * 1. Explicit presentationType
-     * 2. Audience mapping
-     * 3. Goal mapping
-     * 4. Content keyword analysis
-     * 5. Legacy mode fallback
-     */
-    detectType(config: PresentationConfig): PresentationType;
-    /**
-     * Detect presentation type from keyword analysis.
-     */
-    private detectFromKeywords;
-    /**
-     * Get validation rules for a presentation type.
-     */
-    getRules(type: PresentationType): PresentationTypeRules;
+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>;
     /**
-     * Get all available presentation types.
+     * Review the entire deck qualitatively.
      */
-    getAvailableTypes(): PresentationType[];
+    review(slides: Slide[], presentationType: PresentationType): Promise<QualitativeDeckReview>;
     /**
-     * Map legacy mode to a presentation type.
+     * Convert qualitative review to DeckScore format.
      */
-    modeToType(mode: 'keynote' | 'business'): PresentationType;
+    toDeckScore(review: QualitativeDeckReview): DeckScore;
+    private loadRulesForType;
     /**
-     * Map presentation type back to legacy mode for compatibility.
+     * Narrative Flow (30%): Does the presentation tell a coherent story?
      */
-    typeToMode(type: PresentationType): 'keynote' | 'business';
+    private assessNarrativeFlow;
     /**
-     * Get word limits for a presentation type.
+     * Visual Consistency (25%): Is the same theme applied throughout?
      */
-    getWordLimits(type: PresentationType): {
-        min: number;
-        max: number;
-        ideal: number;
-    };
+    private assessVisualConsistency;
     /**
-     * Check if action titles are required for a type.
+     * Pacing & Rhythm (20%): Is there variety in slide types and density?
      */
-    requiresActionTitles(type: PresentationType): boolean;
+    private assessPacingRhythm;
     /**
-     * Check if sources are required for a type.
+     * Opening & Closing (15%): Are the first and last slides the strongest?
      */
-    requiresSources(type: PresentationType): boolean;
+    private assessOpeningClosing;
     /**
-     * Get scoring weights for a presentation type.
+     * Overall Impression (10%): Would you hire/invest based on this?
      */
-    getScoringWeights(type: PresentationType): {
-        visual_quality: number;
-        content_quality: number;
-        expert_compliance: number;
-        accessibility: number;
-    };
+    private assessOverallImpression;
+    private scoreToLevel;
+    private calculateVariance;
+    private getMissingRequiredElements;
+    private collectDeckIssues;
+    private mapAssessmentToCategory;
+    private mapDeckCategory;
+    private generateDeckImprovements;
+    private calculateRequiredElementsScore;
+    private calculateAntiPatternScore;
 }
+declare function getDeckQualityReviewer(): DeckQualityReviewer;
+declare function initDeckQualityReviewer(): Promise<DeckQualityReviewer>;
 
 /**
- * Execution Strategy Types
+ * Remediator - Fix Failing Slides
  *
- * Types for the presentation execution strategy system.
- */
-
-/**
- * A blueprint for a single slide in a presentation.
- */
-interface SlideBlueprint {
-    /** Unique identifier for this slide in the sequence */
-    id: string;
-    /** Human-readable name */
-    name: string;
-    /** Slide type to use */
-    type: SlideType;
-    /** Is this slide required or optional? */
-    required: boolean;
-    /** Purpose of this slide (for content guidance) */
-    purpose: string;
-    /** Data fields this slide needs */
-    requiredData: string[];
-    /** Optional data fields */
-    optionalData: string[];
-    /** Word count constraints */
-    wordLimits: {
-        min: number;
-        max: number;
-        ideal: number;
-    };
-    /** Expert principles that apply to this slide */
-    expertPrinciples: string[];
-    /** Visual design notes */
-    designNotes: string[];
-    /** Example content (for guidance) */
-    example?: {
-        title?: string;
-        subtitle?: string;
-        bullets?: string[];
-        body?: string;
-    };
-}
-/**
- * A content transformation rule.
- */
-interface ContentTransform {
-    /** What to look for in the source content */
-    sourcePattern: string | RegExp;
-    /** How to transform it */
-    transform: (match: string, analysis: ContentAnalysis) => string;
-    /** Description of the transformation */
-    description: string;
-}
-/**
- * An execution strategy for a presentation type.
- */
-interface ExecutionStrategy {
-    /** Presentation type this strategy is for */
-    type: PresentationType;
-    /** Human-readable name */
-    name: string;
-    /** Description */
-    description: string;
-    /** Expert methodologies to apply */
-    experts: {
-        primary: string;
-        secondary: string[];
-    };
-    /** The slide sequence (ordered list of blueprints) */
-    slideSequence: SlideBlueprint[];
-    /** Content transformation rules */
-    contentTransforms: ContentTransform[];
-    /** Quality benchmarks */
-    qualityBenchmarks: {
-        minScore: number;
-        criticalChecks: string[];
-        excellenceIndicators: string[];
-    };
-    /**
-     * Generate slides from content analysis.
-     */
-    generateSlides(analysis: ContentAnalysis): Promise<Slide[]>;
-    /**
-     * Validate slides against this strategy's requirements.
-     */
-    validateSlides(slides: Slide[]): {
-        passed: boolean;
-        score: number;
-        issues: string[];
-        suggestions: string[];
-    };
-    /**
-     * Apply expert methodology transformations.
-     */
-    applyExpertMethodology(slides: Slide[]): Slide[];
-}
-
-/**
- * Strategy Factory
+ * 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
  *
- * Selects the appropriate execution strategy based on presentation type.
- * Each strategy encapsulates world-class expertise for its domain.
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
  */
 
-/**
- * Factory for creating presentation execution strategies.
- */
-declare class StrategyFactory {
-    private strategies;
+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;
     constructor();
+    initialize(): Promise<void>;
     /**
-     * Get the execution strategy for a presentation type.
+     * Attempt to remediate a failing slide.
      */
-    getStrategy(type: PresentationType): ExecutionStrategy;
+    remediate(slide: Slide, presentationType: PresentationType, initialReview: QualitativeSlideReview): Promise<RemediationResult>;
     /**
-     * Get all available strategies.
+     * Batch remediate multiple slides.
      */
-    getAllStrategies(): ExecutionStrategy[];
-    /**
-     * Get strategy descriptions for user guidance.
-     */
-    getStrategyDescriptions(): Record<PresentationType, string>;
-    /**
-     * Get the primary expert for a presentation type.
-     */
-    getPrimaryExpert(type: PresentationType): string;
-    /**
-     * Get all experts for a presentation type.
-     */
-    getAllExperts(type: PresentationType): string[];
+    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;
 }
+declare function getRemediator(): Remediator;
+declare function initRemediator(): Promise<Remediator>;
 
 /**
- * Reveal.js Generator - HTML Presentation Output
+ * Renderer - Premium HTML/PPTX Output Generation
+ *
+ * Renders slides to high-quality outputs:
+ * - HTML: Reveal.js with premium CSS from KB
+ * - PPTX: PowerPoint (future implementation)
  *
- * Generates complete Reveal.js presentations with:
- * - Responsive layouts
- * - Animations
- * - Speaker notes
- * - Custom themes
- * - Chart.js integration
- * - Mermaid diagrams
+ * ALL styling comes from the Knowledge Base and VisualDesignSystem.
+ * NO hardcoded styles.
  */
 
-declare class RevealJsGenerator {
-    private templateEngine;
-    private defaultRevealConfig;
+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 RenderResult {
+    html?: string;
+    pptx?: Buffer;
+}
+declare class Renderer {
+    private kb;
+    private vds;
+    private initialized;
+    private readonly slideImageKeywords;
     constructor();
+    initialize(): Promise<void>;
     /**
-     * Generate complete Reveal.js HTML presentation.
+     * Render slides to specified formats.
      */
-    generate(slides: Slide[], config: PresentationConfig): Promise<string>;
+    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;
     /**
-     * Build the complete HTML document.
+     * Generate a background image URL based on slide type and content.
+     * Priority: 1) slide.data.image, 2) local images array, 3) Picsum fallback
      */
-    private buildDocument;
+    private getBackgroundImageUrl;
     /**
-     * Get base styles for slides.
-     *
-     * BULLETPROOF OVERFLOW PROTECTION:
-     * 1. All slides use height: 100vh to match viewport exactly
-     * 2. overflow: hidden on slide sections clips content at boundaries
-     * 3. All child elements use flex-shrink: 1 and min-height: 0 to allow shrinking
-     * 4. Tables use max-height with overflow: auto for scrolling if needed
-     * 5. Two-column layouts use smaller font sizes to prevent overflow
+     * Resolve an image path - handles relative paths, absolute paths, and URLs.
      */
-    private getBaseStyles;
+    private resolveImagePath;
     /**
-     * Get theme-specific styles.
+     * Generate fallback image URL using Picsum with smart seeding.
      */
-    private getThemeStyles;
+    private getFallbackImageUrl;
     /**
-     * Get animation styles.
+     * Convert markdown syntax to HTML.
+     * Handles: bold, italic, code, links, and basic formatting.
+     * Called BEFORE escapeHTML to preserve markdown-generated HTML tags.
      */
-    private getAnimationStyles;
+    private renderMarkdown;
     /**
-     * Escape HTML entities.
+     * Clean up broken/truncated markdown that can't be properly rendered.
+     * Removes partial code blocks, inline tables, etc.
      */
-    private escapeHtml;
+    private cleanBrokenMarkdown;
     /**
-     * Basic HTML minification.
+     * Render markdown tables to HTML tables.
      */
-    private minifyHtml;
+    private renderMarkdownTables;
+    /**
+     * Build an HTML table from markdown table rows.
+     */
+    private buildHTMLTable;
 }
+declare function getRenderer(): Renderer;
+declare function initRenderer(): Promise<Renderer>;
 
 /**
- * PowerPoint Generator - PPTX Presentation Output
+ * 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
  *
- * Generates PowerPoint presentations using PptxGenJS with:
- * - Professional layouts
- * - Embedded charts
- * - Images
- * - Consistent styling
+ * Usage:
+ *   const provider = createNanoBananaProvider();
+ *   if (await provider.isAvailable()) {
+ *     const imageUrl = await provider.generateHeroImage('AI revolution');
+ *   }
  */
-
-type PptxSlide = ReturnType<PptxGenJS['addSlide']>;
-declare const COLORS: {
-    primary: string;
-    secondary: string;
-    accent: string;
-    highlight: string;
-    white: string;
-    lightGray: string;
-};
-declare class PowerPointGenerator {
-    private chartProvider;
-    /**
-     * Generate a PowerPoint presentation.
-     */
-    generate(slides: Slide[], config: PresentationConfig): Promise<Buffer>;
-    /**
-     * Add a slide to the presentation.
-     */
-    private addSlide;
-    /**
-     * Add title slide.
-     */
-    private addTitleSlide;
-    /**
-     * Add big idea / single statement slide.
-     */
-    private addBigIdeaSlide;
-    /**
-     * Add big number slide.
-     */
-    private addBigNumberSlide;
-    /**
-     * Add quote slide.
-     */
-    private addQuoteSlide;
-    /**
-     * Add bullet points slide.
-     */
-    private addBulletSlide;
-    /**
-     * Add two-column slide.
-     */
-    private addTwoColumnSlide;
-    /**
-     * Add metrics grid slide.
-     */
-    private addMetricsSlide;
+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);
     /**
-     * Add metrics to a slide at specified position.
+     * Check if NanoBanana is available (API key present).
      */
-    private addMetricsToSlide;
+    isAvailable(): Promise<boolean>;
     /**
-     * Add thank you slide.
+     * Generate a hero image for a slide.
      */
-    private addThankYouSlide;
+    generateHeroImage(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Add agenda slide.
+     * Generate a concept illustration.
      */
-    private addAgendaSlide;
+    generateConceptImage(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Add section divider slide.
+     * Generate an icon or symbol.
      */
-    private addSectionDividerSlide;
+    generateIcon(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Add default slide (fallback).
+     * Generate a background image.
      */
-    private addDefaultSlide;
+    generateBackground(concept: string, colorScheme?: 'dark' | 'light'): Promise<ImageGenerationResult>;
     /**
-     * Add image placeholder.
+     * Generate an image based on request parameters.
      */
-    private addImagePlaceholder;
+    generate(request: ImageGenerationRequest): Promise<ImageGenerationResult>;
     /**
-     * Convert layout position to PptxGenJS text props.
+     * Build an optimized prompt for image generation.
      */
-    private positionToProps;
+    private buildPrompt;
     /**
-     * Add Football Field Valuation Chart (IB Standard)
-     * Shows valuation ranges across different methodologies
+     * Call the Gemini API for image generation.
      */
-    addFootballFieldChart(pptxSlide: PptxSlide, data: {
-        title: string;
-        methodologies: Array<{
-            name: string;
-            low: number;
-            mid: number;
-            high: number;
-            color?: string;
-        }>;
-        currentPrice?: number;
-    }, bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    }, colors?: typeof COLORS): void;
-    /**
-     * Add Waterfall Chart (IB Standard)
-     * Shows incremental changes leading to a final value
-     */
-    addWaterfallChart(pptxSlide: PptxSlide, data: {
-        title: string;
-        startLabel: string;
-        startValue: number;
-        steps: Array<{
-            label: string;
-            value: number;
-            isTotal?: boolean;
-        }>;
-        endLabel?: string;
-    }, bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    }, colors?: typeof COLORS): void;
-    /**
-     * Add Sources & Uses Table (IB Standard)
-     * Common in M&A presentations
-     */
-    addSourcesUsesTable(pptxSlide: PptxSlide, data: {
-        title: string;
-        sources: Array<{
-            label: string;
-            amount: number;
-            percentage?: number;
-        }>;
-        uses: Array<{
-            label: string;
-            amount: number;
-            percentage?: number;
-        }>;
-    }, bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    }, colors?: typeof COLORS): void;
-    /**
-     * Add Comparable Companies Table (Comps - IB Standard)
-     */
-    addCompsTable(pptxSlide: PptxSlide, data: {
-        title: string;
-        columns: string[];
-        companies: Array<{
-            name: string;
-            values: (string | number)[];
-            highlight?: boolean;
-        }>;
-        medianRow?: boolean;
-    }, bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    }, colors?: typeof COLORS): void;
+    private callGeminiAPI;
 }
-
 /**
- * Image Provider - Pluggable Image Generation
- *
- * 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 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 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[]>;
-}
-/**
- * Local Image Provider - Uses user-provided images
- */
-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;
-}
-/**
- * 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;
-}
-/**
- * Unsplash Image Provider - Uses Unsplash API (free tier: 50 req/hour)
+ * Create a new NanoBanana provider instance.
  */
-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;
-}
-/**
- * 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 createNanoBananaProvider(config?: NanoBananaConfig): NanoBananaProvider;
 /**
- * Create default image provider chain
+ * Get a pre-built prompt for a specific image type.
+ * Useful for customization or debugging.
  */
-declare function createDefaultImageProvider(options?: {
-    localImages?: Record<string, string>;
-    unsplashKey?: string;
-}): ImageProvider;
+declare function getNanoBananaPrompt(style: 'hero' | 'concept' | 'icon' | 'background' | 'diagram', concept: string, presentationType?: string): string;
 
 /**
- * Chart Provider - Pluggable Chart Generation
+ * CodeQualityValidator - Detects Hardcoded Values in Source Code
  *
- * 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)
- */
-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 ChartProvider {
-    /** Provider name */
-    name: string;
-    /** Check if provider is available */
-    isAvailable(): Promise<boolean>;
-    /** Generate a chart */
-    generateChart(request: ChartRequest): Promise<ChartResult>;
-}
-/**
- * Chart.js Provider - Generates embedded Chart.js HTML
- * No API needed - runs in browser
- */
-declare class ChartJsProvider implements ChartProvider {
-    name: string;
-    isAvailable(): Promise<boolean>;
-    generateChart(request: ChartRequest): Promise<ChartResult>;
-}
-/**
- * QuickChart Provider - Uses quickchart.io for image generation
- * No API key needed - free service
- */
-declare class QuickChartProvider implements ChartProvider {
-    name: string;
-    private baseUrl;
-    isAvailable(): Promise<boolean>;
-    generateChart(request: ChartRequest): Promise<ChartResult>;
-}
-/**
- * Mermaid Provider - Generates diagrams using Mermaid.js
- * No API needed - renders in browser
- */
-declare class MermaidProvider implements ChartProvider {
-    name: string;
-    isAvailable(): Promise<boolean>;
-    generateChart(request: ChartRequest): Promise<ChartResult>;
-    /**
-     * Generate a Mermaid diagram
-     */
-    generateDiagram(definition: string, title?: string): Promise<ChartResult>;
-    /**
-     * Generate flowchart from steps
-     */
-    generateFlowchart(steps: {
-        id: string;
-        label: string;
-        next?: string[];
-    }[]): string;
-    /**
-     * Generate timeline from events
-     */
-    generateTimeline(events: {
-        date: string;
-        title: string;
-    }[]): string;
-}
-/**
- * Composite Chart Provider
- */
-declare class CompositeChartProvider implements ChartProvider {
-    name: string;
-    private htmlProvider;
-    private imageProvider;
-    private mermaidProvider;
-    constructor();
-    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;
-}
-/**
- * Create default chart provider
- */
-declare function createDefaultChartProvider(): CompositeChartProvider;
-
-/**
- * Knowledge Base - RuVector Expert Principles Loader
+ * This validator scans TypeScript/JavaScript source files for hardcoded CSS values,
+ * colors, and dimensions that should be coming from the Knowledge Base.
  *
- * Loads and provides access to the 6,300+ line expert knowledge base
- * containing methodologies from 40+ presentation experts.
+ * 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
  *
- * This runs WITHOUT any API - it's static data bundled with the package.
+ * This validator catches these careless errors at build/test time.
  */
-interface ExpertPrinciple {
-    name: string;
-    description: string;
-    validation?: string[];
-    examples?: string[];
-}
-interface ExpertMethodology {
-    name: string;
-    principles: ExpertPrinciple[];
-    slideTypes?: string[];
-    wordLimits?: {
-        min?: number;
-        max?: number;
-    };
+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 AutomatedQA {
-    scoringRubric: {
-        totalPoints: number;
-        passingThreshold: number;
-        categories: Record<string, {
-            weight: number;
-            checks: Record<string, unknown>;
-        }>;
+interface ValidationResult {
+    passed: boolean;
+    violations: HardcodedViolation[];
+    summary: {
+        totalFiles: number;
+        filesWithViolations: number;
+        totalViolations: number;
+        byType: Record<string, number>;
+        bySeverity: Record<string, number>;
     };
 }
-declare class KnowledgeBase {
-    private data;
-    private loaded;
-    /**
-     * Load the knowledge base from the bundled YAML file.
-     */
-    load(): Promise<void>;
+declare class CodeQualityValidator {
+    private srcDir;
+    private violations;
+    constructor(srcDir: string);
     /**
-     * Get expert methodology by name.
+     * Validate all TypeScript files in the source directory.
      */
-    getExpert(name: string): ExpertMethodology | undefined;
+    validate(): Promise<ValidationResult>;
     /**
-     * Get all expert names.
+     * Validate a single file for hardcoded values.
      */
-    getExpertNames(): string[];
+    private validateFile;
+    private checkForHexColors;
+    private checkForRgbaColors;
+    private checkForDimensions;
+    private checkForGradients;
+    private findTypeScriptFiles;
+    private shouldSkipFile;
+    private isExemptLine;
+    private buildResult;
     /**
-     * Get framework recommendation for audience.
+     * Format validation results for console output.
      */
-    getFrameworkForAudience(audience: string): {
-        primaryFramework: string;
-        secondaryFramework?: string;
-        slideTypes: string[];
-    } | undefined;
-    /**
-     * Get framework recommendation for goal.
-     */
-    getFrameworkForGoal(goal: string): {
-        primaryFramework: string;
-        secondaryFramework?: string;
-        slideTypes: string[];
-    } | undefined;
-    /**
-     * Get QA scoring rubric.
-     */
-    getScoringRubric(): AutomatedQA['scoringRubric'] | undefined;
-    /**
-     * Get mode configuration (keynote or business).
-     */
-    getModeConfig(mode: 'keynote' | 'business'): unknown;
-    /**
-     * Get slide type configuration.
-     */
-    getSlideType(type: string): unknown;
-    /**
-     * Get the knowledge base version.
-     */
-    getVersion(): string;
-    /**
-     * Validate a slide against expert principles.
-     */
-    validateAgainstExpert(expertName: string, slideData: {
-        wordCount: number;
-        hasActionTitle: boolean;
-        bulletCount: number;
-    }): {
-        passed: boolean;
-        violations: string[];
-    };
-    /**
-     * Ensure knowledge base is loaded.
-     */
-    private ensureLoaded;
-    /**
-     * Get default data if YAML can't be loaded.
-     */
-    private getDefaultData;
+    formatResults(result: ValidationResult): string;
 }
 /**
- * Get the knowledge base singleton.
+ * Run code quality validation on the source directory.
  */
-declare function getKnowledgeBase(): KnowledgeBase;
-
+declare function validateCodeQuality(srcDir: string): Promise<ValidationResult>;
 /**
- * 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
+ * Run validation and print results to console.
  */
+declare function runCodeQualityCheck(srcDir: string): Promise<boolean>;
 
 /**
- * Generate a presentation from content.
- *
- * @example
- * ```typescript
- * import { generate } from '@isovision/claude-presentation-master';
- *
- * const result = await generate({
- *   content: '# My Presentation\n\n...',
- *   contentType: 'markdown',
- *   mode: 'keynote',
- *   format: ['html', 'pptx'],
- *   qaThreshold: 95,
- *   title: 'My Amazing Presentation'
- * });
- *
- * 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 generate(config: PresentationConfig): Promise<PresentationResult>;
-/**
- * Validate an existing presentation.
- *
- * @example
- * ```typescript
- * import { validate } from '@isovision/claude-presentation-master';
- * import fs from 'fs';
+ * Claude Presentation Master - Main API
  *
- * const html = fs.readFileSync('presentation.html', 'utf-8');
- * const result = await validate(html, { mode: 'keynote' });
+ * Entry point for the qualitative-first presentation engine.
+ * Every slide must score 95/100 based on REAL qualitative excellence.
  *
- * console.log(`Score: ${result.score}/100`);
- * console.log(`Passed: ${result.passed}`);
- * ```
+ * 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
  *
- * @param presentation - HTML string or file buffer
- * @param options - Validation options
- * @returns QA validation results
- */
-declare function validate(presentation: string | Buffer, options?: {
-    mode?: 'keynote' | 'business';
-    threshold?: number;
-    strictMode?: boolean;
-}): Promise<QAResults & {
-    score: number;
-}>;
-/**
- * Get the version of the package.
+ * ALL decisions come from the Knowledge Base. NO hardcoded fallbacks.
  */
+
 declare const VERSION = "2.0.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) */
+    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;
+}
 /**
- * Default export for convenience.
+ * 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
  */
-declare const _default: {
-    generate: typeof generate;
-    validate: typeof validate;
-    PresentationEngine: typeof PresentationEngine;
-    QAEngine: typeof QAEngine;
-    PPTXValidator: typeof PPTXValidator;
-    AccessibilityValidator: typeof AccessibilityValidator;
-    VERSION: string;
-};
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
 
-export { type AccessibilityResults, AccessibilityValidator, AutoRemediation, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContentTransform, type ContrastIssue, type ExecutionStrategy, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, HTMLLayoutValidator, HallucinationDetector, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeBase, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PPTXValidator, PRESENTATION_TYPE_RULES, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationResult, type PresentationType, type PresentationTypeRules, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideBlueprint, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideVisualScore, type SparklineStructure, StrategyFactory, TemplateEngine, TemplateNotFoundError, type ThemeName, TypeDetector, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeBase, validate };
+export { CodeQualityValidator, type ValidationResult as CodeValidationResult, type ContentAnalysis, ContentAnalyzer, DeckQualityReviewer, type DeckScore, type GenerateOptions, type GenerateResult, type HardcodedViolation, type ImageGenerationRequest, type ImageGenerationResult, KnowledgeGateway, type NanoBananaConfig, NanoBananaProvider, type OutputFormat, type PresentationMetadata, type PresentationMode, type PresentationResult, type PresentationType, type QualitativeDeckReview, type QualitativeSlideReview, type RemediationResult, Remediator, Renderer, type Slide, SlideGenerator, SlideQualityReviewer, type SlideScore, VERSION, type Violation, VisualDesignSystem, createNanoBananaProvider, generate, getContentAnalyzer, getDeckQualityReviewer, getKB, getNanoBananaPrompt, getRemediator, getRenderer, getSlideGenerator, getSlideQualityReviewer, getVisualDesignSystem, initContentAnalyzer, initDeckQualityReviewer, initKB, initRemediator, initRenderer, initSlideGenerator, initSlideQualityReviewer, initVisualDesignSystem, runCodeQualityCheck, validateCodeQuality };