/** * Claude Presentation Master - Type Definitions * @module types */ type PresentationMode = 'keynote' | 'business'; type OutputFormat = 'html' | 'pptx' | 'pdf'; type ThemeName = 'default' | 'light-corporate' | 'modern-tech' | 'minimal' | 'warm' | 'creative'; type PresentationType = 'ted_keynote' | 'sales_pitch' | 'consulting_deck' | 'investment_banking' | 'investor_pitch' | 'technical_presentation' | 'all_hands'; interface PresentationConfig { /** Input content (Markdown, JSON, YAML, or plain text) */ content: string; /** Content format */ contentType: 'markdown' | 'json' | 'yaml' | 'text'; /** Presentation mode: keynote (6-25 words/slide) or business (40-80 words/slide) */ mode: PresentationMode; /** Specific presentation type (optional, inferred from mode if not provided) */ presentationType?: PresentationType; /** Output formats to generate */ format: OutputFormat[]; /** Visual theme */ theme?: ThemeName; /** Minimum QA score required (0-100, default: 80) */ 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; /** Local images available for use */ images?: string[]; /** Base path for resolving image paths */ imageBasePath?: string; /** Generate PDF alongside HTML (default: true when format includes 'html') */ generatePdf?: boolean; } 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' | 'football-field' | 'buyer-universe' | 'league-table' | 'accretion-dilution'; interface Slide { /** Slide index (0-based) */ index: number; /** Slide type */ type: SlideType; /** Slide data for template rendering */ data: SlideData$1; /** CSS classes to apply */ classes?: string[]; /** Custom styles */ styles?: Record; /** Speaker notes */ notes?: string; } interface SlideData$1 { /** Main title */ title?: string; /** Subtitle */ subtitle?: string; /** Body content */ body?: string; /** Bullet points */ bullets?: string[]; /** Key message */ keyMessage?: string; /** Images */ images?: ImageData[]; /** Metrics/KPIs */ metrics?: MetricData[]; /** Quote text */ quote?: string; /** Quote attribution */ attribution?: string; /** Source citation */ source?: 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'; } /** Legacy slide format for backwards compatibility */ interface LegacySlide { index: number; type: string; title: string; content: { subtitle?: string | undefined; statement?: string | undefined; body?: string | undefined; bullets?: string[] | undefined; metrics?: MetricData[] | undefined; quote?: { text: string; attribution?: string | undefined; } | undefined; callToAction?: string | undefined; }; notes?: string | undefined; template: string; } interface QAResults { /** Visual quality results */ visual: VisualQAResults; /** Content quality results */ content: ContentQAResults; /** Expert methodology compliance */ expert: ExpertQAResults; /** Accessibility compliance */ accessibility: AccessibilityResults; /** Overall pass/fail */ passed: boolean; /** List of issues found */ issues: QAIssue[]; /** Per-slide scores from visual QA */ slideScores?: SlideScore$1[]; /** Overall QA score */ score?: number; /** QA status */ status?: string; } interface SlideScore$1 { /** Slide index */ index: number; /** Slide type */ type: string; /** Score 0-100 */ score: number; /** Expert verdict */ expertVerdict?: string; /** Critical issues found */ criticalIssues?: string[]; /** All issues */ issues?: QAIssue[]; } 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 | undefined; } 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[] | undefined; } interface ExpertQAResults { /** Nancy Duarte validation */ duarte: ExpertValidation; /** Garr Reynolds validation */ reynolds: ExpertValidation; /** Carmine Gallo validation */ gallo: ExpertValidation; /** Chris Anderson validation */ anderson: ExpertValidation; } interface ExpertValidation { expertName: string; principlesChecked: string[]; passed: boolean; score: number; violations: string[]; } interface AccessibilityResults { /** WCAG compliance level achieved */ wcagLevel: 'A' | 'AA' | 'AAA' | 'FAIL'; /** Contrast issues found */ contrastIssues: ContrastIssue[]; /** Font size issues */ fontSizeIssues: FontSizeIssue[]; /** Focus state coverage */ focusCoverage: number; /** Color-blind safety */ colorBlindSafe: boolean; } interface ContrastIssue { slideIndex: number; element: string; foreground: string; background: string; ratio: number; required: number; } interface FontSizeIssue { slideIndex: number; element: string; actualSize: number; minimumSize: number; } interface QAIssue { /** Issue severity */ severity: 'error' | 'warning' | 'info'; /** Issue category */ category: 'visual' | 'content' | 'expert' | 'accessibility'; /** Slide index (if applicable) */ slideIndex?: number; /** Issue description */ message: string; /** Suggested fix */ suggestion?: string; } /** Result from 7-dimension QA scoring */ interface SevenDimensionQAResult { passed: boolean; score: number; visual: { whitespacePercentage: number; layoutBalance: number; colorContrast: number; }; content: { perSlide: SlideContentScore[]; issues: Array<{ dimension: string; message: string; slideIndex?: number; }>; }; accessibility: { wcagLevel: string; issues: Array<{ dimension: string; message: string; slideIndex?: number; }>; }; issues: Array<{ severity: string; message: string; slideIndex?: number; dimension: string; }>; dimensions: Record; iterations: unknown[]; report: string; } interface PresentationResult { /** Generated outputs */ outputs: { html?: string; pptx?: Buffer; pdf?: Buffer; }; /** QA validation results */ qaResults: QAResults; /** Overall QA score (0-100) */ score: number; /** Presentation metadata */ metadata: PresentationMetadata; } interface PresentationMetadata { /** Presentation title */ title: string; /** Author */ author: string; /** Generation timestamp */ generatedAt: string; /** Presentation mode */ mode: PresentationMode; /** Detected/specified presentation type */ presentationType?: PresentationType; /** Total slide count */ slideCount: number; /** Total word count */ wordCount: number; /** Total words (alias for wordCount) */ totalWords?: number; /** Average words per slide */ avgWordsPerSlide: number; /** Estimated presentation duration (minutes) */ estimatedDuration: number; /** Themes/frameworks used */ frameworks: string[]; /** QA iterations used */ qaIterations?: number; /** Max iterations configured */ qaMaxIterations?: number; /** 7-dimension scores */ dimensionScores?: Record; } interface ContentSection { /** Section header text */ header: string; /** Header level (1-6) */ level: number; /** Body content */ content: string; /** Bullet points */ bullets: string[]; /** Metrics extracted from section */ metrics: Array<{ value: string; label: string; context?: string; }>; /** Sub-sections for parent-child patterns (e.g., "Three Pillars" with 3 children) */ subSections?: Array<{ title: string; content: string; }>; } interface ContentAnalysis { /** Detected presentation type */ detectedType: PresentationType; /** Main title */ title: string; /** Subtitle (line after title) */ subtitle?: string; /** Content sections */ sections: ContentSection[]; /** SCQA structure extracted */ scqa: SCQAStructure; /** Sparkline narrative arc */ sparkline: SparklineStructure; /** Key messages identified */ keyMessages: string[]; /** Data points (metrics, percentages, etc.) */ dataPoints: Array<{ value: string; label: string; context?: string; }>; /** Generated action titles */ titles: string[]; /** STAR moments identified */ starMoments: string[]; /** Estimated slide count */ estimatedSlideCount: number; } interface SCQAStructure { situation: string; complication: string; question: string; answer: string; } interface SparklineStructure { whatIs: string[]; whatCouldBe: string[]; callToAdventure: string; } declare class ValidationError extends Error { errors: string[]; readonly suggestions: string[]; constructor(errors: string[], message?: string); private static getSuggestions; } declare class QAFailureError extends Error { score: number; threshold: number; qaResults: QAResults; readonly topIssues: string[]; constructor(score: number, threshold: number, qaResults: QAResults, message?: string); getIssues(): string[]; private static getTopIssues; } declare class TemplateNotFoundError extends Error { templatePath: string; constructor(templatePath: string, message?: string); } declare class KnowledgeBaseError extends Error { field: string; context: string; constructor(field: string, context: string, message?: string); } /** * Content pattern detected from a section * Used to match content to appropriate slide types */ interface ContentPattern { /** Section has a big number ($X, X%, Xx) */ hasBigNumber: boolean; /** Extracted big number value */ bigNumberValue?: string; /** Section has comparison language (vs, before/after) */ hasComparison: boolean; /** Section has timeline markers (Phase, Week, Q1) */ hasTimeline: boolean; /** Section has process/steps (Step 1, Pillar) */ hasProcess: boolean; /** Section has 3+ metrics */ hasMetrics: boolean; /** Section is a quote */ hasQuote: boolean; /** Section has code blocks */ hasCode: boolean; /** Number of bullets in section */ bulletCount: number; /** Word count of section */ wordCount: number; /** Primary detected pattern name */ primaryPattern: 'big_number' | 'comparison' | 'timeline' | 'process' | 'metrics' | 'quote' | 'code' | 'bullets' | 'prose'; } /** * Validation rules from KB for a presentation type */ interface ValidationRules { wordsPerSlide: { min: number; max: number; ideal: number; }; whitespace: { min: number; ideal: number; }; bulletsPerSlide: { max: number; }; slidesPerIdea?: number; actionTitlesRequired: boolean; sourcesRequired: boolean; calloutsRequired?: boolean; denseDataAllowed?: boolean; codeBlocksAllowed?: boolean; diagramsRequired?: boolean; } /** * Typography specifications from KB */ interface TypographyRules { titles: string; body: string; maxFonts: number; actionTitle?: string; sectionHeaders?: string; dataLabels?: string; code?: string; } /** * Scoring weights from KB for QA */ interface ScoringWeights { visualQuality: number; contentQuality: number; expertCompliance: number; accessibility: number; } /** * Result of validating a slide against KB rules */ interface SlideValidationResult { valid: boolean; violations: string[]; warnings: string[]; wordCount: number; bulletCount: number; slideType: string; } /** * Story structure from KB */ interface StoryStructure { framework: 'scqa' | 'sparkline' | 'pyramid' | 'hero_journey'; requiredElements: string[]; optionalElements: string[]; antiPatterns: string[]; } /** * KBQueryEngine - Central interface for all Knowledge Base queries * * PRINCIPLE: Every decision comes from the KB. No hardcoded fallbacks. * If KB doesn't have the data, the operation fails with a clear error. */ interface ColorPalette { primary: string; secondary: string; accent: string; background: string; text: string; textSecondary: string; border: string; chartColors: string[]; cardBackground: string; rangeBackground: string; fitHigh: string; fitMedium: string; fitLow: string; } interface TypographySpec { fontFamily: string; titleSize: string; headingSize: string; subheadingSize: string; bodySize: string; footnoteSize: string; lineHeight: string; maxWordsPerSlide: number; } interface LayoutSpec { slideWidth: string; slideHeight: string; margins: string; titleZoneHeight: string; footerZoneHeight: string; contentPadding: string; gridColumns: number; gutterWidth: string; highlightNumberSize: string; methodologyRowHeight: string; methodLabelWidth: string; rangeBarHeight: string; phaseMinWidth: string; borderRadius: string; } interface StructureSpec { sections: Array<{ name: string; slideCount: string; description: string; }>; narrativeArc: string; } interface ParsingRules { patterns: Array<{ name: string; regex: string; extractFields: string[]; }>; categoryDetection: Record; } interface QualityCriteria { clarity: string; evidence: string; visualHierarchy: string; consistency: string; precision: string; professionalism: string; actionable: string; tailored: string; } interface SlideTemplate { html: string; css: string; } declare class KBMissingError extends Error { constructor(message: string); } declare class KBQueryEngine { private client; private cache; private cacheTimeout; private connected; constructor(); connect(): Promise; disconnect(): Promise; private getCached; private setCache; /** * Raw KB query - returns content from matching entries */ query(idPattern: string, sourceFilter?: string): Promise; /** * Semantic search using HNSW vector similarity * Uses the kb_embed() helper function for proper ruvector casting */ semanticSearch(queryText: string, limit?: number, sourceFilter?: string): Promise>; /** * Get first content from query or throw error */ private getFirstContent; /** * Get presentation structure for a specific type */ getStructure(presentationType: string): Promise; /** * Get color palette from KB */ getColorPalette(style?: string): Promise; private tryParseColor; /** * Get typography specifications from KB - NO FALLBACKS */ getTypography(style?: string): Promise; /** * Get layout specifications from KB - NO FALLBACKS */ getLayout(slideType?: string): Promise; /** * Get CSS template from KB */ getCSSTemplate(style?: string): Promise; /** * Get HTML template for a specific slide type */ getHTMLTemplate(slideType: string): Promise; /** * Get slide type specifications from KB */ getSlideTypeSpec(slideType: string): Promise; /** * Get parsing rules from KB */ getParsingRules(contentType: string): Promise; /** * Get quality criteria from KB */ getQualityCriteria(): Promise; /** * Get all KB entries for a source */ listEntries(source: string): Promise>; /** * Verify KB has all required entries for a presentation type */ verifyKBCompleteness(presentationType: string): Promise<{ complete: boolean; missing: string[]; }>; } /** * KBSlideGenerator - Generates slides 100% from Knowledge Base * * PRINCIPLE: Every design decision, template, and style comes from KB. * Zero hardcoded values. If KB is missing data, we fail explicitly. */ interface SlideData { type: string; title: string; subtitle?: string; content: Record; metadata?: Record; } interface GeneratedSlide { html: string; slideNumber: number; type: string; title: string; qualityScore?: number | undefined; issues?: string[] | undefined; } interface GeneratedDeck { html: string; slides: GeneratedSlide[]; css: string; metadata: { totalSlides: number; generatedAt: string; kbVersion: string; qualityScore: number; }; } declare class KBSlideGenerator { private kb; private colors; private typography; private layout; private css; private contentEnhancer; private advancedLayouts; constructor(kb?: KBQueryEngine); initialize(): Promise; generateDeck(content: string, presentationType: string): Promise; private parseContent; private determineSlideType; private extractSlideContent; private extractExecutiveSummary; private extractInvestmentHighlights; private extractFootballField; private extractBuyerUniverse; private extractProcessTimeline; private extractCredentials; private extractBullets; private extractCompanyOverview; private extractMarketAnalysis; private extractMetricValue; private extractFinancialSummary; private extractFinancialProjections; private extractManagementTeam; private extractGrowthDrivers; private extractRiskFactors; private extractCompsAnalysis; private extractTransactionStructure; private extractSourcesUses; private extractSynergyAnalysis; private extractNextSteps; private extractAppendix; private generateSlide; private renderTemplate; private generateSlideHtml; private genExecSummary; private genHighlights; private genFootball; private genBuyers; private genTimeline; private genCredentials; private genBullets; private genCompanyOverview; private genMarketAnalysis; private genFinancialSummary; private genFinancialProjections; private genManagementTeam; private genGrowthDrivers; private genRiskFactors; private genCompsAnalysis; private genTransactionStructure; private genSourcesUses; private genSynergyAnalysis; private genNextSteps; private genAppendix; private calculateSlideQuality; private calculateDeckQuality; private assembleDeck; private generateDynamicCSS; private escapeHtml; cleanup(): Promise; } /** * VisualVerifier - Screenshots and verifies presentation quality * * Uses Playwright to render each slide, capture screenshots, * and detect visual quality issues. */ interface VerificationResult { slideNumber: number; screenshotPath: string; issues: string[]; score: number; } interface DeckVerificationResult { slides: VerificationResult[]; overallScore: number; totalIssues: number; passed: boolean; screenshotsDir: string; } declare class VisualVerifier { private browser; private page; /** * Initialize the browser */ initialize(): Promise; /** * Verify an HTML presentation file */ verifyPresentation(htmlPath: string, outputDir: string): Promise; /** * Analyze a single slide for quality issues */ private analyzeSlide; /** * Generate a verification report */ generateReport(result: DeckVerificationResult): string; /** * Cleanup resources */ cleanup(): Promise; } /** * ChartGenerator - Real SVG chart generation for world-class presentations * * Generates actual SVG visualizations, not HTML div approximations. */ interface FootballFieldData { methodologies: Array<{ name: string; low: number; high: number; color: string; }>; currentPrice?: number; } interface BarChartData { labels: string[]; datasets: Array<{ label: string; data: number[]; color: string; }>; } interface WaterfallData { items: Array<{ label: string; value: number; isTotal?: boolean; }>; colors: { positive: string; negative: string; total: string; }; } interface PieChartData { segments: Array<{ label: string; value: number; color: string; }>; } declare class ChartGenerator { private width; private height; private padding; private fontFamily; private fontSize; constructor(options?: { width?: number; height?: number; padding?: number; fontFamily?: string; fontSize?: number; }); /** * Generate a football field valuation chart (horizontal range bars) */ generateFootballField(data: FootballFieldData): string; /** * Generate a bar chart (vertical bars) */ generateBarChart(data: BarChartData): string; /** * Generate a waterfall chart */ generateWaterfallChart(data: WaterfallData): string; /** * Generate a pie/donut chart */ generatePieChart(data: PieChartData, donut?: boolean): string; private emptyChart; private formatValue; private escapeXml; } /** * PPTXGenerator - PowerPoint export for world-class IB presentations * * Uses pptxgenjs to create native PPTX files that IB clients expect. */ interface SlideContent { type: string; title: string; content: Record; } interface PPTXOptions { title?: string; subject?: string; author?: string; company?: string; colors?: { primary: string; secondary: string; accent: string; background: string; text: string; }; fontSize?: { title: number; heading: number; body: number; footnote: number; }; } declare class PPTXGenerator { private pptx; private colors; private fontSize; constructor(options?: PPTXOptions); /** * Generate slides from content array */ generateSlides(slides: SlideContent[]): void; private renderSlide; private addTitle; private renderExecutiveSummary; private renderCompanyOverview; private renderHighlights; private renderMarketAnalysis; private renderFinancialSummary; private renderFinancialProjections; private renderManagementTeam; private renderGrowthDrivers; private renderRiskFactors; private renderFootballField; private renderCompsAnalysis; private renderBuyerUniverse; private renderTimeline; private renderTransactionStructure; private renderSourcesUses; private renderSynergyAnalysis; private renderCredentials; private renderNextSteps; private renderAppendix; private renderBullets; /** * Export to PPTX buffer */ toBuffer(): Promise; /** * Export to PPTX file */ toFile(filepath: string): Promise; /** * Export to base64 string */ toBase64(): Promise; } /** * ContentEnhancer - AI-powered content suggestions and smart extraction * * Provides intelligent defaults, content scoring, and recommendations * to transform raw markdown into world-class IB presentation content. */ interface ContentSuggestion { field: string; suggestedValue: string | number | string[]; confidence: number; reason: string; } interface EnhancedContent { original: string; enhanced: Record; suggestions: ContentSuggestion[]; qualityScore: number; missingFields: string[]; } interface MetricExtraction { value: number; unit: string; label: string; context: string; } interface EntityExtraction { companies: string[]; people: string[]; amounts: MetricExtraction[]; percentages: MetricExtraction[]; dates: string[]; multiples: MetricExtraction[]; } declare class ContentEnhancer { /** * Extract all entities and metrics from content */ extractEntities(content: string): EntityExtraction; /** * Get context around a match position */ private getContext; /** * Infer what a percentage refers to based on context */ private inferPercentageLabel; /** * Enhance content with smart defaults and suggestions */ enhance(content: string, slideType: string): EnhancedContent; /** * Check if content has data for a required field */ private hasFieldContent; /** * Suggest a value for a missing field */ private suggestFieldValue; /** * Format large numbers with appropriate suffix */ private formatNumber; /** * Calculate quality score based on completeness */ private calculateQualityScore; /** * Generate content recommendations */ generateRecommendations(content: string, slideType: string): string[]; /** * Auto-format currency values consistently */ formatCurrency(content: string): string; /** * Extract and structure key metrics from content */ extractKeyMetrics(content: string): Array<{ label: string; value: string; trend?: string; }>; /** * Extract trend information (YoY, etc.) */ private extractTrend; } /** * QualityEnhancer - KB-Driven Slide Quality Enhancement * * This module reviews and enhances slides using KB knowledge: * - Applies psychology principles (Cialdini, Kahneman) * - Checks against common mistakes * - Enhances storytelling and emotional arc * - Ensures world-class quality standards */ interface QualityIssue { type: 'critical' | 'warning' | 'suggestion'; category: string; message: string; slide?: number; fix?: string; } interface EnhancementSuggestion { slide: number; original: string; enhanced: string; principle: string; impact: string; } interface QualityReport { overallScore: number; issues: QualityIssue[]; suggestions: EnhancementSuggestion[]; storytellingArc: { detected: string; optimal: string; adjustment?: string; }; emotionalJourney: { peaks: number[]; valleys: number[]; recommendation?: string; }; persuasionScore: number; visualScore: number; clarityScore: number; } declare class QualityEnhancer { private kb; constructor(kb?: KBQueryEngine); /** * Run comprehensive quality analysis on a deck */ analyzeDeck(slides: Array<{ type: string; title: string; content: string; html: string; }>): Promise; /** * Check slide against KB mistake patterns */ private checkSlideAgainstMistakes; /** * Generate enhancement suggestions using KB psychology/persuasion patterns */ private generateEnhancements; /** * Analyze storytelling arc against KB patterns */ private analyzeStorytellingArc; /** * Map emotional journey through presentation */ private mapEmotionalJourney; /** * Calculate persuasion score based on Cialdini principles + business psychology * * This is the CORE of business-focused presentation effectiveness. * Draws from: Cialdini, Kahneman, McKinsey communication, Goldman Sachs style */ private calculatePersuasionScore; /** * Calculate visual design score */ private calculateVisualScore; /** * Calculate clarity score */ private calculateClarityScore; /** * Generate improvement recommendations report */ generateReport(analysis: QualityReport): string; } /** * ReportGenerator - Generates comprehensive design rationale and scoring reports * * SYSTEMATIC OUTPUT: Every presentation generation includes: * 1. DESIGN_RATIONALE.md - Why each design decision was made * 2. SCORING_REPORT.md - Comprehensive quality evaluation * * This ensures full transparency on: * - What was selected and why * - KB sources for each decision * - Logic behind each choice * - How KB queries enhanced the output */ interface DesignDecision { area: string; decision: string; rationale: string; kbSource: string | null; kbQuery: string | null; alternativesConsidered: string[]; } interface SlideScore { slideNumber: number; title: string; type: string; wordCount: number; bulletCount: number; hasChart: boolean; hasTable: boolean; score: number; issues: string[]; } interface ComprehensiveReport { designRationale: string; scoringReport: string; decisions: DesignDecision[]; slideScores: SlideScore[]; overallScore: number; } declare class ReportGenerator { private decisions; private slideScores; private presentationType; private timestamp; constructor(); /** * Record a design decision for the rationale document */ recordDecision(decision: DesignDecision): void; /** * Set the presentation type for context */ setPresentationType(type: string): void; /** * Score all slides and record results */ scoreSlides(slides: GeneratedSlide[]): SlideScore[]; /** * Generate the Design Rationale markdown document */ generateDesignRationale(deck: GeneratedDeck): string; /** * Generate the Comprehensive Scoring Report markdown document */ generateScoringReport(deck: GeneratedDeck, qualityReport: QualityReport | undefined): string; /** * Generate all reports and return comprehensive output */ generateAllReports(deck: GeneratedDeck, qualityReport: QualityReport | undefined): ComprehensiveReport; } declare function getDefaultIBDecisions(): DesignDecision[]; /** * AdvancedLayouts - Goldman/Morgan-level presentation layouts * * Professional IB layouts with multi-column structures, nested charts, * sophisticated visual hierarchy, and pixel-perfect typography. */ interface LayoutConfig { columns?: 1 | 2 | 3 | 4; gutter?: number; padding?: number; aspectRatio?: '16:9' | '4:3'; } interface ComponentConfig { type: 'chart' | 'table' | 'metric' | 'text' | 'callout' | 'logo'; width: string; height?: string; position?: { x: number; y: number; }; data?: Record; } interface SlideLayout { name: string; description: string; grid: string; components: ComponentConfig[]; css: string; } /** * Goldman/Morgan-level layout templates */ declare const PROFESSIONAL_LAYOUTS: Record; /** * Generate CSS for all professional layouts */ declare function generateLayoutCSS(): string; /** * Get layout configuration for a slide type */ declare function getLayoutForSlideType(slideType: string): SlideLayout | null; /** * AdvancedLayouts class for generating professional slide HTML */ declare class AdvancedLayouts { private colors; constructor(colors?: Record); /** * Generate executive hero layout HTML */ generateExecutiveHero(metrics: Array<{ value: string; label: string; trend?: string; }>, keyPoints: string[], recommendation?: { title: string; text: string; }): string; /** * Generate KPI dashboard layout HTML */ generateKPIDashboard(kpis: Array<{ label: string; value: string; trend?: string; trendDirection?: 'positive' | 'negative'; }>): string; /** * Generate buyer matrix layout HTML */ generateBuyerMatrix(strategicBuyers: Array<{ name: string; rationale: string; fit: 'high' | 'medium' | 'low'; synergy?: string; }>, financialBuyers: Array<{ name: string; rationale: string; fit: 'high' | 'medium' | 'low'; focus?: string; }>): string; /** * Generate synergy breakdown layout HTML */ generateSynergyBreakdown(totalSynergies: string, costSynergies: Array<{ name: string; value: string; confidence?: 'high' | 'medium' | 'low'; }>, revenueSynergies: Array<{ name: string; value: string; confidence?: 'high' | 'medium' | 'low'; }>): string; /** * Escape HTML special characters */ private escapeHtml; } /** * Claude Presentation Master - KB-Driven Architecture * * 100% Knowledge Base driven presentation generation. * Every design decision, template, and style comes from the KB. * Zero hardcoded values. * * @packageDocumentation * @module claude-presentation-master * @version 11.0.0 */ interface GenerateConfig { content: string; presentationType?: string; outputPath?: string; verify?: boolean; screenshotDir?: string; /** Enable KB-powered quality enhancement and persuasion analysis */ enhance?: boolean; /** Business-focused mode: Maximize persuasion, credibility, and executive appeal */ businessFocus?: boolean; } interface GenerateResult { deck: GeneratedDeck; htmlPath: string; verification?: DeckVerificationResult | undefined; /** KB-powered quality analysis with persuasion scoring */ qualityReport?: QualityReport | undefined; /** Comprehensive design rationale and scoring report */ comprehensiveReport?: ComprehensiveReport | undefined; /** Path to DESIGN_RATIONALE.md */ designRationalePath?: string; /** Path to SCORING_REPORT.md */ scoringReportPath?: string; passed: boolean; } /** * Generate a KB-driven presentation. * * @example * ```typescript * import { generate } from 'claude-presentation-master'; * * const result = await generate({ * content: '## Executive Summary\n...', * presentationType: 'sellside_ma', * outputPath: './output', * verify: true * }); * * console.log(`Score: ${result.deck.metadata.qualityScore}/100`); * console.log(`HTML: ${result.htmlPath}`); * ``` */ declare function generate(config: GenerateConfig): Promise; /** * Verify an existing presentation. * * @example * ```typescript * import { verify } from 'claude-presentation-master'; * * const result = await verify('./presentation.html', './screenshots'); * console.log(`Score: ${result.overallScore}/100`); * console.log(`Passed: ${result.passed}`); * ``` */ declare function verify(htmlPath: string, screenshotDir?: string): Promise; /** * Check KB completeness for a presentation type. * * @example * ```typescript * import { checkKB } from 'claude-presentation-master'; * * const result = await checkKB('sellside_ma'); * if (!result.complete) { * console.log('Missing KB entries:', result.missing); * } * ``` */ declare function checkKB(presentationType: string): Promise<{ complete: boolean; missing: string[]; }>; /** * Generate PDF from an HTML presentation. * * @example * ```typescript * import { generatePDF } from 'claude-presentation-master'; * * const pdfPath = await generatePDF('./presentation.html', './output/presentation.pdf'); * console.log(`PDF saved to: ${pdfPath}`); * ``` */ declare function generatePDF(htmlPath: string, outputPath: string, options?: { format?: 'A4' | 'Letter' | 'Legal' | 'Tabloid'; landscape?: boolean; printBackground?: boolean; }): Promise; /** * Generate full presentation with PDF output. * * @example * ```typescript * import { generateWithPDF } from 'claude-presentation-master'; * * const result = await generateWithPDF({ * content: '## Executive Summary\n...', * outputPath: './output' * }); * console.log(`PDF: ${result.pdfPath}`); * ``` */ declare function generateWithPDF(config: GenerateConfig & { pdfOptions?: Parameters[2]; }): Promise; /** * Generate PPTX presentation (native PowerPoint). */ declare function generatePPTX(config: GenerateConfig & { pptxOptions?: { title?: string; author?: string; company?: string; }; }): Promise; /** * Generate SVG chart directly. */ declare function generateChart(type: 'footballField' | 'bar' | 'waterfall' | 'pie', data: FootballFieldData | BarChartData | WaterfallData | PieChartData, options?: { width?: number; height?: number; }): string; /** * Package version - KB-First Architecture with Systematic Reporting */ declare const VERSION = "13.0.0"; /** * Default export for convenience. */ declare const _default: { generate: typeof generate; generatePDF: typeof generatePDF; generatePPTX: typeof generatePPTX; generateWithPDF: typeof generateWithPDF; generateChart: typeof generateChart; verify: typeof verify; checkKB: typeof checkKB; KBQueryEngine: typeof KBQueryEngine; KBSlideGenerator: typeof KBSlideGenerator; PPTXGenerator: typeof PPTXGenerator; ChartGenerator: typeof ChartGenerator; VisualVerifier: typeof VisualVerifier; QualityEnhancer: typeof QualityEnhancer; ReportGenerator: typeof ReportGenerator; getDefaultIBDecisions: typeof getDefaultIBDecisions; VERSION: string; }; export { type AccessibilityResults, AdvancedLayouts, type BarChartData, ChartGenerator, type ColorPalette, type ComponentConfig, type ComprehensiveReport, type ContentAnalysis, ContentEnhancer, type ContentPattern, type ContentQAResults, type ContentSection, type ContentSuggestion, type ContrastIssue, type DeckVerificationResult, type DesignDecision, type EnhancedContent, type EnhancementSuggestion, type EntityExtraction, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type FootballFieldData, type GenerateConfig, type GenerateResult, type GeneratedDeck, type GeneratedSlide, type GlanceTestResult, type ImageData, KBMissingError, KBQueryEngine, KBSlideGenerator, KnowledgeBaseError, type LayoutConfig, type LayoutSpec, type LegacySlide, type MetricData, type MetricExtraction, type OneIdeaResult, type OutputFormat, PPTXGenerator, type PPTXOptions, PROFESSIONAL_LAYOUTS, type ParsingRules, type PieChartData, type PresentationConfig, type PresentationMetadata, type PresentationMode, type PresentationResult, type PresentationType, QAFailureError, type QAIssue, type QAResults, type QualityCriteria, QualityEnhancer, type QualityIssue, type QualityReport, ReportGenerator, type SCQAStructure, type ScoringWeights, type SevenDimensionQAResult, type SignalNoiseResult, type Slide, type SlideContent, type SlideContentScore, type SlideData, type SlideLayout, type SlideScore, type SlideTemplate, type SlideType, type SlideValidationResult, type SlideVisualScore, type SparklineStructure, type StoryStructure, type StructureSpec, TemplateNotFoundError, type ThemeName, type TypographyRules, type TypographySpec, VERSION, ValidationError, type ValidationRules, type VerificationResult, type VisualQAResults, VisualVerifier, type WaterfallData, checkKB, _default as default, generate, generateChart, generateLayoutCSS, generatePDF, generatePPTX, generateWithPDF, getDefaultIBDecisions, getLayoutForSlideType, verify };