claude-presentation-master 3.0.1 → 3.6.0

package/dist/index.d.mts

@@ -1,449 +1,237 @@
-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;
-    /** Semantic completeness (optional - requires source content) */
-    semanticCompleteness?: SemanticCompletenessResult$1;
-    /** Vision QA results (optional - requires Claude API key) */
-    visionQA?: VisionQAResults;
-    /** 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 VisionQAResults {
-    /** Per-slide AI visual analysis */
-    slideAnalyses: VisionSlideAnalysis[];
-    /** Presentation-level assessment */
-    presentationLevel: {
-        visual_consistency: number;
-        story_arc: number;
-        memorable_moments: number;
-        professional_quality: 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;
+    /** 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;
     };
-    /** Overall score (1-10 scale) */
-    overallScore: number;
-    /** Slides that need improvement */
-    weakSlides: number[];
-    /** Slides that are excellent */
-    strongSlides: number[];
-    /** Critical issues detected */
-    criticalIssues: string[];
-    /** Pass/fail */
-    pass: boolean;
-    /** One-sentence verdict */
-    verdict: string;
-}
-interface VisionSlideAnalysis {
-    slideIndex: number;
-    scores: {
-        typography_hierarchy: number;
-        layout_balance: number;
-        color_harmony: number;
-        professional_polish: number;
-        message_clarity: number;
-        content_density: number;
-        visual_support: number;
-        narrative_flow: number;
+    whitespace: {
+        min: number;
+        ideal: number;
+        max?: number;
     };
-    overallScore: number;
-    criticalIssues: string[];
-    suggestions: string[];
-    pass: boolean;
-}
-interface VisualQAResults {
-    /** Whitespace percentage (target: 35%+ keynote, 25%+ business) */
-    whitespacePercentage: number;
-    /** Layout balance score (0-1) */
-    layoutBalance: number;
-    /** Contrast ratio (target: 4.5+) */
-    contrastRatio: number;
-    /** Number of font families used (target: ≤2) */
-    fontFamilies: number;
-    /** Number of colors used */
-    colorCount: number;
-    /** Screenshots of each slide */
-    screenshots: Buffer[];
-    /** Per-slide visual scores */
-    perSlide: SlideVisualScore[];
-}
-interface SlideVisualScore {
-    slideIndex: number;
-    whitespace: number;
-    balance: number;
-    contrast: number;
-    passed: boolean;
-    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[];
-}
-interface GlanceTestResult {
-    slideIndex: number;
-    keyMessage: string;
-    wordCount: number;
-    readingTime: number;
-    passed: boolean;
-    recommendation?: string;
-}
-interface SignalNoiseResult {
-    slideIndex: number;
-    signalCount: number;
-    noiseCount: number;
-    signalRatio: number;
-    passed: boolean;
-    noiseElements: string[];
-}
-interface OneIdeaResult {
-    slideIndex: number;
-    ideaCount: number;
-    mainIdea: string;
-    passed: boolean;
-    conflictingIdeas?: string[];
-}
-interface ExpertQAResults {
-    /** Nancy Duarte validation */
-    duarte: ExpertValidation;
-    /** Garr Reynolds validation */
-    reynolds: ExpertValidation;
-    /** Carmine Gallo validation */
-    gallo: ExpertValidation;
-    /** Chris Anderson validation */
-    anderson: ExpertValidation;
-}
-interface ExpertValidation {
-    expertName: string;
-    principlesChecked: string[];
-    passed: boolean;
-    score: number;
-    violations: string[];
-}
-interface AccessibilityResults {
-    /** WCAG compliance level achieved */
-    wcagLevel: 'A' | 'AA' | 'AAA' | 'FAIL';
-    /** Contrast issues found */
-    contrastIssues: ContrastIssue[];
-    /** Font size issues */
-    fontSizeIssues: FontSizeIssue[];
-    /** Focus state coverage */
-    focusCoverage: number;
-    /** Color-blind safety */
-    colorBlindSafe: boolean;
-}
-interface ContrastIssue {
-    slideIndex: number;
-    element: string;
-    foreground: string;
-    background: string;
-    ratio: number;
-    required: number;
+    bullets_per_slide: {
+        max: number;
+    };
+    action_titles_required: boolean;
+    sources_required: boolean;
+    callouts_required?: boolean;
+    dense_data_allowed?: boolean;
 }
-interface FontSizeIssue {
-    slideIndex: number;
-    element: string;
-    actualSize: number;
-    minimumSize: number;
+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 QAIssue {
-    /** Issue severity */
-    severity: 'error' | 'warning' | 'info';
-    /** Issue category */
-    category: 'visual' | 'content' | 'expert' | 'accessibility' | 'semantic_completeness';
-    /** Slide index (if applicable) */
-    slideIndex?: number;
-    /** Issue description */
-    message: string;
-    /** Suggested fix */
-    suggestion?: string;
+interface KBScoringRubric {
+    total_points: number;
+    passing_threshold: number;
+    categories: {
+        visual_quality: KBScoringCategory;
+        content_quality: KBScoringCategory;
+        expert_compliance: KBScoringCategory;
+        accessibility: KBScoringCategory;
+    };
 }
-interface SemanticCompletenessResult$1 {
-    /** Coverage score (0-100) - percentage of source concepts found in output */
-    coverageScore: number;
-    /** Key concepts extracted from source content */
-    sourceConcepts: ExtractedConcept$1[];
-    /** Concepts that were found in the generated slides */
-    foundConcepts: ExtractedConcept$1[];
-    /** Concepts that were NOT found - potential content loss */
-    missingConcepts: ExtractedConcept$1[];
-    /** Whether semantic completeness passed (score >= threshold) */
-    passed: boolean;
-    /** Detailed issues */
-    issues: QAIssue[];
+interface KBScoringCategory {
+    weight: number;
+    checks: Record<string, KBCheck>;
 }
-interface ExtractedConcept$1 {
-    /** The concept text (normalized) */
-    text: string;
-    /** Importance weight (1-10) based on context */
-    importance: number;
-    /** Category: heading, metric, key_term, entity, action */
-    category: 'heading' | 'metric' | 'key_term' | 'entity' | 'action';
-    /** Original text before normalization */
-    original: string;
-    /** Was it found in the output? */
-    found?: boolean;
-    /** Where it was found (slide indices) */
-    foundIn?: number[];
+interface KBCheck {
+    points: number;
+    description: string;
+    validation?: string;
 }
-interface PresentationResult {
-    /** Generated outputs */
-    outputs: {
-        html?: string;
-        pptx?: Buffer;
-    };
-    /** QA validation results */
-    qaResults: QAResults;
-    /** Overall QA score (0-100) */
-    score: number;
-    /** Presentation metadata */
-    metadata: PresentationMetadata;
+interface KBExpert {
+    name: string;
+    core_principles: Record<string, KBPrinciple>;
 }
-interface PresentationMetadata {
-    /** Presentation title */
-    title: string;
-    /** Author */
-    author: string;
-    /** Generation timestamp */
-    generatedAt: string;
-    /** Presentation mode */
-    mode: PresentationMode;
-    /** Total slide count */
-    slideCount: number;
-    /** Total word count */
-    wordCount: number;
-    /** Average words per slide */
-    avgWordsPerSlide: number;
-    /** Estimated presentation duration (minutes) */
-    estimatedDuration: number;
-    /** Themes/frameworks used */
-    frameworks: string[];
+interface KBPrinciple {
+    description: string;
+    rules?: string[];
+    examples?: string[];
 }
 interface ContentAnalysis {
-    /** SCQA structure extracted */
-    scqa: SCQAStructure;
-    /** Sparkline narrative arc */
-    sparkline: SparklineStructure;
-    /** Key messages identified */
+    /** Detected presentation type */
+    detectedType: PresentationType;
+    /** Extracted title */
+    title: string;
+    /** Sections found */
+    sections: ContentSection[];
+    /** Key messages */
     keyMessages: string[];
-    /** Generated action titles */
-    titles: string[];
-    /** STAR moments identified */
-    starMoments: string[];
-    /** Estimated slide count */
-    estimatedSlideCount: number;
-    /** Extracted data points (metrics, percentages, financial data) */
-    dataPoints: ExtractedDataPoint[];
-    /** Extracted bullet content by section */
-    sectionContent: ExtractedSection[];
-    /** Financial metrics summary */
-    financialSummary?: FinancialSummary | undefined;
-    /** Comparison data (e.g., Year 1 vs Year 2) */
-    comparisons?: ComparisonData[] | undefined;
-}
-/** Represents an extracted data point with context */
-interface ExtractedDataPoint {
-    value: string;
-    numericValue?: number;
-    type: 'currency' | 'percentage' | 'number' | 'ratio' | 'time';
-    context: string;
-    label?: string;
-    trend?: 'positive' | 'negative' | 'neutral';
-}
-/** Represents content from a section header */
-interface ExtractedSection {
+    /** 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: ExtractedDataPoint[];
-    /** Parsed table data if section contains a table */
-    tables?: ParsedTable[];
-}
-/** Represents a parsed markdown table */
-interface ParsedTable {
-    headers: string[];
-    rows: string[][];
-    caption?: string;
+    /** Metrics in this section */
+    metrics: DataPoint[];
 }
-/** Financial summary for investment-type presentations */
-interface FinancialSummary {
-    totalInvestment?: string;
-    npv?: string;
-    irr?: string;
-    paybackPeriod?: string;
-    roi?: string;
-    annualSavings?: string[];
-    revenueImpact?: string;
-}
-/** Comparison data for before/after or year-over-year analysis */
-interface ComparisonData {
-    label: string;
-    before?: string;
-    after?: string;
-    change?: string;
-    periods?: Array<{
-        period: string;
-        value: string;
-    }>;
+interface DataPoint {
+    value: string;
+    numericValue?: number;
+    type: 'currency' | 'percentage' | 'number' | 'time';
+    context: string;
+    label?: string;
 }
 interface SCQAStructure {
     situation: string;
@@ -454,3345 +242,1200 @@ interface SCQAStructure {
 interface SparklineStructure {
     whatIs: string[];
     whatCouldBe: string[];
+    starMoment?: 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);
-}
-
-/**
- * Score Calculator - QA Score Computation
- *
- * Calculates presentation quality scores based on:
- * - Visual quality (35%)
- * - Content quality (30%)
- * - Expert methodology compliance (25%)
- * - Accessibility (10%)
- */
-
-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;
+interface PresentationResult {
+    /** Generated outputs */
+    outputs: {
+        html?: string;
+        pptx?: Buffer;
+    };
+    /** Slides generated */
+    slides: Slide[];
+    /** Final deck score */
+    score: DeckScore;
+    /** Metadata */
+    metadata: PresentationMetadata;
 }
-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;
-    /**
-     * Get human-readable grade from score.
-     */
-    getGrade(score: number): string;
-    /**
-     * Get pass/fail status.
-     */
-    isPassing(score: number, threshold?: number): boolean;
-    /**
-     * Format score for display.
-     */
-    formatScore(score: number): string;
-    /**
-     * Generate summary report.
-     */
-    generateReport(results: QAResults): string;
+interface PresentationMetadata {
+    title: string;
+    author: string;
+    presentationType: PresentationType;
+    generatedAt: string;
+    slideCount: number;
+    totalWords: number;
+    avgWordsPerSlide: number;
+    kbVersion: string;
 }
 
 /**
- * QA Engine - Real Visual Quality Validation
+ * KnowledgeGateway - Single Point of Access to the Knowledge Base
  *
- * 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 (Duarte, Reynolds, Gallo, Anderson)
- * - Presentation effectiveness, completeness, and visual appeal
+ * 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.
  */
 
-declare class QAEngine {
-    private browser;
-    private typeDetector;
-    /**
-     * Validate a presentation.
-     */
-    validate(presentation: string | Buffer, options?: {
-        mode?: 'keynote' | 'business';
-        presentationType?: PresentationType;
-        strictMode?: boolean;
-        threshold?: number;
-    }): Promise<QAResults>;
-    /**
-     * Calculate overall QA score.
-     */
-    calculateScore(results: QAResults): number;
-    /**
-     * Create empty QA results (for when QA is skipped).
-     */
-    createEmptyResults(): QAResults;
-    private runVisualTests;
-    private runContentTests;
-    private runExpertTests;
-    /**
-     * Validate Nancy Duarte's principles from Slide:ology and Resonate
-     * - Glance Test: 3 seconds to understand main point
-     * - STAR Moments: Something They'll Always Remember
-     * - Sparkline: Contrast between What Is and What Could Be
-     */
-    private validateDuartePrinciples;
-    /**
-     * Validate Garr Reynolds' principles from Presentation Zen
-     * - Signal-to-Noise: Remove everything non-essential
-     * - Simplicity: Amplification through simplification
-     * - Picture Superiority: Visuals over text
-     */
-    private validateReynoldsPrinciples;
-    /**
-     * Validate Carmine Gallo's principles from Talk Like TED
-     * - Rule of Three: Max 3 key points
-     * - Emotional Connection: 65% stories/emotion
-     * - Jaw-Dropping Moment: One unforgettable element
-     */
-    private validateGalloPrinciples;
-    /**
-     * Validate Chris Anderson's principles from TED Talks official guide
-     * - One Idea: Single throughline per presentation
-     * - Clarity: No jargon, simple explanations
-     * - 3-5 Concepts: Limit complexity
-     */
-    private validateAndersonPrinciples;
-    /**
-     * Calculate variance in an array of numbers
-     */
-    private calculateVariance;
-    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
+ * Result wrapper that includes KB path for debugging
  */
-
-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 {
-    private typeDetector;
-    /**
-     * Validate a set of slides before PPTX generation.
-     * This validation is MANDATORY - export will fail if score < threshold.
-     */
-    validate(slides: Slide[], options: {
-        mode: 'keynote' | 'business';
-        presentationType?: PresentationType | undefined;
-        threshold?: number;
-        strictMode?: boolean;
-    }): Promise<PPTXValidationResult>;
-    /**
-     * Validate a single slide.
-     */
-    private validateSlide;
-    /**
-     * Validate cross-slide consistency.
-     */
-    private validateCrossSlide;
-    /**
-     * Validate against expert methodologies.
-     */
-    private validateExpertMethodologies;
-    /**
-     * Count words in slide content.
-     */
-    private countWords;
-    /**
-     * Check if slide has meaningful content.
-     */
-    private hasContent;
-    /**
-     * Count distinct ideas on a slide.
-     *
-     * A slide with ONE idea can still have:
-     * - A title (the main idea)
-     * - A keyMessage (reinforcing the same idea)
-     * - Multiple bullets (supporting evidence for the same idea)
-     * - Body text (elaborating on the same idea)
-     *
-     * Multiple ideas are detected when:
-     * - There's a quote AND substantial other content (quote should stand alone)
-     * - The slide has both body AND many bullets (competing content blocks)
-     * - Title introduces one concept but bullets introduce unrelated concepts
-     */
-    private countIdeas;
-    /**
-     * Calculate layout score for a slide.
-     */
-    private calculateLayoutScore;
-    /**
-     * Calculate overall validation score.
-     */
-    private calculateScore;
-    /**
-     * Build validation summary.
-     */
-    private buildSummary;
-    /**
-     * Convert PPTX validation result to standard QAResults format.
-     */
-    toQAResults(result: PPTXValidationResult, mode: 'keynote' | 'business', presentationType?: PresentationType): QAResults;
-    private createExpertValidation;
-    /**
-     * Generate human-readable validation report.
-     */
-    generateReport(result: PPTXValidationResult): string;
+interface KBResult<T> {
+    value: T;
+    kbPath: 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
+ * KnowledgeGateway - The ONLY way to access KB data
  */
-
-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;
-    private typeDetector;
-    /**
-     * Automatically remediate slides until they pass QA.
-     */
-    remediate(slides: Slide[], issues: QAIssue[] | PPTXIssue[], options: {
-        mode: 'keynote' | 'business';
-        presentationType?: PresentationType | undefined;
-        targetScore: number;
-    }): Promise<Slide[]>;
-    /**
-     * Get the changes that were applied during remediation.
-     */
-    getChanges(): RemediationChange[];
-    /**
-     * Remediate word count issues - both too many AND too few words.
-     */
-    private remediateWordCount;
-    /**
-     * Remediate glance test failures - title too long.
-     */
-    private remediateGlanceTest;
-    /**
-     * Remediate bullet point issues.
-     */
-    private remediateBullets;
-    /**
-     * Remediate multiple-ideas-per-slide violations.
-     * Strategy: Consolidate content to focus on one main idea.
-     */
-    private remediateMultipleIdeas;
-    /**
-     * Remediate structural issues - missing title slide, conclusion, etc.
-     */
-    private remediateStructure;
-    /**
-     * Remediate accessibility issues.
-     */
-    private remediateAccessibility;
-    /**
-     * Enhance a sparse slide by adding substantive content.
-     * Instead of generic filler, we expand existing content intelligently.
-     */
-    private enhanceSparseSlide;
-    /**
-     * Group issues by their primary type.
-     */
-    private groupIssuesByType;
-    /**
-     * Shorten text to approximately N words while preserving meaning.
-     * CRITICAL: Never truncate mid-sentence - always return complete, meaningful phrases.
-     */
-    private shortenText;
-    /**
-     * Shorten a title to N words, keeping the key message.
-     */
-    private shortenTitle;
-    /**
-     * Consolidate bullets by combining related ones.
-     */
-    private consolidateBullets;
-    /**
-     * Reindex slides after insertion/deletion.
-     */
-    private reindexSlides;
-    /**
-     * Count words in a slide.
-     */
-    private countWords;
-    /**
-     * Deep clone slides array.
-     */
-    private deepClone;
-    /**
-     * Generate remediation report.
-     */
-    generateReport(): string;
-}
-
-/**
- * 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.
- */
-
-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;
-    private commonWords;
-    /**
-     * 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;
-}
-
-/**
- * Presentation Engine - Main Orchestrator
- *
- * KNOWLEDGE-DRIVEN ARCHITECTURE
- *
- * This engine now routes ALL decisions through the KnowledgeOrchestrator.
- * The RuVector knowledge base IS the application brain.
- * This code is just plumbing that executes what the KB dictates.
- *
- * PHILOSOPHY: NEVER FAIL - ALWAYS DELIVER
- *
- * Instead of blocking on QA failures, this engine:
- * 1. Analyzes content using KB-driven narrative frameworks
- * 2. Builds slides using KB-driven expert methodologies
- * 3. Validates against 40+ expert principles from the KB
- * 4. Applies persuasion psychology from the KB
- * 5. Auto-remediates based on KB rules
- * 6. ALWAYS delivers a working, world-class presentation
- *
- * KB INTEGRATION:
- * - KnowledgeOrchestrator: Routes ALL decisions through KB
- * - NarrativeAnalyzer: Duarte Sparkline, STAR moments, SCQA
- * - ExpertValidator: Validates against ALL 40+ experts
- * - PersuasionEngine: Cialdini, Kahneman, Heath Brothers
- */
-
-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;
-    private orchestrator;
-    private narrativeAnalyzer;
-    private expertValidator;
-    private persuasionEngine;
-    private kbQueryCount;
-    constructor();
-    /**
-     * Generate a presentation from content.
-     *
-     * KNOWLEDGE-DRIVEN GENERATION:
-     * - ALL decisions route through KnowledgeOrchestrator
-     * - Narrative analysis via Duarte/Minto frameworks
-     * - Expert validation against 40+ methodologies
-     * - Persuasion psychology from Cialdini/Kahneman/Heath
-     *
-     * GUARANTEED DELIVERY:
-     * - Validates presentation quality against KB rules
-     * - Automatically fixes any issues found using KB guidance
-     * - Iterates until quality threshold is met
-     * - ALWAYS returns a working, world-class presentation
-     *
-     * @param config - Presentation configuration
-     * @returns Presentation result with outputs, QA results, and score
-     */
-    generate(config: PresentationConfig): Promise<PresentationResult>;
-    /**
-     * Validate slides and automatically remediate until they pass.
-     * Includes hallucination detection to ensure all facts are sourced.
-     */
-    private validateAndRemediate;
-    /**
-     * Validate presentation configuration.
-     */
-    private validateConfig;
-    /**
-     * Count words in a slide.
-     */
-    private countWords;
-    /**
-     * Build presentation metadata.
-     */
-    private buildMetadata;
-    /**
-     * Detect which expert frameworks were applied.
-     */
-    private detectFrameworks;
-    /**
-     * Get QA Engine for external access.
-     */
-    getQAEngine(): QAEngine;
-    /**
-     * Get PPTX Validator for external access.
-     */
-    getPPTXValidator(): PPTXValidator;
-    /**
-     * Get Score Calculator for external access.
-     */
-    getScoreCalculator(): ScoreCalculator;
-    /**
-     * Get Auto Remediation for external access.
-     */
-    getAutoRemediation(): AutoRemediation;
-    /**
-     * Get Hallucination Detector for external access.
-     */
-    getHallucinationDetector(): HallucinationDetector;
-}
-
-/**
- * Content Analyzer - Extracts Structure AND Data from Raw Content
- *
- * Uses expert methodologies to analyze content and extract:
- * - SCQA structure (Barbara Minto)
- * - Sparkline narrative arc (Nancy Duarte)
- * - Key messages (Rule of Three)
- * - STAR moments
- * - Action titles
- * - **NEW**: Actual data points, metrics, financial figures
- * - **NEW**: Section content with bullets
- * - **NEW**: Comparison data
- */
-
-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 AND data.
-     */
-    analyze(content: string, contentType: string): Promise<ContentAnalysis>;
-    /**
-     * Parse content and extract structured sections.
-     */
-    private parseContentStructured;
-    /**
-     * Parse markdown and extract structured sections with content.
-     */
-    private parseMarkdownStructured;
-    /**
-     * Extract markdown tables from content lines.
-     * Per RuVector knowledge base (Cole Nussbaumer Knaflic):
-     * Tables are for leave-behinds, keep minimal design.
-     */
-    private extractTablesFromLines;
-    /**
-     * Remove table markdown lines from content to prevent raw text display.
-     * Lines that are part of tables (start and end with |, or are separator lines).
-     */
-    private removeTableLinesFromContent;
-    /**
-     * Extract bullet points from content lines.
-     */
-    private extractBulletsFromLines;
-    /**
-     * Extract ALL data points from content.
-     */
-    private extractAllDataPoints;
-    /**
-     * Extract data points from a specific text block.
-     */
-    private extractDataPointsFromText;
-    /**
-     * Get context around a match.
-     */
-    private getContext;
-    /**
-     * Parse numeric value from string.
-     */
-    private parseNumericValue;
-    /**
-     * Detect trend from context.
-     */
-    private detectTrend;
-    /**
-     * Extract a label for the data point from context.
-     */
-    private extractLabel;
-    /**
-     * Extract financial summary from content.
-     */
-    private extractFinancialSummary;
-    /**
-     * Extract comparison data (year-over-year, before/after).
-     */
-    private extractComparisons;
-    /**
-     * Extract SCQA structure from sections and content.
-     */
-    private extractSCQA;
-    /**
-     * Extract first meaningful sentence from text.
-     */
-    private extractFirstMeaningfulSentence;
-    /**
-     * Extract Sparkline structure.
-     */
-    private extractSparkline;
-    /**
-     * Extract key messages from actual content.
-     */
-    private extractKeyMessages;
-    /**
-     * Generate action titles from key insights.
-     */
-    private generateActionTitles;
-    /**
-     * Transform a statement into an action title.
-     */
-    private transformToActionTitle;
-    /**
-     * Identify STAR moments (dramatic/memorable points).
-     */
-    private identifyStarMoments;
-    /**
-     * Estimate slide count based on content.
-     */
-    private estimateSlideCount;
-    private parseJSON;
-    private parseYAML;
-    private flattenObject;
-    private splitIntoParagraphs;
-    private splitIntoSentences;
-    private containsSignals;
-    private truncateToSentence;
-    private truncateToWords;
-    private capitalizeFirst;
-    private cleanText;
-    private isActionTitle;
-}
-
-/**
- * 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();
-    /**
-     * Create slides from analyzed content.
-     * If presentationType is provided, uses the specialized strategy.
-     * Otherwise, falls back to mode-based generation.
-     */
-    createSlides(analysis: ContentAnalysis, mode: PresentationMode, presentationType?: PresentationType): Promise<Slide[]>;
-    /**
-     * Create a title slide.
-     */
-    private createTitleSlide;
-    /**
-     * Create an agenda slide.
-     */
-    private createAgendaSlide;
-    /**
-     * Create a context/situation slide.
-     */
-    private createContextSlide;
-    /**
-     * Create a problem/complication slide.
-     */
-    private createProblemSlide;
-    /**
-     * Create a key message slide.
-     */
-    private createMessageSlide;
-    /**
-     * Create a STAR moment slide.
-     */
-    private createStarMomentSlide;
-    /**
-     * Create a solution/answer slide.
-     */
-    private createSolutionSlide;
-    /**
-     * Create a call-to-action slide.
-     */
-    private createCTASlide;
-    /**
-     * Create a thank you slide.
-     */
-    private createThankYouSlide;
-    /**
-     * Initialize slide templates with constraints.
-     */
-    private initializeTemplates;
-    /**
-     * Truncate text to max length at word boundary.
-     */
-    private truncate;
-    /**
-     * Extract an action title from a message.
-     */
-    private extractActionTitle;
-    /**
-     * Extract bullet points from text.
-     */
-    private extractBullets;
-    /**
-     * Remove a statistic from text.
-     */
-    private removeStatistic;
-}
-
-/**
- * Template Engine - Handlebars Template Rendering
- *
- * Renders slide data into HTML using Handlebars templates.
- * Supports custom templates and helper functions.
- */
-
-interface TemplateConfig {
-    customTemplates?: Record<string, string>;
-    theme?: ThemeName;
-}
-declare class TemplateEngine {
-    private handlebars;
-    private templates;
-    private partials;
-    constructor();
-    /**
-     * Render a slide to HTML.
-     */
-    render(slide: Slide, config?: TemplateConfig): string;
-    /**
-     * Render multiple slides.
-     */
-    renderAll(slides: Slide[], config?: TemplateConfig): string[];
-    /**
-     * Prepare template context with computed properties.
-     */
-    private prepareContext;
-    /**
-     * Build CSS class list for slide.
-     */
-    private buildClassList;
-    /**
-     * Build inline style string.
-     */
-    private buildStyleString;
-    /**
-     * Register Handlebars helpers.
-     */
-    private registerHelpers;
-    /**
-     * Register reusable partials.
-     */
-    private registerPartials;
-    /**
-     * Compile built-in templates.
-     */
-    private compileTemplates;
-    /**
-     * Render fallback for unknown slide types.
-     */
-    private renderFallback;
-    /**
-     * Convert camelCase to kebab-case.
-     */
-    private kebabCase;
-}
-
-/**
- * Accessibility Validator - WCAG Compliance Testing
- *
- * 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
- *
- * MANDATORY: All presentations must meet WCAG AA minimum.
- */
-
-interface A11yValidationResult {
-    passed: boolean;
-    wcagLevel: 'A' | 'AA' | 'AAA' | 'FAIL';
-    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;
-    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;
-    /**
-     * Check keyboard navigation accessibility.
-     */
-    private checkKeyboardNavigation;
-    /**
-     * Check document structure accessibility.
-     */
-    private checkStructure;
-    /**
-     * Check color-blind safety.
-     */
-    private checkColorBlindSafety;
-    /**
-     * Calculate contrast ratio between two colors.
-     */
-    private calculateContrastRatio;
-    /**
-     * Calculate relative luminance of a color.
-     */
-    private getRelativeLuminance;
-    /**
-     * Determine WCAG compliance level.
-     */
-    private determineWCAGLevel;
-    /**
-     * Calculate accessibility score.
-     */
-    private calculateScore;
-    /**
-     * Generate accessibility report.
-     */
-    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;
-    /**
-     * Validate HTML presentation layout using real browser rendering.
-     * This is the MANDATORY check before any HTML export.
-     */
-    validate(html: string): Promise<LayoutValidationResult>;
-    /**
-     * Validate a single slide's layout using Playwright.
-     */
-    private validateSlide;
-    /**
-     * Static HTML analysis fallback when Playwright isn't available.
-     * Analyzes CSS and HTML structure without rendering.
-     */
-    private validateStaticHTML;
-    /**
-     * Generate remediation suggestions for layout issues.
-     */
-    generateRemediationPlan(result: LayoutValidationResult): string[];
-}
-
-/**
- * Semantic Completeness Validator
- *
- * Ensures generated presentations retain the key concepts and topics
- * from the original source content. This prevents loss of critical
- * information during summarization/remediation.
- *
- * Key capabilities:
- * - Extract key topics/concepts from source content
- * - Compare source concepts against generated slides
- * - Flag missing topics that should be covered
- * - Provide coverage score (0-100)
- */
-
-interface SemanticCompletenessResult {
-    /** Coverage score (0-100) - percentage of source concepts found in output */
-    coverageScore: number;
-    /** Key concepts extracted from source content */
-    sourceConcepts: ExtractedConcept[];
-    /** Concepts that were found in the generated slides */
-    foundConcepts: ExtractedConcept[];
-    /** Concepts that were NOT found - potential content loss */
-    missingConcepts: ExtractedConcept[];
-    /** Whether semantic completeness passed (score >= threshold) */
-    passed: boolean;
-    /** Detailed issues */
-    issues: SemanticIssue[];
-}
-interface ExtractedConcept {
-    /** The concept text (normalized) */
-    text: string;
-    /** Importance weight (1-10) based on context */
-    importance: number;
-    /** Category: heading, metric, key_term, entity, action */
-    category: 'heading' | 'metric' | 'key_term' | 'entity' | 'action';
-    /** Original text before normalization */
-    original: string;
-    /** Was it found in the output? */
-    found?: boolean;
-    /** Where it was found (slide indices) */
-    foundIn?: number[];
-}
-interface SemanticIssue {
-    severity: 'error' | 'warning' | 'info';
-    category: 'semantic_completeness';
-    message: string;
-    missingConcept?: string;
-    importance?: number;
-    suggestion?: string;
-}
-declare class SemanticCompletenessValidator {
-    /** Minimum coverage score to pass (default: 70%) */
-    private threshold;
-    constructor(threshold?: number);
-    /**
-     * Validate that generated slides contain the key concepts from source content.
-     */
-    validate(sourceContent: string, generatedSlides: Slide[]): SemanticCompletenessResult;
-    /**
-     * Extract key concepts from source content using NLP-like heuristics.
-     */
-    private extractConcepts;
-    /**
-     * Extract all text content from generated slides.
-     */
-    private extractSlideText;
-    /**
-     * Find a concept in the generated slides using fuzzy matching.
-     */
-    private findConceptInSlides;
-    /**
-     * Generate search variations for fuzzy matching.
-     */
-    private generateSearchVariations;
-    /**
-     * Normalize text for comparison.
-     */
-    private normalize;
-    /**
-     * Generate issues for missing concepts.
-     */
-    private generateIssues;
-    /**
-     * Get a human-readable summary of the validation.
-     */
-    getSummary(result: SemanticCompletenessResult): string;
-}
-
-/**
- * VisionQAEngine - AI-Driven Qualitative Visual Assessment
- *
- * Unlike rules-based QA (word counts, whitespace %), this engine uses
- * Claude's multimodal capabilities to perform actual design quality assessment.
- *
- * Purpose: Stop giving 99/100 to presentations that look terrible.
- *
- * Features:
- * - Per-slide visual analysis using Claude Vision
- * - Presentation-level consistency and narrative assessment
- * - Critical issue detection (raw markdown, broken images, empty slides)
- * - Type-specific standards (TED vs consulting vs investment banking)
- *
- * @module VisionQAEngine
- */
-
-interface SlideVisionAnalysis {
-    slideIndex: number;
-    scores: {
-        typography_hierarchy: number;
-        layout_balance: number;
-        color_harmony: number;
-        professional_polish: number;
-        message_clarity: number;
-        content_density: number;
-        visual_support: number;
-        narrative_flow: number;
-    };
-    overallScore: number;
-    criticalIssues: string[];
-    suggestions: string[];
-    pass: boolean;
-    rawResponse?: string | undefined;
-}
-interface PresentationVisionAnalysis {
-    slideAnalyses: SlideVisionAnalysis[];
-    presentationLevel: {
-        visual_consistency: number;
-        story_arc: number;
-        memorable_moments: number;
-        professional_quality: number;
-    };
-    overallScore: number;
-    weakSlides: number[];
-    strongSlides: number[];
-    criticalIssues: string[];
-    pass: boolean;
-    verdict: string;
-}
-interface VisionQAConfig {
-    /** Enable verbose logging */
-    verbose?: boolean;
-    /** Anthropic API key (defaults to ANTHROPIC_API_KEY env var) */
-    apiKey?: string;
-    /** Model to use for vision analysis */
-    model?: string;
-    /** Skip individual slide analysis (faster, overview only) */
-    overviewOnly?: boolean;
-    /** Maximum slides to analyze (for large decks) */
-    maxSlides?: number;
-    /** Minimum score required to pass (0-10 scale) */
-    passThreshold?: number;
-}
-declare class VisionQAEngine {
-    private client;
-    private kb;
-    private config;
-    constructor(config?: VisionQAConfig);
-    /**
-     * Initialize the engine (lazy - only when needed)
-     */
-    private initialize;
-    /**
-     * Analyze a single slide screenshot using Claude Vision
-     */
-    analyzeSlide(screenshot: Buffer, slideIndex: number, totalSlides: number, presentationType: PresentationType, slideType?: string): Promise<SlideVisionAnalysis>;
-    /**
-     * Analyze the full presentation using Claude Vision
-     */
-    analyzePresentationOverview(screenshots: Buffer[], presentationType: PresentationType, title: string): Promise<{
-        visual_consistency: number;
-        story_arc: number;
-        memorable_moments: number;
-        professional_quality: number;
-        overall_score: number;
-        weak_slides: number[];
-        strong_slides: number[];
-        critical_issues: string[];
-        pass: boolean;
-        verdict: string;
-    }>;
-    /**
-     * Run full vision QA analysis on a presentation
-     */
-    analyze(screenshots: Buffer[], presentationType: PresentationType, title: string, slideTypes?: string[]): Promise<PresentationVisionAnalysis>;
-    /**
-     * Convert vision analysis results to QA issues format
-     */
-    toQAIssues(analysis: PresentationVisionAnalysis): QAIssue[];
-    /**
-     * Calculate a QA score (0-100) from vision analysis
-     */
-    toQAScore(analysis: PresentationVisionAnalysis): number;
-}
-/**
- * Get or create the VisionQAEngine singleton
- */
-declare function getVisionQAEngine(config?: VisionQAConfig): VisionQAEngine;
-/**
- * Create a new VisionQAEngine instance (non-singleton)
- */
-declare function createVisionQAEngine(config?: VisionQAConfig): VisionQAEngine;
-
-/**
- * ConsensusValidator - Multi-Agent Consensus Validation
- *
- * Combines multiple validation perspectives to provide rigorous QA:
- * - Rules-based validation (QAEngine)
- * - AI vision-based assessment (VisionQAEngine)
- * - Expert methodology validators (Duarte, Reynolds, Minto, etc.)
- * - Presentation type-specific validators
- *
- * The consensus approach ensures:
- * 1. No single validator can inflate scores artificially
- * 2. Critical issues are caught across multiple perspectives
- * 3. Type-specific standards are enforced
- *
- * @module ConsensusValidator
- */
-
-/** Expert agent persona for validation */
-type ExpertAgent = 'duarte' | 'reynolds' | 'minto' | 'tufte' | 'gallo' | 'anderson';
-/** Individual agent's assessment */
-interface AgentAssessment {
-    agent: ExpertAgent;
-    score: number;
-    passed: boolean;
-    criticalIssues: string[];
-    suggestions: string[];
-    verdict: string;
-}
-/** Consensus result from all agents */
-interface ConsensusResult {
-    /** Individual agent assessments */
-    agentAssessments: AgentAssessment[];
-    /** Rules-based QA score (from QAEngine) */
-    rulesScore: number;
-    /** Vision AI assessment score (from VisionQAEngine) */
-    visionScore: number;
-    /** Vision analysis details (if available) */
-    visionAnalysis?: PresentationVisionAnalysis;
-    /** Final consensus score (weighted average) */
-    consensusScore: number;
-    /** All critical issues across validators */
-    criticalIssues: string[];
-    /** Aggregated suggestions */
-    suggestions: string[];
-    /** Pass/fail based on consensus */
-    passed: boolean;
-    /** Human-readable verdict */
-    verdict: string;
-    /** Confidence level (how much agreement between validators) */
-    confidence: 'high' | 'medium' | 'low';
-    /** Detailed breakdown by category */
-    breakdown: {
-        visual: number;
-        content: number;
-        structure: number;
-        methodology: number;
-    };
-}
-/** Configuration for consensus validation */
-interface ConsensusConfig {
-    /** Enable verbose logging */
-    verbose?: boolean;
-    /** Anthropic API key (for vision analysis) */
-    apiKey?: string;
-    /** Enable vision-based AI assessment */
-    enableVision?: boolean;
-    /** Agents to include (default: all) */
-    agents?: ExpertAgent[];
-    /** Minimum agreement threshold (0-1, default: 0.6) */
-    agreementThreshold?: number;
-    /** Weights for final score calculation */
-    weights?: {
-        rules?: number;
-        vision?: number;
-        agents?: number;
-    };
-    /** Presentation type for specialized validation */
-    presentationType?: PresentationType;
-}
-declare class ConsensusValidator {
-    private client;
-    private visionEngine;
-    private kb;
-    private config;
-    constructor(config?: ConsensusConfig);
-    /**
-     * Initialize the validator (lazy - only when needed)
-     */
-    private initialize;
-    /**
-     * Run full consensus validation
-     */
-    validate(html: string, screenshots: Buffer[], rulesQAResults: QAResults, presentationType: PresentationType, title: string): Promise<ConsensusResult>;
-    /**
-     * Run all expert agents in parallel
-     */
-    private runExpertAgents;
-    /**
-     * Filter agents relevant to presentation type
-     */
-    private filterAgentsForType;
-    /**
-     * Run a single expert agent assessment
-     */
-    private runSingleAgent;
-    /**
-     * Build context for agent assessment
-     */
-    private buildAgentContext;
-    /**
-     * Sample screenshots evenly
-     */
-    private sampleScreenshots;
-    /**
-     * Calculate rules-based score
-     */
-    private calculateRulesScore;
-    private calculateVisualSubscore;
-    private calculateContentSubscore;
-    /**
-     * Calculate final consensus from all validators
-     */
-    private calculateConsensus;
-    /**
-     * Generate human-readable verdict
-     */
-    private generateVerdict;
-    /**
-     * Calculate standard deviation
-     */
-    private calculateStdDev;
-    /**
-     * Convert consensus result to QA issues format
-     */
-    toQAIssues(result: ConsensusResult): QAIssue[];
-}
-/**
- * Get or create the ConsensusValidator singleton
- */
-declare function getConsensusValidator(config?: ConsensusConfig): ConsensusValidator;
-/**
- * Create a new ConsensusValidator instance (non-singleton)
- */
-declare function createConsensusValidator(config?: ConsensusConfig): ConsensusValidator;
-
-/**
- * Presentation Type Detector
- *
- * 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
- *
- * Each presentation type has distinct validation rules that do not conflict.
- */
-
-/**
- * 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;
-    /**
-     * Get all available presentation types.
-     */
-    getAvailableTypes(): PresentationType[];
-    /**
-     * Map legacy mode to a presentation type.
-     */
-    modeToType(mode: 'keynote' | 'business'): PresentationType;
-    /**
-     * Map presentation type back to legacy mode for compatibility.
-     */
-    typeToMode(type: PresentationType): 'keynote' | 'business';
-    /**
-     * Get word limits for a presentation type.
-     */
-    getWordLimits(type: PresentationType): {
-        min: number;
-        max: number;
-        ideal: number;
-    };
-    /**
-     * Check if action titles are required for a type.
-     */
-    requiresActionTitles(type: PresentationType): boolean;
-    /**
-     * Check if sources are required for a type.
-     */
-    requiresSources(type: PresentationType): boolean;
-    /**
-     * Get scoring weights for a presentation type.
-     */
-    getScoringWeights(type: PresentationType): {
-        visual_quality: number;
-        content_quality: number;
-        expert_compliance: number;
-        accessibility: number;
-    };
-}
-
-/**
- * Execution Strategy Types
- *
- * 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
- *
- * Selects the appropriate execution strategy based on presentation type.
- * Each strategy encapsulates world-class expertise for its domain.
- */
-
-/**
- * Factory for creating presentation execution strategies.
- */
-declare class StrategyFactory {
-    private strategies;
-    constructor();
-    /**
-     * Get the execution strategy for a presentation type.
-     */
-    getStrategy(type: PresentationType): ExecutionStrategy;
-    /**
-     * Get all available strategies.
-     */
-    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[];
-}
-
-/**
- * Reveal.js Generator - HTML Presentation Output
- *
- * Generates complete Reveal.js presentations with:
- * - Responsive layouts
- * - Animations
- * - Speaker notes
- * - Custom themes
- * - Chart.js integration
- * - Mermaid diagrams
- */
-
-declare class RevealJsGenerator {
-    private templateEngine;
-    private defaultRevealConfig;
-    constructor();
-    /**
-     * Generate complete Reveal.js HTML presentation.
-     */
-    generate(slides: Slide[], config: PresentationConfig): Promise<string>;
-    /**
-     * Build the complete HTML document.
-     */
-    private buildDocument;
-    /**
-     * 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
-     */
-    private getBaseStyles;
-    /**
-     * Get theme-specific styles.
-     */
-    private getThemeStyles;
-    /**
-     * Get animation styles.
-     */
-    private getAnimationStyles;
-    /**
-     * Escape HTML entities.
-     */
-    private escapeHtml;
-    /**
-     * Basic HTML minification.
-     */
-    private minifyHtml;
-    /**
-     * Get theme variables based on presentation type.
-     * Returns color scheme and typography for each type.
-     */
-    private getTypeThemeVars;
-}
-
-/**
- * PowerPoint Generator - PPTX Presentation Output
- *
- * Generates PowerPoint presentations using PptxGenJS with:
- * - Professional layouts
- * - Embedded charts
- * - Images
- * - Consistent styling
- */
-
-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 with professional gradient background.
-     */
-    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 with professional styling.
-     */
-    private addBulletSlide;
-    /**
-     * Add two-column slide with professional layout.
-     */
-    private addTwoColumnSlide;
-    /**
-     * Add professional metrics card to slide.
-     */
-    private addMetricsCard;
-    /**
-     * Add metrics grid slide.
-     */
-    private addMetricsSlide;
-    /**
-     * Add metrics to a slide at specified position.
-     */
-    private addMetricsToSlide;
-    /**
-     * Add thank you slide.
-     */
-    private addThankYouSlide;
-    /**
-     * Add agenda slide.
-     */
-    private addAgendaSlide;
-    /**
-     * Add section divider slide.
-     */
-    private addSectionDividerSlide;
-    /**
-     * Add default slide (fallback).
-     */
-    private addDefaultSlide;
-    /**
-     * Add image placeholder.
-     */
-    private addImagePlaceholder;
-    /**
-     * Convert layout position to PptxGenJS text props.
-     */
-    private positionToProps;
-    /**
-     * Add Football Field Valuation Chart (IB Standard)
-     * Shows valuation ranges across different methodologies
-     */
-    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;
-}
-
-/**
- * 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)
- */
-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[]>;
-}
-/**
- * Create default image provider chain
- *
- * Priority order:
- * 1. Local images (user-provided)
- * 2. NanoBanana Pro (AI generation, if GOOGLE_AI_API_KEY available)
- * 3. Unsplash (if key available)
- * 4. Placeholder (always available)
- */
-declare function createDefaultImageProvider(options?: {
-    localImages?: Record<string, string>;
-    unsplashKey?: string;
-    googleAiKey?: string;
-    enableAiGeneration?: boolean;
-}): ImageProvider;
-
-/**
- * Chart Provider - Pluggable Chart Generation
- *
- * 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;
-
-/**
- * NanoBanana Pro Image Provider
- *
- * AI-powered image generation using Google's Gemini Image models:
- * - Gemini 2.5 Flash Image ("Nano Banana") - Fast, 1K resolution
- * - Gemini 3 Pro Image Preview ("Nano Banana Pro") - Professional, up to 4K resolution
- *
- * Perfect for generating:
- * - Hero images for title slides
- * - Abstract concept visualizations
- * - Background imagery
- * - Product/feature illustrations
- *
- * @see https://ai.google.dev/gemini-api/docs/image-generation
- */
-
-/** Model options for NanoBanana image generation */
-type NanoBananaModel = 'gemini-2.5-flash-image' | 'gemini-3-pro-image';
-/** Image size options (Pro only supports 2K and 4K) */
-type ImageSize = '1K' | '2K' | '4K';
-/** Aspect ratio options */
-type AspectRatio = '1:1' | '16:9' | '9:16' | '4:3' | '3:4' | '21:9';
-/** Configuration for NanoBanana provider */
-interface NanoBananaConfig {
-    /** Google AI API key (or set GOOGLE_AI_API_KEY env var) */
-    apiKey?: string;
-    /** Model to use (default: gemini-2.5-flash-image) */
-    model?: NanoBananaModel;
-    /** Default aspect ratio (default: 16:9 for presentations) */
-    aspectRatio?: AspectRatio;
-    /** Image size for Pro model (default: 2K) */
-    imageSize?: ImageSize;
-    /** Style modifiers to append to prompts */
-    styleModifiers?: string[];
-    /** Whether to include text in generated images */
-    allowText?: boolean;
-}
-/**
- * NanoBanana Pro Image Provider
- *
- * Generates AI images using Google's Gemini Image models.
- * Requires GOOGLE_AI_API_KEY environment variable or apiKey in config.
- */
-declare class NanoBananaProvider implements ImageProvider {
-    name: string;
-    private apiKey;
-    private model;
-    private aspectRatio;
-    private imageSize;
-    private styleModifiers;
-    private allowText;
-    private baseUrl;
-    constructor(config?: NanoBananaConfig);
-    isAvailable(): Promise<boolean>;
-    getImage(request: ImageRequest): Promise<ImageResult>;
-    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
-    /**
-     * Build an optimized prompt for presentation imagery
-     */
-    private buildPrompt;
-    /**
-     * Call the Gemini API for image generation
-     */
-    private callGeminiAPI;
-    /**
-     * Extract image result from Gemini response
-     */
-    private extractImageResult;
-    /**
-     * Get a fallback placeholder image
-     */
-    private getFallbackImage;
-    /**
-     * Generate a consistent hash from a string
-     */
-    private hashString;
-    /**
-     * Delay helper for rate limiting
-     */
-    private delay;
-}
-/**
- * Create a NanoBanana provider with presentation-optimized defaults
- */
-declare function createNanoBananaProvider(config?: NanoBananaConfig): NanoBananaProvider;
-/**
- * Create prompt templates from the knowledge base
- */
-declare const NANOBANANA_PROMPT_TEMPLATES: {
-    /** Hero image for title/section slides */
-    readonly hero: (topic: string) => string;
-    /** Abstract concept visualization */
-    readonly concept: (concept: string) => string;
-    /** Feature/product illustration */
-    readonly feature: (feature: string) => string;
-    /** Background imagery */
-    readonly background: (theme: string) => string;
-    /** Data/metrics visualization enhancement */
-    readonly data: (metric: string) => string;
-    /** Team/people representation (abstract) */
-    readonly team: (context: string) => string;
-    /** Process/workflow visualization */
-    readonly process: (process: string) => string;
-};
-type PromptTemplate = keyof typeof NANOBANANA_PROMPT_TEMPLATES;
-/**
- * Get a pre-built prompt from templates
- */
-declare function getNanoBananaPrompt(template: PromptTemplate, value: string): string;
-
-/**
- * Knowledge Base - RuVector Expert Principles Loader
- *
- * Loads and provides access to the 6,300+ line expert knowledge base
- * containing methodologies from 40+ presentation experts.
- *
- * This runs WITHOUT any API - it's static data bundled with the package.
- */
-interface ExpertPrinciple {
-    name: string;
-    description: string;
-    validation?: string[];
-    examples?: string[];
-}
-interface ExpertMethodology {
-    name: string;
-    principles: ExpertPrinciple[];
-    slideTypes?: string[];
-    wordLimits?: {
-        min?: number;
-        max?: number;
-    };
-}
-interface AutomatedQA {
-    scoringRubric: {
-        totalPoints: number;
-        passingThreshold: number;
-        categories: Record<string, {
-            weight: number;
-            checks: Record<string, unknown>;
-        }>;
-    };
-}
-declare class KnowledgeBase {
+declare class KnowledgeGateway {
     private data;
-    private loaded;
-    /**
-     * Load the knowledge base from the bundled YAML file.
-     */
-    load(): Promise<void>;
-    /**
-     * Get expert methodology by name.
-     */
-    getExpert(name: string): ExpertMethodology | undefined;
-    /**
-     * Get all expert names.
-     */
-    getExpertNames(): string[];
-    /**
-     * Get framework recommendation for audience.
-     */
-    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;
-}
-/**
- * Get the knowledge base singleton.
- */
-declare function getKnowledgeBase(): KnowledgeBase;
-
-/**
- * KnowledgeOrchestrator - The Central Brain (Optimized v2.0)
- *
- * THIS IS THE HEART OF THE APPLICATION.
- *
- * Every single decision in the presentation engine flows through this orchestrator.
- * It queries the RuVector knowledge base via KnowledgeService typed methods.
- *
- * DESIGN PRINCIPLE: The RuVector KB IS the application.
- * This orchestrator simply executes what the KB dictates.
- *
- * KEY OPTIMIZATION (v2.0):
- * - Uses KnowledgeService typed methods instead of raw property access
- * - Memory-resident KB (loaded once, cached forever)
- * - Optional logging (no console spam by default)
- * - 95/100 KB utilization target
- *
- * The knowledge base contains 7,000+ lines of world-class expertise from:
- * - Nancy Duarte (Sparkline, STAR moments)
- * - Barbara Minto (Pyramid Principle, MECE, Action Titles)
- * - Edward Tufte (Data-Ink Ratio, Chartjunk elimination)
- * - Cole Nussbaumer Knaflic (Storytelling with Data)
- * - Garr Reynolds (Presentation Zen)
- * - Carmine Gallo (Talk Like TED)
- * - Robert Cialdini (Persuasion Psychology)
- * - Daniel Kahneman (Behavioral Economics)
- * - Chip & Dan Heath (Made to Stick)
- * - McKinsey, BCG, Bain (Consulting methodology)
- * - Cognitive Science (Miller's Law, Chunking, Cognitive Load)
- * - Gestalt Principles (Proximity, Similarity, Closure, Continuity)
- * - WCAG Accessibility Standards
- * - And 30+ more expert methodologies
- */
-
-interface KBQueryLog {
-    timestamp: Date;
-    path: string;
-    query: string;
-    result: any;
-    appliedAs: string;
-}
-interface OrchestratorDecision<T> {
-    value: T;
-    kbPath: string;
-    kbSource: string;
-    reasoning: string;
-}
-interface OrchestratorConfig {
-    verbose?: boolean;
-    logQueries?: boolean;
-}
-/**
- * KnowledgeOrchestrator - Routes ALL decisions through the knowledge base
- *
- * Uses KnowledgeService typed methods for reliable access to all 33 KB domains.
- */
-declare class KnowledgeOrchestrator {
-    private queryLog;
-    private initialized;
-    private config;
-    private kbVersion;
-    constructor(config?: OrchestratorConfig);
-    /**
-     * Initialize the orchestrator by loading the knowledge base
-     */
-    initialize(): Promise<void>;
-    /**
-     * Log a knowledge base query for verification
-     */
-    private log;
+    private loaded;
+    private version;
     /**
-     * Safe JSON stringify that handles undefined
+     * Load the knowledge base from YAML.
+     * MUST be called before any queries.
      */
-    private safeStringify;
+    load(): Promise<void>;
     /**
-     * Get the full query log for verification
+     * Get KB version
      */
-    getQueryLog(): KBQueryLog[];
+    getVersion(): string;
     /**
-     * Get query statistics
+     * Get complete presentation type configuration.
+     * @throws KBQueryError if type not found
      */
-    getQueryStats(): {
-        total: number;
-        byDomain: Record<string, number>;
-    };
+    getPresentationType(type: PresentationType): KBResult<KBPresentationType>;
     /**
-     * Print query log summary (only if verbose)
+     * Get validation rules for a presentation type.
+     * @throws KBQueryError if rules not found
      */
-    printQuerySummary(): void;
+    getValidationRules(type: PresentationType): KBResult<KBValidationRules>;
     /**
-     * Get word limits for a presentation mode
-     * SOURCE: KnowledgeService.getModeRules(mode).characteristics.words_per_slide
+     * Get word limits for a presentation type.
      */
-    getWordLimits(mode: PresentationMode): OrchestratorDecision<{
+    getWordLimits(type: PresentationType): KBResult<{
         min: number;
         max: number;
+        ideal: number;
     }>;
     /**
-     * Get whitespace requirements
-     * SOURCE: KnowledgeService.getModeRules(mode).characteristics.whitespace
+     * Get whitespace requirements.
      */
-    getWhitespaceRequirement(mode: PresentationMode): OrchestratorDecision<number>;
+    getWhitespaceRules(type: PresentationType): KBResult<{
+        min: number;
+        ideal: number;
+        max?: number;
+    }>;
     /**
-     * Get primary experts for a mode
-     * SOURCE: KnowledgeService.getModeRules(mode).experts
+     * Get scoring weights for a presentation type.
      */
-    getPrimaryExperts(mode: PresentationMode): OrchestratorDecision<string[]>;
+    getScoringWeights(type: PresentationType): KBResult<KBScoringWeights>;
     /**
-     * Get full mode configuration
-     * SOURCE: KnowledgeService.getModeRules(mode)
+     * Get allowed slide types for a presentation type.
      */
-    getModeConfig(mode: PresentationMode): OrchestratorDecision<any>;
+    getAllowedSlideTypes(type: PresentationType): KBResult<string[]>;
     /**
-     * Get presentation type configuration
-     * SOURCE: KnowledgeService.getTypeConfig(type)
+     * Get required elements for a presentation type.
      */
-    getTypeConfig(type: PresentationType): OrchestratorDecision<any>;
+    getRequiredElements(type: PresentationType): KBResult<string[]>;
     /**
-     * Get type detection signals
-     * SOURCE: KnowledgeService.getTypeDetection()
+     * Get anti-patterns to avoid for a presentation type.
      */
-    getTypeDetection(): OrchestratorDecision<any>;
+    getAntiPatterns(type: PresentationType): KBResult<string[]>;
     /**
-     * Get Miller's Law limit for items
-     * SOURCE: KnowledgeService.getMillersLaw()
+     * Get the scoring rubric.
      */
-    getMillersLawLimit(): OrchestratorDecision<number>;
+    getScoringRubric(): KBResult<KBScoringRubric>;
     /**
-     * Get chunking rules for information grouping
-     * SOURCE: KnowledgeService.getChunkingPrinciples()
+     * Get passing threshold (default: 95).
      */
-    getChunkingRules(): OrchestratorDecision<string[]>;
+    getPassingThreshold(): KBResult<number>;
     /**
-     * Get cognitive load reduction strategies
-     * SOURCE: KnowledgeService.getCognitiveLoadTheory()
+     * Get expert methodology.
      */
-    getCognitiveLoadRules(): OrchestratorDecision<string[]>;
+    getExpert(name: string): KBResult<KBExpert>;
     /**
-     * Get attention span guidance
-     * SOURCE: KnowledgeService.getAttentionSpan()
+     * Get Nancy Duarte's glance test rules.
      */
-    getAttentionSpanGuidance(): OrchestratorDecision<{
-        maxSeconds: number;
-        rules: string[];
+    getGlanceTest(): KBResult<{
+        description: string;
+        word_limit: number;
     }>;
     /**
-     * Get all cognitive science rules
-     * SOURCE: KnowledgeService.getCognitiveRules()
+     * Get Duarte's Sparkline framework.
      */
-    getAllCognitiveRules(): OrchestratorDecision<any>;
+    getSparkline(): KBResult<Record<string, unknown>>;
     /**
-     * Get proximity principle for layout
-     * SOURCE: KnowledgeService.getGestaltPrinciple('proximity')
+     * Get Minto's SCQA framework.
      */
-    getProximityPrinciple(): OrchestratorDecision<{
-        description: string;
-        application: string[];
-    }>;
+    getSCQA(): KBResult<Record<string, unknown>>;
     /**
-     * Get similarity principle for styling
-     * SOURCE: KnowledgeService.getGestaltPrinciple('similarity')
+     * Get Miller's Law (7±2 items).
      */
-    getSimilarityPrinciple(): OrchestratorDecision<{
-        description: string;
+    getMillersLaw(): KBResult<{
+        principle: string;
         application: string[];
     }>;
     /**
-     * Get all Gestalt principles
-     * SOURCE: KnowledgeService.getGestaltPrinciples()
-     */
-    getAllGestaltPrinciples(): OrchestratorDecision<Record<string, any>>;
-    /**
-     * Get Tufte's data-ink ratio rules
-     * SOURCE: KnowledgeService.getDataVizExpert('edward_tufte')
-     */
-    getTufteDataInkRules(): OrchestratorDecision<string[]>;
-    /**
-     * Get chartjunk to avoid
-     * SOURCE: KnowledgeService.getDataVizExpert('edward_tufte')
-     */
-    getChartjunkToAvoid(): OrchestratorDecision<string[]>;
-    /**
-     * Get Knaflic's 6 key principles
-     * SOURCE: KnowledgeService.getDataVizExpert('cole_nussbaumer_knaflic')
-     */
-    getKnaflicPrinciples(): OrchestratorDecision<Record<string, any>>;
-    /**
-     * Select chart type based on purpose
-     * SOURCE: KnowledgeService.getChartSelectionGuide(purpose)
+     * Get accessibility requirements.
      */
-    selectChartType(purpose: 'comparison' | 'composition' | 'distribution' | 'relationship', characteristics: {
-        categoryCount: number;
-        hasTimeSeries: boolean;
-        variableCount: number;
-    }): OrchestratorDecision<string>;
+    getAccessibilityRules(): KBResult<Record<string, unknown>>;
     /**
-     * Get chart-specific rules
-     * SOURCE: KnowledgeService.getChartRules(chartType)
+     * Get contrast ratio requirements.
      */
-    getChartRules(chartType: string): OrchestratorDecision<any>;
+    getContrastRequirements(): KBResult<{
+        normal_text: string;
+        large_text: string;
+    }>;
     /**
-     * Get table styling rules
-     * SOURCE: KnowledgeService.getChartRules('tables')
+     * Get minimum font sizes.
      */
-    getTableStylingRules(): OrchestratorDecision<string[]>;
+    getFontSizeRequirements(): KBResult<Record<string, string>>;
     /**
-     * Get data label rules
-     * SOURCE: KnowledgeService.getDataLabelRules()
+     * Get Tufte's data-ink ratio rules.
      */
-    getDataLabelRules(): OrchestratorDecision<any>;
+    getDataInkRules(): KBResult<Record<string, unknown>>;
     /**
-     * Get Barbara Minto's Pyramid Principle
-     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto')
+     * Get chartjunk to avoid.
      */
-    getMintoPyramidPrinciple(): OrchestratorDecision<any>;
+    getChartjunk(): KBResult<string[]>;
     /**
-     * Get action title requirements
-     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto') + getModeRules('business')
+     * Get Cialdini's 6 Principles of Influence.
      */
-    getActionTitleRequirements(): OrchestratorDecision<{
-        rules: string[];
-        examples: any;
-    }>;
+    getCialdiniPrinciples(): KBResult<Record<string, unknown>>;
     /**
-     * Get MECE validation rules
-     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto')
+     * Get specific Cialdini principle by name.
      */
-    getMECERules(): OrchestratorDecision<any>;
+    getCialdiniPrinciple(name: string): KBResult<Record<string, unknown>>;
     /**
-     * Get Nancy Duarte's principles
-     * SOURCE: KnowledgeService.getExpertPrinciples('nancy_duarte')
+     * Get all Gestalt principles.
      */
-    getDuartePrinciples(): OrchestratorDecision<any>;
+    getGestaltPrinciples(): KBResult<Record<string, unknown>>;
     /**
-     * Get Glance Test requirements
-     * SOURCE: KnowledgeService.getGlanceTest()
+     * Get specific Gestalt principle by name.
      */
-    getGlanceTestRequirements(): OrchestratorDecision<{
-        maxSeconds: number;
-        rules: string[];
-    }>;
+    getGestaltPrinciple(name: string): KBResult<Record<string, unknown>>;
     /**
-     * Get Garr Reynolds' principles (Presentation Zen)
-     * SOURCE: KnowledgeService.getExpertPrinciples('garr_reynolds')
+     * Get Gestalt proximity principle (for layout checks).
      */
-    getReynoldsPrinciples(): OrchestratorDecision<any>;
+    getGestaltProximity(): KBResult<Record<string, unknown>>;
     /**
-     * Get Carmine Gallo's principles (Talk Like TED)
-     * SOURCE: KnowledgeService.getExpertPrinciples('carmine_gallo')
+     * Get Gestalt similarity principle (for consistency checks).
      */
-    getGalloPrinciples(): OrchestratorDecision<any>;
+    getGestaltSimilarity(): KBResult<Record<string, unknown>>;
     /**
-     * Get Sparkline framework
-     * SOURCE: KnowledgeService.getSparklineFramework()
+     * Get Gestalt figure-ground principle (for visual impact checks).
      */
-    getSparklineFramework(): OrchestratorDecision<any>;
+    getGestaltFigureGround(): KBResult<Record<string, unknown>>;
     /**
-     * Get SCQA framework
-     * SOURCE: KnowledgeService.getSCQAFramework()
+     * Query any KB path directly.
+     * @throws KBQueryError if path not found
      */
-    getSCQAFramework(): OrchestratorDecision<any>;
+    queryRequired<T>(path: string): KBResult<T>;
     /**
-     * Get STAR moment guidance
-     * SOURCE: KnowledgeService.getExpertPrinciples('nancy_duarte')
+     * Query any KB path directly (optional - returns null if not found).
      */
-    getSTARMomentGuidance(): OrchestratorDecision<any>;
+    queryOptional<T>(path: string): KBResult<T | null>;
     /**
-     * Get all story frameworks
-     * SOURCE: KnowledgeService.getStoryFrameworks()
+     * Ensure KB is loaded.
      */
-    getAllStoryFrameworks(): OrchestratorDecision<any>;
+    private ensureLoaded;
     /**
-     * Get Cialdini's persuasion principles
-     * SOURCE: KnowledgeService.getCialdiniPrinciples()
+     * Query a dotted path in the KB.
      */
-    getCialdiniPrinciples(): OrchestratorDecision<any>;
+    private query;
     /**
-     * Get Kahneman insights
-     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     * Create a KB query error.
      */
-    getKahnemanInsights(): OrchestratorDecision<any>;
+    private error;
+}
+/**
+ * Get the singleton KnowledgeGateway instance.
+ */
+declare function getKB(): KnowledgeGateway;
+/**
+ * Initialize and return the KB (async).
+ */
+declare function initKB(): Promise<KnowledgeGateway>;
+
+/**
+ * ContentAnalyzer - Parse and Analyze Input Content
+ *
+ * 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 ContentAnalyzer {
+    private kb;
+    private initialized;
+    constructor();
+    initialize(): Promise<void>;
     /**
-     * Get Heath Brothers' Made to Stick principles
-     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     * Analyze content and return structured analysis.
      */
-    getHeathBrothersPrinciples(): OrchestratorDecision<any>;
+    analyze(content: string, contentType?: 'markdown' | 'text'): Promise<ContentAnalysis>;
     /**
-     * Get all persuasion psychology
-     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     * Parse content into sections based on headers.
      */
-    getAllPersuasionPsychology(): OrchestratorDecision<any>;
+    private parseSections;
     /**
-     * Get color contrast requirements
-     * SOURCE: KnowledgeService.getContrastRequirements()
+     * Extract title from content.
      */
-    getContrastRequirements(): OrchestratorDecision<any>;
+    private extractTitle;
     /**
-     * Get font size requirements
-     * SOURCE: KnowledgeService.getFontSizeRequirements()
+     * Extract bullet points from content.
+     * Strips markdown formatting (**bold**, *italic*, `code`) from bullet text.
      */
-    getFontSizeRequirements(): OrchestratorDecision<any>;
+    private extractBullets;
     /**
-     * Get color blindness guidance
-     * SOURCE: KnowledgeService.getColorBlindnessGuidance()
+     * Strip markdown formatting from text.
+     * Converts **bold**, *italic*, `code`, [links](url) to plain text.
      */
-    getColorBlindnessGuidance(): OrchestratorDecision<any>;
+    private stripMarkdown;
     /**
-     * Get all accessibility rules
-     * SOURCE: KnowledgeService.getAccessibilityRules()
+     * Extract data points (metrics, percentages, currencies, numbers).
      */
-    getAllAccessibilityRules(): OrchestratorDecision<any>;
+    private extractDataPoints;
     /**
-     * Get typography rules
-     * SOURCE: KnowledgeService.getTypography()
+     * Get surrounding context for a data point.
      */
-    getTypographyRules(): OrchestratorDecision<any>;
+    private getContext;
     /**
-     * Get color system
-     * SOURCE: KnowledgeService.getColorSystem()
+     * Parse numeric value from string (handles M/B/K suffixes).
      */
-    getColorSystem(): OrchestratorDecision<any>;
+    private parseNumericValue;
     /**
-     * Get spacing system
-     * SOURCE: KnowledgeService.getSpacingSystem()
+     * Extract key messages from sections.
      */
-    getSpacingSystem(): OrchestratorDecision<any>;
+    private extractKeyMessages;
     /**
-     * Get layout rules
-     * SOURCE: KnowledgeService.getLayoutSystem()
+     * Detect presentation type based on content signals.
      */
-    getLayoutRules(mode: PresentationMode): OrchestratorDecision<any>;
+    private detectPresentationType;
     /**
-     * Get complete design system
-     * SOURCE: KnowledgeService.getDesignSystem()
+     * Identify SCQA (Situation, Complication, Question, Answer) structure.
      */
-    getFullDesignSystem(): OrchestratorDecision<any>;
+    private identifySCQA;
     /**
-     * Get Harvey balls guidance
-     * SOURCE: KnowledgeService.getHarveyBalls()
+     * Identify Sparkline (What Is / What Could Be) structure.
      */
-    getHarveyBallsGuidance(): OrchestratorDecision<any>;
+    private identifySparkline;
+}
+declare function getContentAnalyzer(): ContentAnalyzer;
+declare function initContentAnalyzer(): Promise<ContentAnalyzer>;
+
+/**
+ * SlideGenerator - Generate Slides with Visual Intent
+ *
+ * Takes ContentAnalysis and generates slides with:
+ * - Appropriate slide types based on content
+ * - Visual intent (emphasis, layout hints)
+ * - Respect for KB word limits and rules
+ * - SCQA/Sparkline narrative structure when detected
+ *
+ * ALL decisions come from the Knowledge Base. NO hardcoded fallbacks.
+ */
+
+declare class SlideGenerator {
+    private kb;
+    private vds;
+    private initialized;
+    private wordLimits;
+    private bulletLimit;
+    private allowedSlideTypes;
+    constructor();
+    initialize(): Promise<void>;
     /**
-     * Get traffic light guidance
-     * SOURCE: KnowledgeService.getTrafficLights()
+     * Generate slides from content analysis.
      */
-    getTrafficLightGuidance(): OrchestratorDecision<any>;
+    generate(analysis: ContentAnalysis, presentationType: PresentationType): Promise<Slide[]>;
+    private loadRulesForType;
     /**
-     * Get icon usage guidance
-     * SOURCE: KnowledgeService.getIconGuidance()
+     * Create title slide.
      */
-    getIconGuidance(): OrchestratorDecision<any>;
+    private createTitleSlide;
     /**
-     * Get all consulting visuals
-     * SOURCE: KnowledgeService.getConsultingVisuals()
+     * Create agenda slide.
      */
-    getAllConsultingVisuals(): OrchestratorDecision<any>;
+    private createAgendaSlide;
     /**
-     * Get signal-to-noise ratio requirements
-     * SOURCE: KnowledgeService.getSignalToNoise()
+     * Create SCQA slides (Situation, Complication, Question, Answer).
      */
-    getSignalToNoiseRequirements(): OrchestratorDecision<any>;
+    private createSCQASlides;
     /**
-     * Get one-idea-per-slide requirements
-     * SOURCE: KnowledgeService.getOneIdeaPerSlide()
+     * Create slides for a content section.
      */
-    getOneIdeaRequirements(): OrchestratorDecision<any>;
+    private createSectionSlides;
     /**
-     * Get scoring weights
-     * SOURCE: KnowledgeService.getScoringWeights()
+     * Create metrics grid slide from data points.
      */
-    getScoringWeights(): OrchestratorDecision<any>;
+    private createMetricsSlide;
     /**
-     * Get all quality metrics
-     * SOURCE: KnowledgeService.getQualityMetrics()
+     * Create metrics grid slide from a section.
      */
-    getAllQualityMetrics(): OrchestratorDecision<any>;
+    private createMetricsGridSlide;
     /**
-     * Get anti-patterns to avoid
-     * SOURCE: KnowledgeService.getAntiPatterns()
+     * Create STAR moment slide (Something They'll Always Remember).
      */
-    getAntiPatterns(): OrchestratorDecision<any>;
+    private createStarMomentSlide;
     /**
-     * Get visual anti-patterns
-     * SOURCE: KnowledgeService.getVisualAntiPatterns()
+     * Create call to action slide.
      */
-    getVisualAntiPatterns(): OrchestratorDecision<any[]>;
+    private createCallToActionSlide;
     /**
-     * Get content anti-patterns
-     * SOURCE: KnowledgeService.getContentAntiPatterns()
+     * Create thank you / closing slide.
      */
-    getContentAntiPatterns(): OrchestratorDecision<any[]>;
+    private createThankYouSlide;
     /**
-     * Get slide templates for mode
-     * SOURCE: KnowledgeService.getAllSlideTemplates()
+     * Determine the best slide type for a section.
      */
-    getSlideTemplates(mode: PresentationMode): OrchestratorDecision<any>;
+    private determineSlideType;
     /**
-     * Get specific slide template
-     * SOURCE: KnowledgeService.getSlideTemplate(templateType)
+     * Check if presentation type favors minimal slides.
      */
-    getSlideTemplate(templateType: string): OrchestratorDecision<any>;
+    private isMinimalType;
     /**
-     * Get data integrity requirements
-     * SOURCE: KnowledgeService.getDataIntegrity()
+     * Strip all markdown syntax from text for clean slide content.
+     * This is called on ALL text going into slides to prevent raw markdown.
      */
-    getDataIntegrityRules(): OrchestratorDecision<any>;
+    private stripMarkdownSyntax;
     /**
-     * Get source documentation requirements
-     * SOURCE: KnowledgeService.getSourceDocumentation()
+     * 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)
      */
-    getSourceDocumentationRules(): OrchestratorDecision<any>;
+    private cleanBullets;
     /**
-     * Get verification checklist
-     * SOURCE: KnowledgeService.getVerificationChecklist()
+     * Truncate text to word limit, stripping markdown first.
+     * NEVER adds "..." - just takes the complete words that fit.
      */
-    getVerificationChecklist(): OrchestratorDecision<any>;
+    private truncateToWordLimit;
     /**
-     * Get HTML output configuration
-     * SOURCE: KnowledgeService.getHtmlConfig()
+     * Extract a key statement from content (first sentence or bold text).
      */
-    getHtmlConfig(): OrchestratorDecision<any>;
+    private extractKeyStatement;
     /**
-     * Get PPTX output configuration
-     * SOURCE: KnowledgeService.getPptxConfig()
+     * Extract a key message from title and body for single_statement slides.
+     * Returns a concise, impactful message that provides substance.
      */
-    getPptxConfig(): OrchestratorDecision<any>;
+    private extractKeyMessage;
     /**
-     * Get PPTX generation rules
-     * SOURCE: KnowledgeService.getPptxGeneration()
+     * Extract a label from context (nearby text around a data point).
      */
-    getPptxGenerationRules(): OrchestratorDecision<any>;
+    private extractLabelFromContext;
     /**
-     * Get ALL rules applicable to slide creation
-     * This is the master method that aggregates all relevant KB sections
+     * Detect trend from context (up, down, neutral).
      */
-    getSlideCreationRules(mode: PresentationMode, type: PresentationType): Promise<{
-        wordLimits: OrchestratorDecision<{
-            min: number;
-            max: number;
-        }>;
-        millerLimit: OrchestratorDecision<number>;
-        glanceTest: OrchestratorDecision<{
-            maxSeconds: number;
-            rules: string[];
-        }>;
-        actionTitles: OrchestratorDecision<{
-            rules: string[];
-            examples: any;
-        }>;
-        tufteRules: OrchestratorDecision<string[]>;
-        chartjunk: OrchestratorDecision<string[]>;
-        gestalt: OrchestratorDecision<Record<string, any>>;
-        accessibility: {
-            contrast: OrchestratorDecision<any>;
-            fonts: OrchestratorDecision<any>;
-        };
-        antiPatterns: OrchestratorDecision<any>;
-    }>;
+    private detectTrend;
     /**
-     * Get ALL narrative/persuasion rules
+     * Split array into chunks.
      */
-    getNarrativeRules(): Promise<{
-        sparkline: OrchestratorDecision<any>;
-        scqa: OrchestratorDecision<any>;
-        starMoment: OrchestratorDecision<any>;
-        cialdini: OrchestratorDecision<any>;
-        kahneman: OrchestratorDecision<any>;
-        heath: OrchestratorDecision<any>;
-    }>;
+    private chunkArray;
     /**
-     * Search the knowledge base by keyword
-     * SOURCE: KnowledgeService.search(keyword)
+     * Generate meaningful titles for chunked bullet lists.
+     * Instead of "Title (continued)", create contextual subtitles.
      */
-    searchKB(keyword: string): OrchestratorDecision<any[]>;
+    private generateChunkTitles;
     /**
-     * Get KB version and metadata
+     * Extract a meaningful subtitle from bullet content.
      */
-    getKBMetadata(): OrchestratorDecision<any>;
+    private extractSubtitleFromBullets;
 }
-declare function getKnowledgeOrchestrator(config?: OrchestratorConfig): KnowledgeOrchestrator;
-/**
- * Create a new orchestrator instance (useful for testing with different configs)
- */
-declare function createKnowledgeOrchestrator(config?: OrchestratorConfig): KnowledgeOrchestrator;
+declare function getSlideGenerator(): SlideGenerator;
+declare function initSlideGenerator(): Promise<SlideGenerator>;
 
 /**
- * NarrativeAnalyzer - Story Structure Analysis Engine
- *
- * THIS MODULE ANALYZES AND ENFORCES NARRATIVE STRUCTURE.
- *
- * ALL decisions flow through the KnowledgeOrchestrator - NO hardcoding.
- *
- * Implements expert frameworks from:
- * - Nancy Duarte (Sparkline: What Is / What Could Be, STAR moments)
- * - Barbara Minto (SCQA: Situation, Complication, Question, Answer)
- * - Cole Nussbaumer Knaflic (Story structure: Beginning, Middle, End)
- * - Carmine Gallo (Rule of Three, Emotional Connection)
- * - Chris Anderson (One Idea, Gift Giving)
+ * VisualDesignSystem - KB-Driven Visual Design Configuration
  *
- * The knowledge base IS the brain. This code is just plumbing.
+ * CRITICAL: ALL design decisions come from the Knowledge Base.
+ * This module queries KB for colors, typography, gradients, layouts.
+ * NO hardcoded fallbacks.
  */
 
-type SparklineStage = 'what_is' | 'what_could_be' | 'contrast' | 'star_moment' | 'new_bliss' | 'unknown';
-type SCQAStage = 'situation' | 'complication' | 'question' | 'answer' | 'unknown';
-type EmotionalPosition = 'opening_hook' | 'rising_tension' | 'climax' | 'resolution' | 'call_to_action';
-interface SectionNarrativeAnalysis {
-    section: ExtractedSection;
-    sparklineStage: SparklineStage;
-    scqaStage: SCQAStage;
-    emotionalPosition: EmotionalPosition;
-    emotionalIntensity: number;
-    isSTARCandidate: boolean;
-    narrativeFunction: string;
-    kbSources: string[];
+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 PresentationNarrativeAnalysis {
-    sections: SectionNarrativeAnalysis[];
-    sparklineFlow: SparklineStage[];
-    hasProperSparkline: boolean;
-    sparklineScore: number;
-    scqaFlow: SCQAStage[];
-    hasProperSCQA: boolean;
-    scqaScore: number;
-    starMomentIndex: number | null;
-    starMomentContent: string | null;
-    emotionalArc: EmotionalPosition[];
-    emotionalScore: number;
-    overallNarrativeScore: number;
-    recommendations: string[];
-    kbQueriesUsed: number;
+interface SlideLayout {
+    name: string;
+    purpose: string;
+    elements: string[];
+    wordLimit?: number;
+    grid?: {
+        columns: number;
+        rows?: number;
+        gap: string;
+    };
 }
-/**
- * NarrativeAnalyzer - Analyzes and enforces story structure
- */
-declare class NarrativeAnalyzer {
-    private orchestrator;
-    private sparklineKB;
-    private scqaKB;
-    private starMomentKB;
-    private knaflicKB;
-    private galloKB;
-    private andersonKB;
-    private queryCount;
+interface VisualTheme {
+    presentationType: PresentationType;
+    mode: 'keynote' | 'business';
+    palette: ColorPalette;
+    typography: Typography;
+    layout: LayoutRules;
+    gradients: GradientDefinition[];
+    cssVariables: Record<string, string>;
+}
+declare class VisualDesignSystem {
+    private kb;
     private initialized;
     constructor();
     /**
-     * Initialize by loading all narrative frameworks from KB
-     * OPTIMIZATION: Only initialize once - cached data is reused
+     * Initialize the design system (loads KB)
      */
     initialize(): Promise<void>;
     /**
-     * Analyze the narrative structure of content
-     */
-    analyzeNarrative(analysis: ContentAnalysis, mode: PresentationMode): Promise<PresentationNarrativeAnalysis>;
-    /**
-     * Analyze a single section's narrative position
-     */
-    private analyzeSection;
-    /**
-     * Classify content into Sparkline stage
-     * Based on KB: story_frameworks.sparkline
-     */
-    private classifySparklineStage;
-    /**
-     * Classify content into SCQA stage
-     * Based on KB: story_frameworks.scqa, experts.barbara_minto.scqa_framework
-     */
-    private classifySCQAStage;
-    /**
-     * Classify emotional position and intensity
-     * Based on KB: persuasion_psychology, experts.nancy_duarte.core_principles
-     */
-    private classifyEmotionalPosition;
-    /**
-     * Check if section is a STAR moment candidate
-     * Based on KB: experts.nancy_duarte.core_teachings.star_moment
+     * Get complete visual theme for a presentation type.
      */
-    private isSTARMomentCandidate;
+    getTheme(type: PresentationType): Promise<VisualTheme>;
     /**
-     * Determine the narrative function of a section
+     * Determine mode (keynote vs business) for a presentation type.
      */
-    private determineNarrativeFunction;
+    private getModeForType;
     /**
-     * Find the best STAR moment in the presentation
+     * Get color palette for presentation type from KB.
      */
-    private findSTARMoment;
+    private getPaletteForType;
     /**
-     * Score the Sparkline flow
-     * Based on KB: story_frameworks.sparkline.stages
+     * Get typography rules for mode from KB.
      */
-    private scoreSparklineFlow;
+    private getTypographyForMode;
     /**
-     * Score the SCQA flow
-     * Based on KB: story_frameworks.scqa, experts.barbara_minto
+     * Get layout rules for mode from KB.
      */
-    private scoreSCQAFlow;
+    private getLayoutRulesForMode;
     /**
-     * Score the emotional arc
-     * Based on KB: persuasion_psychology, experts.nancy_duarte
+     * Get gradient definitions for presentation type.
      */
-    private scoreEmotionalArc;
+    private getGradientsForType;
     /**
-     * Generate recommendations for improving narrative
+     * Build CSS custom properties for the theme.
      */
-    private generateRecommendations;
+    private buildCSSVariables;
     /**
-     * Get recommended Sparkline structure for a presentation
-     * Based on KB: story_frameworks.sparkline
+     * Get slide layout templates from KB.
      */
-    getRecommendedSparklineStructure(slideCount: number): SparklineStage[];
+    getSlideLayouts(type: PresentationType): Promise<SlideLayout[]>;
     /**
-     * Get recommended SCQA structure based on mode
-     * Based on KB: story_frameworks.scqa, experts.barbara_minto
+     * Generate complete CSS for the theme.
      */
-    getRecommendedSCQAStructure(slideCount: number, mode: PresentationMode): SCQAStage[];
+    generateCSS(theme: VisualTheme): string;
+    private lightenColor;
+    private darkenColor;
+    private hexToRgb;
     /**
-     * Get total KB queries made
+     * Get contrasting text color for a given background color.
+     * Returns white or black based on luminance.
      */
-    getQueryCount(): number;
+    private getContrastColor;
 }
-declare function getNarrativeAnalyzer(): NarrativeAnalyzer;
+declare function getVisualDesignSystem(): VisualDesignSystem;
+declare function initVisualDesignSystem(): Promise<VisualDesignSystem>;
 
 /**
- * ExpertValidator - Validates Slides Against ALL Expert Methodologies
- *
- * THIS MODULE VALIDATES OUTPUT AGAINST THE COMPLETE KNOWLEDGE BASE.
- *
- * ALL validation rules come from the KB - NO hardcoded thresholds.
- *
- * Validates against 40+ expert methodologies including:
- *
- * DATA VISUALIZATION:
- * - Edward Tufte (Data-Ink Ratio, Chartjunk elimination)
- * - Cole Nussbaumer Knaflic (Storytelling with Data)
- * - Scott Berinato (Good Charts)
- *
- * PRESENTATION DESIGN:
- * - Nancy Duarte (Glance Test, STAR moments, Sparkline)
- * - Garr Reynolds (Signal-to-Noise, Presentation Zen)
- * - Carmine Gallo (Rule of Three, 18 minutes)
- * - Chris Anderson (One Idea, Dead Laptop Test)
- * - Guy Kawasaki (10/20/30 Rule)
- *
- * BUSINESS COMMUNICATION:
- * - Barbara Minto (Pyramid Principle, MECE, Action Titles)
- * - McKinsey/BCG/Bain (Consulting standards)
- * - Analyst Academy (SCQA Framework)
- *
- * COGNITIVE SCIENCE:
- * - George Miller (7±2 items)
- * - John Sweller (Cognitive Load Theory)
- * - Gestalt Psychology (Proximity, Similarity, etc.)
+ * SlideQualityReviewer - THE HEART OF THE QUALITATIVE REVIEW SYSTEM
  *
- * PERSUASION:
- * - Robert Cialdini (6 Principles of Influence)
- * - Daniel Kahneman (System 1/2)
- * - Chip & Dan Heath (Made to Stick - SUCCESs)
+ * 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
  *
- * ACCESSIBILITY:
- * - WCAG 2.1 Standards
- *
- * The knowledge base IS the brain. This code is just plumbing.
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
  */
 
-interface ValidationCheck {
-    expert: string;
-    principle: string;
-    kbPath: string;
-    passed: boolean;
+type QualityLevel = 'excellent' | 'good' | 'acceptable' | 'poor' | 'failing';
+interface QualitativeAssessment {
+    /** Score (0-100) */
     score: number;
-    message: string;
-    remediation?: string | undefined;
-}
-interface SlideValidation {
-    slideIndex: number;
-    slideTitle: string;
-    checks: ValidationCheck[];
-    overallScore: number;
-    passed: boolean;
-    criticalFailures: string[];
+    /** Quality level */
+    level: QualityLevel;
+    /** WHY this score - specific reasoning */
+    reasoning: string;
+    /** KB reference for this assessment */
+    kbReference?: string;
 }
-interface PresentationValidation {
-    slides: SlideValidation[];
-    overallScore: number;
-    passed: boolean;
-    expertScores: Record<string, number>;
-    categoryScores: {
-        dataVisualization: number;
-        presentationDesign: number;
-        businessCommunication: number;
-        cognitiveScience: number;
-        persuasion: number;
-        accessibility: number;
+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;
     };
-    kbQueriesUsed: number;
-    criticalIssues: string[];
-    recommendations: string[];
+    /** Specific issues found */
+    issues: QualityIssue[];
+    /** What would make this slide better */
+    improvements: string[];
+}
+interface QualityIssue {
+    severity: 'critical' | 'major' | 'minor';
+    category: 'visual' | 'content' | 'layout' | 'typography' | 'accessibility';
+    issue: string;
+    fix: string;
+    kbReference?: string;
 }
-/**
- * ExpertValidator - Validates against all expert methodologies
- */
-declare class ExpertValidator {
-    private orchestrator;
-    private queryCount;
+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 the validator
-     */
     initialize(): Promise<void>;
     /**
-     * Validate an entire presentation
-     */
-    validatePresentation(slides: Slide[], mode: PresentationMode): Promise<PresentationValidation>;
-    /**
-     * Validate a single slide against all expert principles
-     */
-    private validateSlide;
-    /**
-     * Validate Tufte's Data-Ink Ratio
-     * KB: data_visualization_experts.edward_tufte.core_principles.data_ink_ratio
-     */
-    private validateTufteDataInk;
-    /**
-     * Validate Tufte's Chartjunk elimination
-     * KB: data_visualization_experts.edward_tufte.core_principles.chartjunk
+     * Review a slide qualitatively.
      */
-    private validateTufteChartjunk;
+    review(slide: Slide, presentationType: PresentationType): Promise<QualitativeSlideReview>;
     /**
-     * Validate Knaflic's principles
-     * KB: data_visualization_experts.cole_nussbaumer_knaflic.six_key_principles
+     * Convert qualitative review to SlideScore format.
      */
-    private validateKnaflicPrinciples;
+    toSlideScore(review: QualitativeSlideReview): SlideScore;
+    private loadRulesForType;
     /**
-     * Validate Duarte's Glance Test
-     * KB: quality_metrics.glance_test, experts.nancy_duarte
+     * Visual Impact (25%): Does this slide command attention appropriately?
      */
-    private validateDuarteGlanceTest;
+    private assessVisualImpact;
     /**
-     * Validate Reynolds' Signal-to-Noise ratio
-     * KB: experts.garr_reynolds.core_principles.signal_to_noise
+     * Content Clarity (20%): Can you understand the message in 3 seconds?
      */
-    private validateReynoldsSignalNoise;
+    private assessContentClarity;
     /**
-     * Validate Gallo's Rule of Three
-     * KB: experts.carmine_gallo.core_principles.rule_of_three
+     * Get all text content from a slide for analysis.
      */
-    private validateGalloRuleOfThree;
+    private getAllTextContent;
     /**
-     * Validate Anderson's One Idea principle
-     * KB: experts.chris_anderson.core_principles.one_idea
+     * Layout Balance (15%): Is visual weight distributed appropriately?
      */
-    private validateAndersonOneIdea;
+    private assessLayoutBalance;
     /**
-     * Validate Minto's Action Titles
-     * KB: experts.barbara_minto, presentation_modes.business
+     * Typography Hierarchy (15%): Is there clear primary/secondary/tertiary hierarchy?
      */
-    private validateMintoActionTitles;
+    private assessTypographyHierarchy;
     /**
-     * Validate Minto's MECE principle
-     * KB: experts.barbara_minto.mece_principle
+     * Whitespace Usage (10%): Is whitespace used purposefully?
      */
-    private validateMintoMECE;
+    private assessWhitespaceUsage;
     /**
-     * Validate Horizontal Logic (titles tell the story)
-     * KB: data_visualization_experts.cole_nussbaumer_knaflic.horizontal_vertical_logic
+     * Color Harmony (10%): Do colors work together within the theme?
      */
-    private validateHorizontalLogic;
+    private assessColorHarmony;
     /**
-     * Validate Miller's Law (7±2 items)
-     * KB: cognitive_science.millers_law
+     * Audience Appropriateness (5%): Is the visual style right for this audience?
      */
-    private validateMillersLaw;
+    private assessAudienceAppropriate;
+    private isMinimalType;
+    private isDenseType;
+    private countWords;
+    private countLongWords;
     /**
-     * Validate Cognitive Load
-     * KB: cognitive_science.cognitive_load_theory
+     * Detect raw markdown syntax that should have been rendered to HTML.
+     * Returns array of issue descriptions.
      */
-    private validateCognitiveLoad;
+    private detectRawMarkdown;
     /**
-     * Validate Gestalt Proximity principle
-     * KB: gestalt_principles.proximity
+     * Check if slide type is appropriate for its content.
+     * Returns issue description if mismatched.
      */
-    private validateGestaltProximity;
+    private checkSlideTypeMismatch;
+    private scoreToLevel;
+    private collectIssues;
+    private mapAssessmentToCategory;
+    private mapIssueCategory;
+    private generateImprovements;
+    private createCategoryScore;
+}
+declare function getSlideQualityReviewer(): SlideQualityReviewer;
+declare function initSlideQualityReviewer(): Promise<SlideQualityReviewer>;
+
+/**
+ * DeckQualityReviewer - HOLISTIC DECK QUALITY REVIEW
+ *
+ * After all slides pass individual review, this evaluates the deck as a whole:
+ * 1. Narrative Flow (30%) - Does it tell a coherent story?
+ * 2. Visual Consistency (25%) - Is the same theme applied throughout?
+ * 3. Pacing & Rhythm (20%) - Is there variety and appropriate density?
+ * 4. Opening & Closing (15%) - Are first/last slides the strongest?
+ * 5. Overall Impression (10%) - Would you hire/invest based on this?
+ *
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
+ */
+
+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>;
     /**
-     * Validate word count
-     * KB: presentation_modes.[mode].characteristics.words_per_slide
+     * Review the entire deck qualitatively.
      */
-    private validateWordCount;
+    review(slides: Slide[], presentationType: PresentationType): Promise<QualitativeDeckReview>;
     /**
-     * Validate accessibility basics
-     * KB: accessibility
+     * Convert qualitative review to DeckScore format.
      */
-    private validateAccessibility;
+    toDeckScore(review: QualitativeDeckReview): DeckScore;
+    private loadRulesForType;
     /**
-     * Get all text content from a slide
+     * Narrative Flow (30%): Does the presentation tell a coherent story?
      */
-    private getSlideContent;
+    private assessNarrativeFlow;
     /**
-     * Count words in a slide
+     * Visual Consistency (25%): Is the same theme applied throughout?
      */
-    private countWords;
+    private assessVisualConsistency;
     /**
-     * Calculate scores by expert
+     * Pacing & Rhythm (20%): Is there variety in slide types and density?
      */
-    private calculateExpertScores;
+    private assessPacingRhythm;
     /**
-     * Calculate category scores
+     * Opening & Closing (15%): Are the first and last slides the strongest?
      */
-    private calculateCategoryScores;
-    private avgScore;
+    private assessOpeningClosing;
     /**
-     * Aggregate critical issues across all slides
+     * Overall Impression (10%): Would you hire/invest based on this?
      */
-    private aggregateCriticalIssues;
+    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>;
+
+/**
+ * Remediator - Fix Failing Slides
+ *
+ * When a slide fails qualitative review (< 95), this module attempts to fix it.
+ * Maximum 3 remediation attempts per slide.
+ *
+ * Remediation strategies are based on the specific quality issues identified:
+ * - Visual Impact: Increase title prominence, add visual elements
+ * - Content Clarity: Reduce word count, simplify messaging
+ * - Layout Balance: Redistribute content, improve alignment
+ * - Typography Hierarchy: Adjust text sizes, create clearer hierarchy
+ * - Whitespace Usage: Remove content or split slide
+ * - Color Harmony: Ensure colors match theme
+ * - Audience Appropriateness: Adjust density for audience
+ *
+ * ALL rules come from the Knowledge Base. NO hardcoded fallbacks.
+ */
+
+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>;
     /**
-     * Generate recommendations based on validation results
+     * Attempt to remediate a failing slide.
      */
-    private generateRecommendations;
+    remediate(slide: Slide, presentationType: PresentationType, initialReview: QualitativeSlideReview): Promise<RemediationResult>;
     /**
-     * Get query count
+     * Batch remediate multiple slides.
      */
-    getQueryCount(): number;
+    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 getExpertValidator(): ExpertValidator;
+declare function getRemediator(): Remediator;
+declare function initRemediator(): Promise<Remediator>;
 
 /**
- * PersuasionEngine - Applies Persuasion Psychology to Presentations
+ * Renderer - Premium HTML/PPTX Output Generation
  *
- * THIS MODULE ENHANCES PRESENTATIONS WITH PSYCHOLOGICAL PERSUASION.
+ * Renders slides to high-quality outputs:
+ * - HTML: Reveal.js with premium CSS from KB
+ * - PPTX: PowerPoint (future implementation)
  *
- * ALL decisions flow through the KnowledgeOrchestrator - NO hardcoding.
- *
- * Implements frameworks from:
- *
- * ROBERT CIALDINI - 6 Principles of Influence:
- * - Reciprocity: Give value first
- * - Commitment/Consistency: Build on prior agreements
- * - Social Proof: Show what others are doing
- * - Authority: Cite credible experts
- * - Liking: Create rapport and common ground
- * - Scarcity: Highlight limited opportunities
- *
- * DANIEL KAHNEMAN - Dual Process Theory:
- * - System 1: Fast, intuitive, emotional
- * - System 2: Slow, deliberate, rational
- * - Cognitive biases and heuristics
- *
- * CHIP & DAN HEATH - Made to Stick (SUCCESs):
- * - Simple: Find the core
- * - Unexpected: Break patterns
- * - Concrete: Use specific examples
- * - Credible: Cite proof
- * - Emotional: Appeal to feelings
- * - Stories: Use narrative
- *
- * ARISTOTLE - Rhetoric:
- * - Ethos: Credibility
- * - Pathos: Emotion
- * - Logos: Logic
- *
- * The knowledge base IS the brain. This code is just plumbing.
+ * ALL styling comes from the Knowledge Base and VisualDesignSystem.
+ * NO hardcoded styles.
  */
 
-type CialdiniPrinciple = 'reciprocity' | 'commitment_consistency' | 'social_proof' | 'authority' | 'liking' | 'scarcity';
-type KahnemanSystem = 'system_1' | 'system_2';
-type HeathPrinciple = 'simple' | 'unexpected' | 'concrete' | 'credible' | 'emotional' | 'stories';
-type AristotleAppeal = 'ethos' | 'pathos' | 'logos';
-interface PersuasionOpportunity {
-    principle: CialdiniPrinciple | HeathPrinciple | AristotleAppeal;
-    source: string;
-    kbPath: string;
-    location: 'title' | 'subtitle' | 'bullet' | 'content';
-    originalText: string;
-    enhancedText: string;
-    reasoning: string;
-    confidence: number;
-}
-interface SectionPersuasionAnalysis {
-    section: ExtractedSection;
-    cialdiniOpportunities: Map<CialdiniPrinciple, PersuasionOpportunity[]>;
-    heathAlignment: Map<HeathPrinciple, number>;
-    kahnemanTarget: KahnemanSystem;
-    aristotleBalance: Record<AristotleAppeal, number>;
-    overallPersuasivenessScore: number;
-    recommendations: string[];
-}
-interface PresentationPersuasionAnalysis {
-    sections: SectionPersuasionAnalysis[];
-    cialdiniUsage: Record<CialdiniPrinciple, number>;
-    heathScore: number;
-    kahnemanBalance: {
-        system1: number;
-        system2: number;
-    };
-    aristotleBalance: Record<AristotleAppeal, number>;
-    overallPersuasivenessScore: number;
-    topOpportunities: PersuasionOpportunity[];
-    kbQueriesUsed: number;
+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;
 }
-/**
- * PersuasionEngine - Applies persuasion psychology
- */
-declare class PersuasionEngine {
-    private orchestrator;
-    private cialdiniKB;
-    private kahnemanKB;
-    private heathKB;
-    private queryCount;
+declare class Renderer {
+    private kb;
+    private vds;
     private initialized;
+    private readonly slideImageKeywords;
     constructor();
-    /**
-     * Initialize by loading all persuasion frameworks from KB
-     * OPTIMIZATION: Only initialize once - cached data is reused
-     */
     initialize(): Promise<void>;
     /**
-     * Analyze content for persuasion opportunities
-     */
-    analyzePersuasion(sections: ExtractedSection[], mode: PresentationMode): Promise<PresentationPersuasionAnalysis>;
-    /**
-     * Analyze a single section for persuasion
+     * Render slides to specified formats.
      */
-    private analyzeSection;
+    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;
     /**
-     * Find Cialdini principle opportunities
-     * KB: persuasion_psychology.cialdini_principles
+     * Generate a background image URL based on slide type and content.
+     * Priority: 1) slide.data.image, 2) local images array, 3) Picsum fallback
      */
-    private findCialdiniOpportunities;
+    private getBackgroundImageUrl;
     /**
-     * Analyze Heath Brothers' SUCCESs alignment
-     * KB: persuasion_psychology.heath_brothers
+     * Resolve an image path - handles relative paths, absolute paths, and URLs.
      */
-    private analyzeHeathAlignment;
+    private resolveImagePath;
     /**
-     * Determine Kahneman System target
-     * KB: persuasion_psychology.kahneman_systems
+     * Generate fallback image URL using Picsum with smart seeding.
      */
-    private determineKahnemanTarget;
+    private getFallbackImageUrl;
     /**
-     * Analyze Aristotle's rhetorical balance
-     * KB: persuasion_psychology.aristotle
+     * Convert markdown syntax to HTML.
+     * Handles: bold, italic, code, links, and basic formatting.
+     * Called BEFORE escapeHTML to preserve markdown-generated HTML tags.
      */
-    private analyzeAristotleBalance;
+    private renderMarkdown;
     /**
-     * Calculate section persuasiveness score
+     * Clean up broken/truncated markdown that can't be properly rendered.
+     * Removes partial code blocks, inline tables, etc.
      */
-    private calculateSectionPersuasiveness;
+    private cleanBrokenMarkdown;
     /**
-     * Generate recommendations for a section
+     * Render markdown tables to HTML tables.
      */
-    private generateSectionRecommendations;
+    private renderMarkdownTables;
     /**
-     * Aggregate Cialdini usage across sections
+     * Build an HTML table from markdown table rows.
      */
-    private aggregateCialdiniUsage;
+    private buildHTMLTable;
+}
+declare function getRenderer(): Renderer;
+declare function initRenderer(): Promise<Renderer>;
+
+/**
+ * NanoBanana Pro Image Generation Provider
+ *
+ * Integrates with Google Gemini's image generation capabilities via NanoBanana Pro.
+ * Generates high-quality hero images, concept illustrations, and visual assets
+ * for presentation slides.
+ *
+ * Requires: GOOGLE_AI_API_KEY environment variable
+ *
+ * Usage:
+ *   const provider = createNanoBananaProvider();
+ *   if (await provider.isAvailable()) {
+ *     const imageUrl = await provider.generateHeroImage('AI revolution');
+ *   }
+ */
+interface ImageGenerationRequest {
+    /** The concept or topic to visualize */
+    concept: string;
+    /** Image style/type */
+    style: 'hero' | 'concept' | 'icon' | 'background' | 'diagram';
+    /** Presentation type for context */
+    presentationType?: string;
+    /** Aspect ratio */
+    aspectRatio?: '16:9' | '4:3' | '1:1' | '9:16';
+    /** Color scheme preference */
+    colorScheme?: 'dark' | 'light' | 'vibrant' | 'muted';
+}
+interface ImageGenerationResult {
+    /** Whether generation succeeded */
+    success: boolean;
+    /** Generated image URL or base64 data */
+    imageUrl?: string;
+    /** Base64 encoded image data */
+    imageData?: string;
+    /** MIME type of the image */
+    mimeType?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Prompt used for generation */
+    promptUsed?: string;
+}
+interface NanoBananaConfig {
+    /** Google AI API key (defaults to GOOGLE_AI_API_KEY env var) */
+    apiKey?: string;
+    /** Model to use (defaults to gemini-2.0-flash-exp for image generation) */
+    model?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * NanoBanana Pro image generation provider.
+ * Uses Google Gemini's image generation capabilities.
+ */
+declare class NanoBananaProvider {
+    readonly name = "NanoBanana Pro";
+    private apiKey;
+    private model;
+    private timeout;
+    private verbose;
+    constructor(config?: NanoBananaConfig);
     /**
-     * Calculate overall Heath SUCCESs score
+     * Check if NanoBanana is available (API key present).
      */
-    private calculateHeathScore;
+    isAvailable(): Promise<boolean>;
     /**
-     * Calculate Kahneman balance
+     * Generate a hero image for a slide.
      */
-    private calculateKahnemanBalance;
+    generateHeroImage(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Calculate Aristotle balance across presentation
+     * Generate a concept illustration.
      */
-    private calculateAristotleBalance;
+    generateConceptImage(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Calculate overall persuasiveness score
+     * Generate an icon or symbol.
      */
-    private calculateOverallPersuasiveness;
+    generateIcon(concept: string): Promise<ImageGenerationResult>;
     /**
-     * Find top persuasion opportunities
+     * Generate a background image.
      */
-    private findTopOpportunities;
+    generateBackground(concept: string, colorScheme?: 'dark' | 'light'): Promise<ImageGenerationResult>;
     /**
-     * Get suggested persuasion enhancements for a slide
-     * Returns specific text suggestions based on KB principles
+     * Generate an image based on request parameters.
      */
-    getSlideEnhancements(slide: Slide, mode: PresentationMode): Promise<{
-        enhancedTitle?: string | undefined;
-        enhancedBullets?: string[] | undefined;
-        persuasionTechniques: string[];
-        kbReferences: string[];
-    }>;
+    generate(request: ImageGenerationRequest): Promise<ImageGenerationResult>;
     /**
-     * Get power words from KB
-     * KB: persuasion_psychology.power_words
+     * Build an optimized prompt for image generation.
      */
-    getPowerWords(): Promise<{
-        urgency: string[];
-        exclusivity: string[];
-        emotion: string[];
-        authority: string[];
-        kbPath: string;
-    }>;
+    private buildPrompt;
     /**
-     * Get query count
+     * Call the Gemini API for image generation.
      */
-    getQueryCount(): number;
+    private callGeminiAPI;
 }
-declare function getPersuasionEngine(): PersuasionEngine;
-
 /**
- * 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
+ * Create a new NanoBanana provider instance.
+ */
+declare function createNanoBananaProvider(config?: NanoBananaConfig): NanoBananaProvider;
+/**
+ * Get a pre-built prompt for a specific image type.
+ * Useful for customization or debugging.
  */
+declare function getNanoBananaPrompt(style: 'hero' | 'concept' | 'icon' | 'background' | 'diagram', concept: string, presentationType?: string): string;
 
 /**
- * Generate a presentation from content.
- *
- * @example
- * ```typescript
- * import { generate } from '@isovision/claude-presentation-master';
+ * CodeQualityValidator - Detects Hardcoded Values in Source Code
  *
- * const result = await generate({
- *   content: '# My Presentation\n\n...',
- *   contentType: 'markdown',
- *   mode: 'keynote',
- *   format: ['html', 'pptx'],
- *   qaThreshold: 95,
- *   title: 'My Amazing Presentation'
- * });
+ * This validator scans TypeScript/JavaScript source files for hardcoded CSS values,
+ * colors, and dimensions that should be coming from the Knowledge Base.
  *
- * console.log(`Score: ${result.score}/100`);
- * ```
+ * 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
  *
- * @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
+ * This validator catches these careless errors at build/test time.
+ */
+interface HardcodedViolation {
+    file: string;
+    line: number;
+    column: number;
+    type: 'color' | 'dimension' | 'font' | 'shadow' | 'rgba' | 'gradient';
+    value: string;
+    context: string;
+    severity: 'error' | 'warning';
+    suggestion: string;
+}
+interface ValidationResult {
+    passed: boolean;
+    violations: HardcodedViolation[];
+    summary: {
+        totalFiles: number;
+        filesWithViolations: number;
+        totalViolations: number;
+        byType: Record<string, number>;
+        bySeverity: Record<string, number>;
+    };
+}
+declare class CodeQualityValidator {
+    private srcDir;
+    private violations;
+    constructor(srcDir: string);
+    /**
+     * Validate all TypeScript files in the source directory.
+     */
+    validate(): Promise<ValidationResult>;
+    /**
+     * Validate a single file for hardcoded values.
+     */
+    private validateFile;
+    private checkForHexColors;
+    private checkForRgbaColors;
+    private checkForDimensions;
+    private checkForGradients;
+    private findTypeScriptFiles;
+    private shouldSkipFile;
+    private isExemptLine;
+    private buildResult;
+    /**
+     * Format validation results for console output.
+     */
+    formatResults(result: ValidationResult): string;
+}
+/**
+ * Run code quality validation on the source directory.
  */
-declare function generate(config: PresentationConfig): Promise<PresentationResult>;
+declare function validateCodeQuality(srcDir: string): Promise<ValidationResult>;
 /**
- * Validate an existing presentation.
- *
- * @example
- * ```typescript
- * import { validate } from '@isovision/claude-presentation-master';
- * import fs from 'fs';
+ * Run validation and print results to console.
+ */
+declare function runCodeQualityCheck(srcDir: string): Promise<boolean>;
+
+/**
+ * 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 = "3.0.1";
 
+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.
  *
- * Now includes Knowledge-Driven Orchestration components:
- * - getKnowledgeOrchestrator: Central brain that routes ALL decisions through KB
- * - getNarrativeAnalyzer: Duarte Sparkline, STAR moments, SCQA analysis
- * - getExpertValidator: Validates against 40+ expert methodologies
- * - getPersuasionEngine: Cialdini, Kahneman, Heath Brothers
+ * 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;
-    getKnowledgeOrchestrator: typeof getKnowledgeOrchestrator;
-    getNarrativeAnalyzer: typeof getNarrativeAnalyzer;
-    getExpertValidator: typeof getExpertValidator;
-    getPersuasionEngine: typeof getPersuasionEngine;
-};
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
 
-export { type AccessibilityResults, AccessibilityValidator, type AgentAssessment, type AristotleAppeal, type AspectRatio, AutoRemediation, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, type CialdiniPrinciple, type ComparisonData, CompositeChartProvider, CompositeImageProvider, type ConsensusConfig, type ConsensusResult, ConsensusValidator, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContentTransform, type ContrastIssue, type EmotionalPosition, type ExecutionStrategy, type ExpertAgent, type ExpertQAResults, type ExpertValidation, ExpertValidator, type ExtractedConcept$1 as ExtractedConcept, type ExtractedDataPoint, type ExtractedSection, type FinancialSummary, type FontSizeIssue, type GlanceTestResult, HTMLLayoutValidator, HallucinationDetector, type HeathPrinciple, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, type ImageSize, type KBQueryLog, type KahnemanSystem, KnowledgeBase, KnowledgeOrchestrator, LocalImageProvider, MermaidProvider, type MetricData, NANOBANANA_PROMPT_TEMPLATES, type NanoBananaConfig, type NanoBananaModel, NanoBananaProvider, NarrativeAnalyzer, type OneIdeaResult, type OrchestratorConfig, type OrchestratorDecision, type OutputFormat, PPTXValidator, PRESENTATION_TYPE_RULES, type ParsedTable, PersuasionEngine, type PersuasionOpportunity, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationNarrativeAnalysis, type PresentationPersuasionAnalysis, type PresentationResult, type PresentationType, type PresentationTypeRules, type PresentationValidation, type PresentationVisionAnalysis, type PromptTemplate, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStage, type SCQAStructure, ScoreCalculator, type SectionNarrativeAnalysis, type SectionPersuasionAnalysis, type SemanticCompletenessResult$1 as SemanticCompletenessResult, SemanticCompletenessValidator, type SignalNoiseResult, type Slide, type SlideBlueprint, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideValidation, type SlideVisionAnalysis, type SlideVisualScore, type SparklineStage, type SparklineStructure, StrategyFactory, TemplateEngine, TemplateNotFoundError, type ThemeName, TypeDetector, UnsplashImageProvider, VERSION, type ValidationCheck, ValidationError, type VisionQAConfig, VisionQAEngine, type VisionQAResults, type VisionSlideAnalysis, type VisualQAResults, createConsensusValidator, createDefaultChartProvider, createDefaultImageProvider, createKnowledgeOrchestrator, createNanoBananaProvider, createVisionQAEngine, _default as default, generate, getConsensusValidator, getExpertValidator, getKnowledgeBase, getKnowledgeOrchestrator, getNanoBananaPrompt, getNarrativeAnalyzer, getPersuasionEngine, getVisionQAEngine, 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 };