@juspay/neurolink 8.35.1 → 8.36.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [8.36.0](https://github.com/juspay/neurolink/compare/v8.35.2...v8.36.0) (2026-01-22)
+
+### Features
+
+- **(ppt):** Add Types and Validation for PPT generation ([27b970c](https://github.com/juspay/neurolink/commit/27b970c9fd5d74161b74603738ca307f8217e287))
+
+## [8.35.2](https://github.com/juspay/neurolink/compare/v8.35.1...v8.35.2) (2026-01-15)
+
+### Bug Fixes
+
+- **(provider):** add network retry logic with exponential backoff to detection operations ([3b29e24](https://github.com/juspay/neurolink/commit/3b29e248766fac01f1e3ea368e9439233957121e))
+
 ## [8.35.1](https://github.com/juspay/neurolink/compare/v8.35.0...v8.35.1) (2026-01-15)
 
 ### Bug Fixes

package/dist/lib/types/fileTypes.d.ts

@@ -225,6 +225,10 @@ export type FileDetectorOptions = {
     officeOptions?: OfficeProcessorOptions;
     confidenceThreshold?: number;
     provider?: string;
+    /** Maximum number of retry attempts for network requests (default: 3) */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds with exponential backoff (default: 1000) */
+    retryDelay?: number;
 };
 /**
  * Google AI Studio Files API types

package/dist/lib/types/generateTypes.d.ts

@@ -8,6 +8,7 @@ import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 import type { JsonValue } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { TTSOptions, TTSResult } from "./ttsTypes.js";
+import type { PPTOutputOptions, PPTGenerationResult } from "./pptTypes.js";
 import type { VideoOutputOptions, VideoGenerationResult } from "./multimodal.js";
 /**
  * Generate function options type - Primary method for content generation
@@ -68,13 +69,19 @@ export type GenerateOptions = {
          * Output mode - determines the type of content generated
          * - "text": Standard text generation (default)
          * - "video": Video generation using models like Veo 3.1
+         * - "ppt": PowerPoint presentation generation
          */
-        mode?: "text" | "video";
+        mode?: "text" | "video" | "ppt";
         /**
          * Video generation configuration (used when mode is "video")
          * Requires an input image and text prompt
          */
         video?: VideoOutputOptions;
+        /**
+         * PowerPoint generation configuration (used when mode is "ppt")
+         * Generates slides based on text prompt
+         */
+        ppt?: PPTOutputOptions;
     };
     csvOptions?: {
         maxRows?: number;
@@ -312,6 +319,24 @@ export type GenerateResult = {
      * ```
      */
     video?: VideoGenerationResult;
+    /**
+     * PowerPoint generation result (present when output.mode is "ppt")
+     *
+     * @example
+     * ```typescript
+     * const result = await neurolink.generate({
+     *   input: { text: "Introducing Our New Product" },
+     *   model: "gemini-pro",
+     *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+     * });
+     *
+     * if (result.ppt) {
+     *   console.log(`Generated ${result.ppt.slides.length} slides`);
+     *   console.log(`Title: ${result.ppt.slides[0].title}`);
+     * }
+     * ```
+     */
+    ppt?: PPTGenerationResult;
     imageOutput?: {
         base64: string;
     } | null;
@@ -434,12 +459,17 @@ export type TextGenerationOptions = {
          * Output mode - determines the type of content generated
          * - "text": Standard text generation (default)
          * - "video": Video generation using models like Veo 3.1
+         * - "ppt": PowerPoint presentation generation
          */
-        mode?: "text" | "video";
+        mode?: "text" | "video" | "ppt";
         /**
          * Video generation configuration (used when mode is "video")
          */
         video?: VideoOutputOptions;
+        /**
+         * PowerPoint generation configuration (used when mode is "ppt")
+         */
+        ppt?: PPTOutputOptions;
     };
     tools?: Record<string, Tool>;
     timeout?: number | string;
@@ -612,6 +642,8 @@ export type TextGenerationResult = {
     audio?: TTSResult;
     /** Video generation result */
     video?: VideoGenerationResult;
+    /** PowerPoint generation result */
+    ppt?: PPTGenerationResult;
     /** Image generation output */
     imageOutput?: {
         base64: string;

package/dist/lib/types/pptTypes.d.ts

@@ -0,0 +1,69 @@
+import type { ImageWithAltText } from "./content.js";
+type ThemeOption = "modern" | "corporate" | "creative" | "minimal" | "dark";
+type AudienceOption = "business" | "students" | "technical" | "general";
+type ToneOption = "professional" | "casual" | "educational" | "persuasive";
+type OutputFormatOption = "pptx";
+type AspectRatioOption = "16:9" | "4:3";
+export type PPTOutputOptions = {
+    /** Number of slides to generate (required, range: 5-50) */
+    pages: number;
+    /** Output format - only PPTX supported currently (default: "pptx") */
+    format?: OutputFormatOption;
+    /** Presentation theme/style (default: "modern") */
+    theme?: ThemeOption;
+    /** Target audience for content customization */
+    audience?: AudienceOption;
+    /** Presentation tone/style */
+    tone?: ToneOption;
+    /** Whether to generate AI images for slides (default: true) */
+    includeImages?: boolean;
+    /** Custom output file path (default: auto-generated in ./output/) */
+    outputPath?: string;
+    /** Aspect ratio for slides (default: "16:9") */
+    aspectRatio?: AspectRatioOption;
+    /** Path to logo image to include in slides */
+    logoPath?: Buffer | string | ImageWithAltText;
+};
+/**
+ * Result type for generated presentation content
+ *
+ * Returned in `GenerateResult.ppt` when presentation generation is successful.
+ * Contains the file path and metadata about the generated presentation.
+ *
+ * @example
+ * ```typescript
+ * const result = await neurolink.generate({
+ *   input: { text: "Introducing Our New Product" },
+ *   provider: "vertex",
+ *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+ * });
+ *
+ * if (result.ppt) {
+ *   console.log(`Presentation saved: ${result.ppt.filePath}`);
+ *   console.log(`Total slides: ${result.ppt.totalSlides}`);
+ *   console.log(`Theme: ${result.ppt.metadata?.theme}`);
+ * }
+ * ```
+ */
+export type PPTGenerationResult = {
+    /** Path to the generated PPTX file */
+    filePath: string;
+    /** Total number of slides in the presentation */
+    totalSlides: number;
+    /** Output format (always "pptx" currently) */
+    format: OutputFormatOption;
+    /** Presentation metadata */
+    metadata?: {
+        /** Theme/style used */
+        theme?: string;
+        /** Target audience */
+        audience?: string;
+        /** Presentation tone */
+        tone?: string;
+        /** Model used for image generation */
+        imageModel?: string;
+        /** File size in bytes */
+        fileSize?: number;
+    };
+};
+export {};

package/dist/lib/types/pptTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pptTypes.js.map

package/dist/lib/utils/errorHandling.d.ts

@@ -32,6 +32,15 @@ export declare const ERROR_CODES: {
     readonly IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
     readonly IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL";
     readonly INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT";
+    readonly MISSING_PPT_PROPERTIES: "MISSING_PPT_PROPERTIES";
+    readonly INVALID_PPT_PAGES: "INVALID_PPT_PAGES";
+    readonly INVALID_PPT_FORMAT: "INVALID_PPT_FORMAT";
+    readonly INVALID_PPT_PROVIDER: "INVALID_PPT_PROVIDER";
+    readonly INVALID_PPT_OUTPUT_OPTIONS: "INVALID_PPT_OUTPUT_OPTIONS";
+    readonly INVALID_PPT_OUTPUT_PATH: "INVALID_PPT_OUTPUT_PATH";
+    readonly INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH";
+    readonly INVALID_PPT_MODE: "INVALID_PPT_MODE";
+    readonly INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT";
 };
 /**
  * Enhanced error class with structured information
@@ -149,6 +158,42 @@ export declare class ErrorFactory {
      * Create an invalid image format error
      */
     static invalidImageFormat(): NeuroLinkError;
+    /**
+     * Create a generic missing PPT property error
+     */
+    static missingPPTProperty(field: string, suggestions?: string[]): NeuroLinkError;
+    /**
+     * Create an invalid PPT pages error
+     */
+    static invalidPPTPages(pages: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT format error
+     */
+    static invalidPPTFormat(format: string): NeuroLinkError;
+    /**
+     * Create a generic invalid PPT output options error
+     */
+    static invalidPPTOutputOptions(field: string, value: unknown, validOptions?: string[]): NeuroLinkError;
+    /**
+     * Create an invalid PPT output path error
+     */
+    static invalidPPTOutputPath(path: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT mode error
+     */
+    static invalidPPTMode(): NeuroLinkError;
+    /**
+     * Create an invalid PPT prompt error
+     */
+    static invalidPPTPrompt(reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT logo path error
+     */
+    static invalidPPTLogoPath(path: unknown, reason: string): NeuroLinkError;
+    /**
+     * Create an invalid PPT provider error
+     */
+    static invalidPPTProvider(provider: unknown): NeuroLinkError;
 }
 /**
  * Timeout wrapper for async operations

package/dist/lib/utils/errorHandling.js

@@ -40,6 +40,16 @@ export const ERROR_CODES = {
     IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE",
     IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL",
     INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT",
+    // PPT validation errors
+    MISSING_PPT_PROPERTIES: "MISSING_PPT_PROPERTIES",
+    INVALID_PPT_PAGES: "INVALID_PPT_PAGES",
+    INVALID_PPT_FORMAT: "INVALID_PPT_FORMAT",
+    INVALID_PPT_PROVIDER: "INVALID_PPT_PROVIDER",
+    INVALID_PPT_OUTPUT_OPTIONS: "INVALID_PPT_OUTPUT_OPTIONS",
+    INVALID_PPT_OUTPUT_PATH: "INVALID_PPT_OUTPUT_PATH",
+    INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH",
+    INVALID_PPT_MODE: "INVALID_PPT_MODE",
+    INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT",
 };
 /**
  * Enhanced error class with structured information
@@ -461,6 +471,187 @@ export class ErrorFactory {
             },
         });
     }
+    // ============================================================================
+    // PPT VALIDATION ERRORS
+    // ============================================================================
+    /**
+     * Create a generic missing PPT property error
+     */
+    static missingPPTProperty(field, suggestions) {
+        const defaultSuggestions = [`Provide the required '${field}' field`];
+        return new NeuroLinkError({
+            code: ERROR_CODES.MISSING_PPT_PROPERTIES,
+            message: `PPT generation requires '${field}' field`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field,
+                suggestions: suggestions || defaultSuggestions,
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT pages error
+     */
+    static invalidPPTPages(pages, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PAGES,
+            message: `Invalid pages value '${pages}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.pages",
+                providedValue: pages,
+                suggestions: [
+                    "Use a number between 5 and 50",
+                    "For longer presentations, consider breaking into multiple decks",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT format error
+     */
+    static invalidPPTFormat(format) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_FORMAT,
+            message: `Invalid format '${format}'. Only 'pptx' is supported`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.format",
+                providedValue: format,
+                suggestions: ["Use format: 'pptx' or omit (defaults to 'pptx')"],
+            },
+        });
+    }
+    /**
+     * Create a generic invalid PPT output options error
+     */
+    static invalidPPTOutputOptions(field, value, validOptions) {
+        const suggestions = validOptions
+            ? validOptions.map((opt) => `Use '${opt}'`)
+            : ["Check the documentation for valid options"];
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_OUTPUT_OPTIONS,
+            message: `Invalid ${field} value '${value}'`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: `output.ppt.${field}`,
+                providedValue: value,
+                suggestions,
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT output path error
+     */
+    static invalidPPTOutputPath(path, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_OUTPUT_PATH,
+            message: `Invalid outputPath '${path}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.outputPath",
+                providedValue: path,
+                suggestions: [
+                    "Provide a valid file path string",
+                    "Example: './presentations/my-deck.pptx'",
+                    "Omit to use auto-generated path",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT mode error
+     */
+    static invalidPPTMode() {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_MODE,
+            message: "Presentation generation requires output.mode to be 'ppt'",
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.mode",
+                suggestions: [
+                    "Set output: { mode: 'ppt' } for presentation generation",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT prompt error
+     */
+    static invalidPPTPrompt(reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PROMPT,
+            message: `Invalid PPT prompt: ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "input.text",
+                suggestions: [
+                    "Provide a non-empty text prompt",
+                    "Keep the prompt under 1000 characters",
+                    "Focus on key topics and structure for the presentation",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT logo path error
+     */
+    static invalidPPTLogoPath(path, reason) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_LOGO_PATH,
+            message: `Invalid logoPath '${path}': ${reason}`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "output.ppt.logoPath",
+                providedValue: path,
+                suggestions: [
+                    "Provide a valid file path string",
+                    "Example: './assets/logo.png'",
+                    "Omit to skip logo inclusion",
+                ],
+            },
+        });
+    }
+    /**
+     * Create an invalid PPT provider error
+     */
+    static invalidPPTProvider(provider) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.INVALID_PPT_PROVIDER,
+            message: `Invalid provider '${provider}' for PPT generation. Supported providers: vertex, openai, azure, anthropic, google-ai, bedrock`,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {
+                field: "provider",
+                providedValue: provider,
+                suggestions: [
+                    "Use 'vertex' for Google Vertex AI (Gemini)",
+                    "Use 'openai' for OpenAI GPT models",
+                    "Use 'azure' for Azure OpenAI",
+                    "Use 'anthropic' for Anthropic Claude models",
+                    "Use 'google-ai' for Google AI Studio (Gemini)",
+                    "Use 'bedrock' for AWS Bedrock (Claude, Llama, Nova, etc.)",
+                ],
+            },
+        });
+    }
 }
 /**
  * Timeout wrapper for async operations

package/dist/lib/utils/fileDetector.d.ts

@@ -70,7 +70,7 @@ export declare class FileDetector {
      */
     private static processFile;
     /**
-     * Load file from URL
+     * Load file from URL with automatic retry on transient network errors
      */
     private static loadFromURL;
     /**

package/dist/lib/utils/fileDetector.js

@@ -9,6 +9,116 @@ import { logger } from "./logger.js";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
 import { PDFProcessor } from "./pdfProcessor.js";
+/**
+ * Default retry configuration constants
+ */
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 1000; // milliseconds
+/**
+ * Retryable network error codes (Node.js/undici network errors)
+ */
+const RETRYABLE_ERROR_CODES = [
+    "ETIMEDOUT",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "EPIPE",
+    "ECONNABORTED",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+];
+/**
+ * Non-retryable HTTP status codes (client errors)
+ */
+const NON_RETRYABLE_STATUS_CODES = [400, 401, 403, 404, 405];
+/**
+ * Retryable HTTP status codes (server errors + rate limiting)
+ */
+const RETRYABLE_STATUS_CODES = [429, 500, 502, 503, 504];
+/**
+ * Check if an error is a recoverable network error that should be retried
+ *
+ * @param error - Error to check
+ * @returns True if error is retryable (transient network issue)
+ */
+function isRetryableNetworkError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const errorMessage = error.message.toLowerCase();
+    // Extract error code from various error shapes
+    const errorWithCode = error;
+    const errorCode = errorWithCode.code?.toUpperCase();
+    // Check for retryable network error codes
+    if (errorCode && RETRYABLE_ERROR_CODES.includes(errorCode)) {
+        return true;
+    }
+    // Check HTTP status code if present in error message (e.g., "HTTP 503")
+    const httpStatusMatch = errorMessage.match(/http\s*(\d{3})/);
+    if (httpStatusMatch) {
+        const statusCode = parseInt(httpStatusMatch[1], 10);
+        if (NON_RETRYABLE_STATUS_CODES.includes(statusCode)) {
+            return false;
+        }
+        if (RETRYABLE_STATUS_CODES.includes(statusCode)) {
+            return true;
+        }
+    }
+    // Check error message for transient issues
+    const transientKeywords = [
+        "timeout",
+        "timed out",
+        "connection reset",
+        "econnreset",
+        "etimedout",
+        "network error",
+        "socket hang up",
+        "enotfound",
+        "getaddrinfo",
+        "unavailable",
+        "service unavailable",
+    ];
+    return transientKeywords.some((keyword) => errorMessage.includes(keyword));
+}
+/**
+ * Execute an operation with automatic retry logic on transient network errors
+ *
+ * @param operation - Async function to execute
+ * @param options - Retry configuration options
+ * @returns Promise resolving to the operation result
+ * @throws Error if all retry attempts fail or error is non-retryable
+ */
+async function withRetry(operation, options = {}) {
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryDelay = options.retryDelay ?? DEFAULT_RETRY_DELAY;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const isRetryable = isRetryableNetworkError(error);
+            const isLastAttempt = attempt === maxRetries;
+            if (!isRetryable || isLastAttempt) {
+                throw error;
+            }
+            // Calculate exponential backoff delay
+            const delay = retryDelay * Math.pow(2, attempt);
+            logger.debug("Retrying network operation after transient error", {
+                attempt: attempt + 1,
+                maxRetries,
+                delay,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    // TypeScript exhaustiveness check - should never reach here
+    throw new Error("Retry logic failed unexpectedly");
+}
 /**
  * Check if text has JSON markers (starts with { or [ and ends with corresponding closing bracket)
  */
@@ -356,30 +466,34 @@ export class FileDetector {
         }
     }
     /**
-     * Load file from URL
+     * Load file from URL with automatic retry on transient network errors
      */
     static async loadFromURL(url, options) {
         const maxSize = options?.maxSize || 10 * 1024 * 1024;
         const timeout = options?.timeout || this.DEFAULT_NETWORK_TIMEOUT;
-        const response = await request(url, {
-            dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
-            method: "GET",
-            headersTimeout: timeout,
-            bodyTimeout: timeout,
-        });
-        if (response.statusCode !== 200) {
-            throw new Error(`HTTP ${response.statusCode}`);
-        }
-        const chunks = [];
-        let totalSize = 0;
-        for await (const chunk of response.body) {
-            totalSize += chunk.length;
-            if (totalSize > maxSize) {
-                throw new Error(`File too large: ${formatFileSize(totalSize)} (max: ${formatFileSize(maxSize)})`);
+        const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const retryDelay = options?.retryDelay ?? DEFAULT_RETRY_DELAY;
+        return withRetry(async () => {
+            const response = await request(url, {
+                dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
+                method: "GET",
+                headersTimeout: timeout,
+                bodyTimeout: timeout,
+            });
+            if (response.statusCode !== 200) {
+                throw new Error(`HTTP ${response.statusCode}`);
             }
-            chunks.push(chunk);
-        }
-        return Buffer.concat(chunks);
+            const chunks = [];
+            let totalSize = 0;
+            for await (const chunk of response.body) {
+                totalSize += chunk.length;
+                if (totalSize > maxSize) {
+                    throw new Error(`File too large: ${formatFileSize(totalSize)} (max: ${formatFileSize(maxSize)})`);
+                }
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks);
+        }, { maxRetries, retryDelay });
     }
     /**
      * Load file from filesystem path

package/dist/lib/utils/parameterValidation.d.ts

@@ -4,6 +4,7 @@
  */
 import type { GenerateOptions } from "../types/generateTypes.js";
 import type { VideoOutputOptions } from "../types/multimodal.js";
+import type { PPTOutputOptions } from "../types/pptTypes.js";
 import type { EnhancedValidationResult } from "../types/tools.js";
 import type { StringArray, ValidationSchema } from "../types/typeAliases.js";
 import { NeuroLinkError } from "./errorHandling.js";
@@ -132,6 +133,46 @@ export declare function validateImageForVideo(image: Buffer | string, maxSize?:
  * ```
  */
 export declare function validateVideoGenerationInput(options: GenerateOptions): EnhancedValidationResult;
+export declare const MIN_PPT_PAGES = 5;
+export declare const MAX_PPT_PAGES = 50;
+export declare const MIN_PPT_PROMPT_LENGTH = 10;
+export declare const MAX_PPT_PROMPT_LENGTH = 1000;
+/**
+ * Validate PPT output options (pages, theme, audience, tone, etc.)
+ *
+ * @param options - PPTOutputOptions to validate
+ * @returns NeuroLinkError if invalid, null if valid
+ *
+ * @example
+ * ```typescript
+ * const error = validatePPTOutputOptions({ pages: 100, theme: "invalid" });
+ * // error.code === "INVALID_PPT_PAGES"
+ * ```
+ */
+export declare function validatePPTOutputOptions(options: PPTOutputOptions): NeuroLinkError | null;
+/**
+ * Validate complete PPT generation input
+ *
+ * Validates all requirements for presentation generation:
+ * - output.mode must be "ppt"
+ * - Prompt must be within length limits
+ * - PPT output options must be valid
+ *
+ * @param options - GenerateOptions to validate for PPT generation
+ * @returns EnhancedValidationResult with errors, warnings, and suggestions
+ *
+ * @example
+ * ```typescript
+ * const validation = validatePPTGenerationInput({
+ *   input: { text: "Introducing Our New Product" },
+ *   output: { mode: "ppt", ppt: { pages: 10, theme: "modern" } }
+ * });
+ * if (!validation.isValid) {
+ *   console.error(validation.errors);
+ * }
+ * ```
+ */
+export declare function validatePPTGenerationInput(options: GenerateOptions): EnhancedValidationResult;
 /**
  * Create a validation error summary for logging
  */