@ncukondo/slide-generation 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,999 @@
+import { z, ZodTypeAny } from 'zod';
+
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+    theme: z.ZodDefault<z.ZodString>;
+    references: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        style: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        style: string;
+    }, {
+        enabled?: boolean | undefined;
+        style?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    theme: string;
+    author?: string | undefined;
+    date?: string | undefined;
+    references?: {
+        enabled: boolean;
+        style: string;
+    } | undefined;
+}, {
+    title: string;
+    author?: string | undefined;
+    date?: string | undefined;
+    theme?: string | undefined;
+    references?: {
+        enabled?: boolean | undefined;
+        style?: string | undefined;
+    } | undefined;
+}>;
+declare const slideSchema: z.ZodObject<{
+    template: z.ZodString;
+    content: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    class: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    raw: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    template: string;
+    content: Record<string, unknown>;
+    class?: string | undefined;
+    notes?: string | undefined;
+    raw?: string | undefined;
+}, {
+    template: string;
+    content?: Record<string, unknown> | undefined;
+    class?: string | undefined;
+    notes?: string | undefined;
+    raw?: string | undefined;
+}>;
+declare const presentationSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        author: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        theme: z.ZodDefault<z.ZodString>;
+        references: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            style: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            style: string;
+        }, {
+            enabled?: boolean | undefined;
+            style?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        theme: string;
+        author?: string | undefined;
+        date?: string | undefined;
+        references?: {
+            enabled: boolean;
+            style: string;
+        } | undefined;
+    }, {
+        title: string;
+        author?: string | undefined;
+        date?: string | undefined;
+        theme?: string | undefined;
+        references?: {
+            enabled?: boolean | undefined;
+            style?: string | undefined;
+        } | undefined;
+    }>;
+    slides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        template: z.ZodString;
+        content: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        class: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        template: string;
+        content: Record<string, unknown>;
+        class?: string | undefined;
+        notes?: string | undefined;
+        raw?: string | undefined;
+    }, {
+        template: string;
+        content?: Record<string, unknown> | undefined;
+        class?: string | undefined;
+        notes?: string | undefined;
+        raw?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    meta: {
+        title: string;
+        theme: string;
+        author?: string | undefined;
+        date?: string | undefined;
+        references?: {
+            enabled: boolean;
+            style: string;
+        } | undefined;
+    };
+    slides: {
+        template: string;
+        content: Record<string, unknown>;
+        class?: string | undefined;
+        notes?: string | undefined;
+        raw?: string | undefined;
+    }[];
+}, {
+    meta: {
+        title: string;
+        author?: string | undefined;
+        date?: string | undefined;
+        theme?: string | undefined;
+        references?: {
+            enabled?: boolean | undefined;
+            style?: string | undefined;
+        } | undefined;
+    };
+    slides?: {
+        template: string;
+        content?: Record<string, unknown> | undefined;
+        class?: string | undefined;
+        notes?: string | undefined;
+        raw?: string | undefined;
+    }[] | undefined;
+}>;
+type PresentationMeta = z.infer<typeof metaSchema>;
+type ParsedSlide = z.infer<typeof slideSchema>;
+type ParsedPresentation = z.infer<typeof presentationSchema>;
+declare class ParseError extends Error {
+    details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}
+declare class ValidationError extends Error {
+    details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}
+declare class Parser {
+    parse(yamlContent: string): ParsedPresentation;
+    parseFile(filePath: string): Promise<ParsedPresentation>;
+}
+
+/**
+ * Icons helper interface for template rendering
+ */
+interface IconsHelper {
+    render: (name: string, options?: Record<string, unknown>) => string;
+}
+/**
+ * References helper interface for citation handling
+ */
+interface RefsHelper {
+    cite: (id: string) => string;
+    expand: (text: string) => string;
+}
+/**
+ * Slide context passed to templates
+ */
+interface SlideContext {
+    index: number;
+    total: number;
+}
+/**
+ * Meta context for presentation metadata
+ */
+interface MetaContext {
+    title: string;
+    author?: string;
+    theme: string;
+    [key: string]: unknown;
+}
+/**
+ * Full template context interface
+ */
+interface TemplateContext {
+    content: Record<string, unknown>;
+    meta: MetaContext;
+    slide: SlideContext;
+    icons: IconsHelper;
+    refs: RefsHelper;
+    [key: string]: unknown;
+}
+declare class TemplateEngine {
+    private env;
+    constructor();
+    render(template: string, context: Record<string, unknown>): string;
+    private registerFilters;
+    private registerGlobals;
+}
+
+/**
+ * JSON Schema type definition (subset used by templates)
+ */
+interface JsonSchema {
+    type?: string;
+    required?: string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    pattern?: string;
+    enum?: (string | number | boolean)[];
+    default?: unknown;
+    description?: string;
+    oneOf?: JsonSchema[];
+}
+/**
+ * Validation result for content against template schema
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Convert a JSON Schema object to a Zod schema
+ *
+ * Supports a subset of JSON Schema used by template definitions:
+ * - Basic types: string, number, boolean, array, object
+ * - Required fields
+ * - Nested objects and arrays
+ * - Pattern validation for strings
+ * - minItems/maxItems for arrays
+ */
+declare function jsonSchemaToZod(schema: JsonSchema): ZodTypeAny;
+/**
+ * Validate content against a JSON Schema
+ */
+declare function validateWithJsonSchema(schema: JsonSchema, content: unknown): ValidationResult;
+
+/**
+ * Template definition schema - validates YAML template definition files
+ */
+declare const templateDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    example: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodString;
+    css: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    category: string;
+    schema: Record<string, unknown>;
+    output: string;
+    example?: Record<string, unknown> | undefined;
+    css?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    category: string;
+    schema: Record<string, unknown>;
+    output: string;
+    example?: Record<string, unknown> | undefined;
+    css?: string | undefined;
+}>;
+/**
+ * Template definition type derived from schema
+ */
+type TemplateDefinition = z.infer<typeof templateDefSchema>;
+/**
+ * Loads and manages template definitions from YAML files
+ */
+declare class TemplateLoader {
+    private templates;
+    constructor();
+    /**
+     * Load a template from a YAML string
+     */
+    loadFromString(yamlContent: string): Promise<void>;
+    /**
+     * Load a template from a file
+     */
+    loadFromFile(filePath: string): Promise<void>;
+    /**
+     * Load all templates from a directory (recursively)
+     */
+    loadBuiltIn(directory: string): Promise<void>;
+    /**
+     * Load custom templates from a directory (can override built-in)
+     */
+    loadCustom(directory: string): Promise<void>;
+    /**
+     * Internal method to load templates from a directory
+     */
+    private loadDirectory;
+    /**
+     * Get a template by name
+     */
+    get(name: string): TemplateDefinition | undefined;
+    /**
+     * List all loaded templates
+     */
+    list(): TemplateDefinition[];
+    /**
+     * List templates filtered by category
+     */
+    listByCategory(category: string): TemplateDefinition[];
+    /**
+     * Validate content against a template's schema
+     */
+    validateContent(templateName: string, content: unknown): ValidationResult;
+}
+
+/**
+ * Schema for individual icon source definition
+ */
+declare const iconSourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["web-font", "svg-inline", "svg-sprite", "local-svg"]>;
+    prefix: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    render: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+    name: string;
+    prefix: string;
+    path?: string | undefined;
+    url?: string | undefined;
+    render?: string | undefined;
+}, {
+    type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+    name: string;
+    prefix: string;
+    path?: string | undefined;
+    url?: string | undefined;
+    render?: string | undefined;
+}>;
+type IconSource = z.infer<typeof iconSourceSchema>;
+/**
+ * Schema for icon defaults
+ */
+declare const iconDefaultsSchema: z.ZodObject<{
+    size: z.ZodDefault<z.ZodString>;
+    color: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    size: string;
+    color: string;
+}, {
+    size?: string | undefined;
+    color?: string | undefined;
+}>;
+type IconDefaults = z.infer<typeof iconDefaultsSchema>;
+/**
+ * Schema for the full icon registry configuration
+ */
+declare const iconRegistrySchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["web-font", "svg-inline", "svg-sprite", "local-svg"]>;
+        prefix: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        render: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+        name: string;
+        prefix: string;
+        path?: string | undefined;
+        url?: string | undefined;
+        render?: string | undefined;
+    }, {
+        type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+        name: string;
+        prefix: string;
+        path?: string | undefined;
+        url?: string | undefined;
+        render?: string | undefined;
+    }>, "many">;
+    aliases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    colors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaults: z.ZodDefault<z.ZodObject<{
+        size: z.ZodDefault<z.ZodString>;
+        color: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        size: string;
+        color: string;
+    }, {
+        size?: string | undefined;
+        color?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sources: {
+        type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+        name: string;
+        prefix: string;
+        path?: string | undefined;
+        url?: string | undefined;
+        render?: string | undefined;
+    }[];
+    aliases: Record<string, string>;
+    defaults: {
+        size: string;
+        color: string;
+    };
+    colors?: Record<string, string> | undefined;
+}, {
+    sources: {
+        type: "web-font" | "svg-inline" | "svg-sprite" | "local-svg";
+        name: string;
+        prefix: string;
+        path?: string | undefined;
+        url?: string | undefined;
+        render?: string | undefined;
+    }[];
+    aliases?: Record<string, string> | undefined;
+    colors?: Record<string, string> | undefined;
+    defaults?: {
+        size?: string | undefined;
+        color?: string | undefined;
+    } | undefined;
+}>;
+type IconRegistry = z.infer<typeof iconRegistrySchema>;
+
+/**
+ * Parsed icon reference with prefix and name
+ */
+interface ParsedIconReference {
+    prefix: string;
+    name: string;
+}
+/**
+ * Icon Registry Loader - loads and manages icon registry configuration
+ */
+declare class IconRegistryLoader {
+    private registry;
+    private sourcesByPrefix;
+    private aliasMap;
+    private colorMap;
+    /**
+     * Load registry from YAML file
+     */
+    load(configPath: string): Promise<IconRegistry>;
+    /**
+     * Resolve an alias to its icon reference
+     * @returns The resolved icon reference or the original name if not an alias
+     */
+    resolveAlias(nameOrAlias: string): string;
+    /**
+     * Get icon source by prefix
+     */
+    getSource(prefix: string): IconSource | undefined;
+    /**
+     * Parse an icon reference string (e.g., "mi:home" or "iconify:mdi:account")
+     * @returns Parsed reference or null if invalid format
+     */
+    parseIconReference(reference: string): ParsedIconReference | null;
+    /**
+     * Get registry defaults
+     */
+    getDefaults(): IconDefaults;
+    /**
+     * Get color by name from color palette
+     */
+    getColor(name: string): string | undefined;
+    /**
+     * Get all sources
+     */
+    getSources(): IconSource[];
+    /**
+     * Get all aliases
+     */
+    getAliases(): Record<string, string>;
+    /**
+     * Check if registry is loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Build internal lookup maps from registry
+     */
+    private buildMaps;
+}
+
+/**
+ * Options for rendering an icon
+ */
+interface IconOptions {
+    size?: string;
+    color?: string;
+    class?: string;
+}
+/**
+ * Icon Resolver - renders icons from various sources
+ */
+declare class IconResolver {
+    private registry;
+    private nunjucksEnv;
+    constructor(registry: IconRegistryLoader);
+    /**
+     * Render an icon by name or alias
+     */
+    render(nameOrAlias: string, options?: IconOptions): Promise<string>;
+    /**
+     * Render a web-font icon
+     */
+    private renderWebFont;
+    /**
+     * Render a local SVG icon
+     */
+    private renderLocalSvg;
+    /**
+     * Render an SVG from external URL (placeholder without cache)
+     */
+    private renderSvgInline;
+    /**
+     * Render an SVG sprite reference
+     */
+    private renderSvgSprite;
+    /**
+     * Process SVG content and apply options
+     */
+    private processSvg;
+    /**
+     * Build CSS style string
+     */
+    private buildStyle;
+    /**
+     * Build class name string
+     */
+    private buildClassName;
+}
+
+interface CSLAuthor {
+    family: string;
+    given?: string;
+}
+interface CSLItem {
+    id: string;
+    author?: CSLAuthor[];
+    issued?: {
+        'date-parts': number[][];
+    };
+    title?: string;
+    DOI?: string;
+    PMID?: string;
+    'container-title'?: string;
+    volume?: string;
+    issue?: string;
+    page?: string;
+    URL?: string;
+    type?: string;
+}
+/**
+ * Client for reference-manager CLI
+ */
+declare class ReferenceManager {
+    private command;
+    constructor(command?: string);
+    /**
+     * Check if reference-manager CLI is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get all references from the library
+     */
+    getAll(): Promise<CSLItem[]>;
+    /**
+     * Get a single reference by ID
+     */
+    getById(id: string): Promise<CSLItem | null>;
+    /**
+     * Get multiple references by IDs
+     */
+    getByIds(ids: string[]): Promise<Map<string, CSLItem>>;
+    private execCommand;
+    private parseJSON;
+}
+
+interface FormatterConfig {
+    author?: {
+        maxAuthors?: number;
+        etAl?: string;
+        etAlJa?: string;
+        separatorJa?: string;
+    };
+    inline?: {
+        authorSep?: string;
+        identifierSep?: string;
+        multiSep?: string;
+    };
+}
+/**
+ * Formats citations for inline display and bibliography generation
+ */
+declare class CitationFormatter {
+    private manager;
+    private config;
+    constructor(manager: ReferenceManager, config?: FormatterConfig);
+    /**
+     * Format an inline citation
+     * e.g., "(Smith et al., 2024; PMID: 12345678)"
+     */
+    formatInline(id: string): Promise<string>;
+    /**
+     * Format a full bibliography citation
+     */
+    formatFull(id: string): Promise<string>;
+    /**
+     * Expand all citations in text
+     * e.g., "[@smith2024]" -> "(Smith et al., 2024; PMID: 12345678)"
+     */
+    expandCitations(text: string): Promise<string>;
+    /**
+     * Generate bibliography entries
+     */
+    generateBibliography(ids: string[], sort?: 'author' | 'year' | 'citation-order'): Promise<string[]>;
+    private formatInlineItem;
+    private formatFullItem;
+    private formatAuthorInline;
+    private formatAuthorsFull;
+    private isJapaneseAuthors;
+    private getFirstAuthorFamily;
+    private getYear;
+    private getIdentifier;
+}
+
+/**
+ * Context passed to each slide transformation
+ */
+interface TransformContext {
+    meta: PresentationMeta;
+    slideIndex: number;
+    totalSlides: number;
+}
+/**
+ * Error thrown when transformation fails
+ */
+declare class TransformError extends Error {
+    slide?: ParsedSlide | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, slide?: ParsedSlide | undefined, details?: unknown | undefined);
+}
+/**
+ * Transformer applies templates to slides and generates HTML content
+ */
+declare class Transformer {
+    private templateEngine;
+    private templateLoader;
+    private iconResolver;
+    private citationFormatter;
+    constructor(templateEngine: TemplateEngine, templateLoader: TemplateLoader, iconResolver: IconResolver, citationFormatter: CitationFormatter);
+    /**
+     * Transform a single slide using its template
+     */
+    transform(slide: ParsedSlide, context: TransformContext): Promise<string>;
+    /**
+     * Transform all slides in a presentation
+     */
+    transformAll(presentation: ParsedPresentation): Promise<string[]>;
+    /**
+     * Build the full template context with helpers that collect async operations
+     */
+    private buildTemplateContext;
+    /**
+     * Resolve all placeholders by executing async operations
+     */
+    private resolvePlaceholders;
+}
+
+/**
+ * Options for rendering the final Marp markdown
+ */
+interface RenderOptions {
+    /** Include theme in front matter (default: true) */
+    includeTheme?: boolean;
+    /** Speaker notes for each slide (indexed by slide position) */
+    notes?: (string | undefined)[];
+    /** Additional front matter properties */
+    additionalFrontMatter?: Record<string, unknown>;
+}
+/**
+ * Renderer combines transformed slides into Marp-compatible Markdown
+ */
+declare class Renderer {
+    /**
+     * Render slides and metadata into final Marp markdown
+     */
+    render(slides: string[], meta: PresentationMeta, options?: RenderOptions): string;
+    /**
+     * Render the YAML front matter block
+     */
+    private renderFrontMatter;
+    /**
+     * Format a front matter value for YAML
+     */
+    private formatFrontMatterValue;
+    /**
+     * Join slides with Marp slide separator
+     */
+    private joinSlides;
+    /**
+     * Render speaker notes as HTML comment
+     */
+    private renderSpeakerNotes;
+}
+
+declare const configSchema: z.ZodObject<{
+    templates: z.ZodDefault<z.ZodObject<{
+        builtin: z.ZodDefault<z.ZodString>;
+        custom: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        builtin: string;
+        custom?: string | undefined;
+    }, {
+        custom?: string | undefined;
+        builtin?: string | undefined;
+    }>>;
+    icons: z.ZodDefault<z.ZodObject<{
+        registry: z.ZodDefault<z.ZodString>;
+        cache: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            directory: z.ZodDefault<z.ZodString>;
+            ttl: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            directory: string;
+            ttl: number;
+        }, {
+            enabled?: boolean | undefined;
+            directory?: string | undefined;
+            ttl?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        registry: string;
+        cache: {
+            enabled: boolean;
+            directory: string;
+            ttl: number;
+        };
+    }, {
+        registry?: string | undefined;
+        cache?: {
+            enabled?: boolean | undefined;
+            directory?: string | undefined;
+            ttl?: number | undefined;
+        } | undefined;
+    }>>;
+    references: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        connection: z.ZodDefault<z.ZodObject<{
+            type: z.ZodDefault<z.ZodLiteral<"cli">>;
+            command: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "cli";
+            command: string;
+        }, {
+            type?: "cli" | undefined;
+            command?: string | undefined;
+        }>>;
+        format: z.ZodDefault<z.ZodObject<{
+            locale: z.ZodDefault<z.ZodString>;
+            authorSep: z.ZodDefault<z.ZodString>;
+            identifierSep: z.ZodDefault<z.ZodString>;
+            maxAuthors: z.ZodDefault<z.ZodNumber>;
+            etAl: z.ZodDefault<z.ZodString>;
+            etAlJa: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            etAl: string;
+            etAlJa: string;
+            locale: string;
+            authorSep: string;
+            identifierSep: string;
+            maxAuthors: number;
+        }, {
+            etAl?: string | undefined;
+            etAlJa?: string | undefined;
+            locale?: string | undefined;
+            authorSep?: string | undefined;
+            identifierSep?: string | undefined;
+            maxAuthors?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        connection: {
+            type: "cli";
+            command: string;
+        };
+        format: {
+            etAl: string;
+            etAlJa: string;
+            locale: string;
+            authorSep: string;
+            identifierSep: string;
+            maxAuthors: number;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        connection?: {
+            type?: "cli" | undefined;
+            command?: string | undefined;
+        } | undefined;
+        format?: {
+            etAl?: string | undefined;
+            etAlJa?: string | undefined;
+            locale?: string | undefined;
+            authorSep?: string | undefined;
+            identifierSep?: string | undefined;
+            maxAuthors?: number | undefined;
+        } | undefined;
+    }>>;
+    output: z.ZodDefault<z.ZodObject<{
+        theme: z.ZodDefault<z.ZodString>;
+        inlineStyles: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        theme: string;
+        inlineStyles: boolean;
+    }, {
+        theme?: string | undefined;
+        inlineStyles?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    references: {
+        enabled: boolean;
+        connection: {
+            type: "cli";
+            command: string;
+        };
+        format: {
+            etAl: string;
+            etAlJa: string;
+            locale: string;
+            authorSep: string;
+            identifierSep: string;
+            maxAuthors: number;
+        };
+    };
+    icons: {
+        registry: string;
+        cache: {
+            enabled: boolean;
+            directory: string;
+            ttl: number;
+        };
+    };
+    output: {
+        theme: string;
+        inlineStyles: boolean;
+    };
+    templates: {
+        builtin: string;
+        custom?: string | undefined;
+    };
+}, {
+    references?: {
+        enabled?: boolean | undefined;
+        connection?: {
+            type?: "cli" | undefined;
+            command?: string | undefined;
+        } | undefined;
+        format?: {
+            etAl?: string | undefined;
+            etAlJa?: string | undefined;
+            locale?: string | undefined;
+            authorSep?: string | undefined;
+            identifierSep?: string | undefined;
+            maxAuthors?: number | undefined;
+        } | undefined;
+    } | undefined;
+    icons?: {
+        registry?: string | undefined;
+        cache?: {
+            enabled?: boolean | undefined;
+            directory?: string | undefined;
+            ttl?: number | undefined;
+        } | undefined;
+    } | undefined;
+    output?: {
+        theme?: string | undefined;
+        inlineStyles?: boolean | undefined;
+    } | undefined;
+    templates?: {
+        custom?: string | undefined;
+        builtin?: string | undefined;
+    } | undefined;
+}>;
+type Config = z.infer<typeof configSchema>;
+
+/**
+ * Options for the Pipeline
+ */
+interface PipelineOptions {
+    /** Custom config path override */
+    configPath?: string;
+    /** Output file path (if not specified, returns string only) */
+    outputPath?: string;
+    /** Enable verbose/progress output */
+    verbose?: boolean;
+}
+/**
+ * Result of a pipeline run
+ */
+interface PipelineResult {
+    /** Generated Marp markdown */
+    output: string;
+    /** Citation IDs found in the presentation */
+    citations: string[];
+    /** Warnings generated during processing */
+    warnings: string[];
+    /** Number of slides processed */
+    slideCount: number;
+}
+/**
+ * Error thrown when pipeline processing fails
+ */
+declare class PipelineError extends Error {
+    stage: string;
+    details?: unknown | undefined;
+    constructor(message: string, stage: string, details?: unknown | undefined);
+}
+/**
+ * Pipeline orchestrates the full YAML to Marp markdown conversion
+ *
+ * Stages:
+ * 1. Parse Source - Load and validate YAML
+ * 2. Collect Citations - Extract citation IDs from all slides
+ * 3. Resolve References - Fetch bibliography data
+ * 4. Transform Slides - Apply templates and resolve icons/citations
+ * 5. Render Output - Generate final Marp markdown
+ */
+declare class Pipeline {
+    private config;
+    private parser;
+    private templateEngine;
+    private templateLoader;
+    private iconRegistry;
+    private iconResolver;
+    private referenceManager;
+    private citationExtractor;
+    private citationFormatter;
+    private transformer;
+    private renderer;
+    private warnings;
+    constructor(config: Config);
+    /**
+     * Run the full conversion pipeline
+     */
+    run(inputPath: string, options?: PipelineOptions): Promise<string>;
+    /**
+     * Run the full pipeline with detailed result
+     */
+    runWithResult(inputPath: string, options?: PipelineOptions): Promise<PipelineResult>;
+    /**
+     * Initialize the pipeline by loading templates and icon registry
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get collected warnings
+     */
+    getWarnings(): string[];
+    /**
+     * Stage 1: Parse the YAML source file
+     */
+    private parseSource;
+    /**
+     * Stage 2: Collect all citation IDs from the presentation
+     */
+    private collectCitations;
+    /**
+     * Stage 3: Resolve references from the reference manager
+     */
+    private resolveReferences;
+    /**
+     * Stage 4: Transform all slides using templates
+     */
+    private transformSlides;
+    /**
+     * Stage 5: Render the final Marp markdown
+     */
+    private render;
+}
+
+/**
+ * slide-generation - A CLI tool to generate Marp-compatible Markdown from YAML source files
+ */
+declare const VERSION = "0.1.0";
+
+export { type IconsHelper, type JsonSchema, type MetaContext, ParseError, type ParsedPresentation, type ParsedSlide, Parser, Pipeline, PipelineError, type PipelineOptions, type PipelineResult, type PresentationMeta, type RefsHelper, type RenderOptions, Renderer, type SlideContext, type TemplateContext, type TemplateDefinition, TemplateEngine, TemplateLoader, type TransformContext, TransformError, Transformer, VERSION, ValidationError, type ValidationResult, jsonSchemaToZod, presentationSchema, templateDefSchema, validateWithJsonSchema };