@juspay/neurolink 9.1.1 → 9.2.0

package/dist/utils/async/retry.js

@@ -0,0 +1,171 @@
+/**
+ * Retry Utilities
+ *
+ * Provides retry logic with exponential backoff for resilient async operations.
+ */
+import { delay } from "./delay.js";
+/**
+ * Default retry configuration.
+ */
+export const DEFAULT_RETRY_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+};
+/**
+ * Calculate exponential backoff delay with optional jitter.
+ *
+ * Uses the formula: min(baseDelay * 2^(attempt-1) + jitter, maxDelay)
+ *
+ * @param attempt - Current attempt number (1-based)
+ * @param baseDelayMs - Base delay in milliseconds
+ * @param maxDelayMs - Maximum delay cap in milliseconds
+ * @param addJitter - Whether to add random jitter (default: true)
+ * @returns Calculated delay in milliseconds
+ *
+ * @example
+ * ```typescript
+ * // Without jitter
+ * calculateBackoff(1, 1000, 30000, false); // 1000ms
+ * calculateBackoff(2, 1000, 30000, false); // 2000ms
+ * calculateBackoff(3, 1000, 30000, false); // 4000ms
+ *
+ * // With jitter (adds up to 10% random delay)
+ * calculateBackoff(3, 1000, 30000, true); // ~4000-4400ms
+ * ```
+ */
+export function calculateBackoff(attempt, baseDelayMs, maxDelayMs, addJitter = true) {
+    const exponentialDelay = baseDelayMs * 2 ** (attempt - 1);
+    if (addJitter) {
+        // Add up to 10% jitter to prevent thundering herd
+        const jitter = Math.random() * 0.1 * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, maxDelayMs);
+    }
+    return Math.min(exponentialDelay, maxDelayMs);
+}
+/**
+ * Error thrown when all retry attempts are exhausted.
+ */
+export class RetryExhaustedError extends Error {
+    attempts;
+    lastError;
+    /**
+     * Creates a new RetryExhaustedError.
+     *
+     * @param message - Error message
+     * @param attempts - Total number of attempts made
+     * @param lastError - The last error that caused the final failure
+     */
+    constructor(message, attempts, lastError) {
+        super(message);
+        this.attempts = attempts;
+        this.lastError = lastError;
+        this.name = "RetryExhaustedError";
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RetryExhaustedError);
+        }
+    }
+}
+/**
+ * Retry an async function with exponential backoff.
+ *
+ * Executes the provided function and retries on failure according to
+ * the specified options. Uses exponential backoff between retries.
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry configuration (merged with defaults)
+ * @returns Promise that resolves with the function result
+ * @throws The last error if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults
+ * const data = await retry(() => fetchFromAPI());
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom options
+ * const data = await retry(
+ *   () => fetchFromAPI(),
+ *   {
+ *     maxRetries: 5,
+ *     baseDelayMs: 500,
+ *     maxDelayMs: 10000,
+ *     onRetry: (err, attempt, delay) => {
+ *       console.log(`Retry ${attempt} after ${delay}ms: ${err.message}`);
+ *     },
+ *     shouldRetry: (err) => {
+ *       // Only retry on network errors
+ *       return err.name === 'NetworkError';
+ *     }
+ *   }
+ * );
+ * ```
+ */
+export async function retry(fn, options = {}) {
+    const config = {
+        ...DEFAULT_RETRY_OPTIONS,
+        ...options,
+    };
+    const { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier = 2, shouldRetry = () => true, onRetry, } = config;
+    let lastError = new Error("Retry failed");
+    let currentDelay = baseDelayMs;
+    // Total attempts = initial attempt + retries
+    const totalAttempts = maxRetries + 1;
+    for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            lastError = err;
+            // Check if we've exhausted all retries
+            if (attempt >= totalAttempts) {
+                throw new RetryExhaustedError(`All ${totalAttempts} retry attempts exhausted`, totalAttempts, err);
+            }
+            // Check if we should retry this error
+            if (!shouldRetry(err, attempt)) {
+                throw err;
+            }
+            // Calculate delay with exponential backoff (capped at maxDelay)
+            const delayMs = Math.min(currentDelay, maxDelayMs);
+            // Notify about retry
+            if (onRetry) {
+                onRetry(err, attempt, delayMs);
+            }
+            // Wait before next attempt
+            await delay(delayMs);
+            // Increase delay for next iteration
+            currentDelay = currentDelay * backoffMultiplier;
+        }
+    }
+    // This should never be reached, but TypeScript needs it
+    throw new RetryExhaustedError(`All ${totalAttempts} retry attempts exhausted`, totalAttempts, lastError || new Error("Unknown retry failure"));
+}
+/**
+ * Create a retry wrapper with pre-configured options.
+ *
+ * Useful for creating reusable retry strategies.
+ *
+ * @param defaultOptions - Default retry options for the wrapper
+ * @returns A retry function with the specified defaults
+ *
+ * @example
+ * ```typescript
+ * const apiRetry = createRetry({
+ *   maxRetries: 5,
+ *   baseDelayMs: 100,
+ *   onRetry: (err, attempt) => logger.warn(`API retry ${attempt}`)
+ * });
+ *
+ * // Use the configured retry
+ * const data = await apiRetry(() => fetchFromAPI());
+ * ```
+ */
+export function createRetry(defaultOptions) {
+    return (fn, overrideOptions) => {
+        return retry(fn, { ...defaultOptions, ...overrideOptions });
+    };
+}

package/dist/utils/async/withTimeout.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Timeout Utilities
+ *
+ * Wrapper functions for adding timeout protection to async operations.
+ */
+/**
+ * Error thrown when an operation times out.
+ */
+export declare class TimeoutError extends Error {
+    readonly timeoutMs: number;
+    /**
+     * Creates a new TimeoutError.
+     *
+     * @param message - Error message describing the timeout
+     * @param timeoutMs - The timeout duration that was exceeded
+     */
+    constructor(message: string, timeoutMs: number);
+}
+/**
+ * Execute a promise with timeout protection.
+ *
+ * Wraps a promise and rejects with a TimeoutError if the operation
+ * takes longer than the specified duration.
+ *
+ * @param promise - The promise to wrap with timeout
+ * @param ms - Maximum time to wait in milliseconds
+ * @param message - Optional custom error message for timeout
+ * @returns Promise that resolves with the result or rejects on timeout
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeout(
+ *   fetchData(),
+ *   5000,
+ *   'Data fetch timed out'
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = await withTimeout(slowOperation(), 3000);
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     console.log(`Timed out after ${error.timeoutMs}ms`);
+ *   }
+ * }
+ * ```
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Execute a function with timeout protection.
+ *
+ * Alternative signature that accepts a function instead of a promise,
+ * useful when you want to delay starting the operation.
+ *
+ * @param fn - Async function to execute
+ * @param ms - Maximum time to wait in milliseconds
+ * @param message - Optional custom error message for timeout
+ * @returns Promise that resolves with the function result or rejects on timeout
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeoutFn(
+ *   () => fetchData(),
+ *   5000,
+ *   'Data fetch timed out'
+ * );
+ * ```
+ */
+export declare function withTimeoutFn<T>(fn: () => Promise<T>, ms: number, message?: string): Promise<T>;

package/dist/utils/async/withTimeout.js

@@ -0,0 +1,96 @@
+/**
+ * Timeout Utilities
+ *
+ * Wrapper functions for adding timeout protection to async operations.
+ */
+/**
+ * Error thrown when an operation times out.
+ */
+export class TimeoutError extends Error {
+    timeoutMs;
+    /**
+     * Creates a new TimeoutError.
+     *
+     * @param message - Error message describing the timeout
+     * @param timeoutMs - The timeout duration that was exceeded
+     */
+    constructor(message, timeoutMs) {
+        super(message);
+        this.timeoutMs = timeoutMs;
+        this.name = "TimeoutError";
+        // Maintains proper stack trace for where error was thrown (V8 engines)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TimeoutError);
+        }
+    }
+}
+/**
+ * Execute a promise with timeout protection.
+ *
+ * Wraps a promise and rejects with a TimeoutError if the operation
+ * takes longer than the specified duration.
+ *
+ * @param promise - The promise to wrap with timeout
+ * @param ms - Maximum time to wait in milliseconds
+ * @param message - Optional custom error message for timeout
+ * @returns Promise that resolves with the result or rejects on timeout
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeout(
+ *   fetchData(),
+ *   5000,
+ *   'Data fetch timed out'
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = await withTimeout(slowOperation(), 3000);
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     console.log(`Timed out after ${error.timeoutMs}ms`);
+ *   }
+ * }
+ * ```
+ */
+export async function withTimeout(promise, ms, message) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new TimeoutError(message || `Operation timed out after ${ms}ms`, ms));
+        }, ms);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Execute a function with timeout protection.
+ *
+ * Alternative signature that accepts a function instead of a promise,
+ * useful when you want to delay starting the operation.
+ *
+ * @param fn - Async function to execute
+ * @param ms - Maximum time to wait in milliseconds
+ * @param message - Optional custom error message for timeout
+ * @returns Promise that resolves with the function result or rejects on timeout
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * ```typescript
+ * const result = await withTimeoutFn(
+ *   () => fetchData(),
+ *   5000,
+ *   'Data fetch timed out'
+ * );
+ * ```
+ */
+export async function withTimeoutFn(fn, ms, message) {
+    return withTimeout(fn(), ms, message);
+}

package/dist/utils/fileDetector.d.ts

@@ -3,7 +3,7 @@
  * Centralized file detection for all multimodal file types
  * Uses multi-strategy approach for reliable type identification
  */
-import type { FileInput, FileProcessingResult, FileDetectorOptions } from "../types/fileTypes.js";
+import type { FileDetectorOptions, FileInput, FileProcessingResult } from "../types/fileTypes.js";
 /**
  * Centralized file type detection and processing
  *
@@ -69,6 +69,12 @@ export declare class FileDetector {
      * Route to appropriate processor
      */
     private static processFile;
+    /**
+     * Process SVG file as text content
+     * Uses SvgProcessor for security sanitization (removes XSS vectors)
+     * Returns sanitized SVG markup as text for AI analysis
+     */
+    private static processSvgAsText;
     /**
      * Load file from URL with automatic retry on transient network errors
      */

package/dist/utils/fileDetector.js

@@ -3,11 +3,11 @@
  * Centralized file detection for all multimodal file types
  * Uses multi-strategy approach for reliable type identification
  */
-import { request, getGlobalDispatcher, interceptors } from "undici";
 import { readFile, stat } from "fs/promises";
-import { logger } from "./logger.js";
+import { getGlobalDispatcher, interceptors, request } from "undici";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
+import { logger } from "./logger.js";
 import { PDFProcessor } from "./pdfProcessor.js";
 /**
  * Default retry configuration constants
@@ -106,7 +106,7 @@ async function withRetry(operation, options = {}) {
                 throw error;
             }
             // Calculate exponential backoff delay
-            const delay = retryDelay * Math.pow(2, attempt);
+            const delay = retryDelay * 2 ** attempt;
             logger.debug("Retrying network operation after transient error", {
                 attempt: attempt + 1,
                 maxRetries,
@@ -186,7 +186,7 @@ export class FileDetector {
      * @returns Processed file result with type and content
      */
     static async detectAndProcess(input, options) {
-        const detection = await this.detect(input, options);
+        const detection = await FileDetector.detect(input, options);
         // FD-018: Comprehensive fallback parsing for extension-less files
         // When file detection returns "unknown" or doesn't match allowedTypes,
         // attempt parsing for each allowed type before failing. This handles cases like Slack
@@ -194,12 +194,12 @@ export class FileDetector {
         if (options?.allowedTypes &&
             !options.allowedTypes.includes(detection.type)) {
             // Try fallback parsing for both "unknown" types and when detection doesn't match allowed types
-            const content = await this.loadContent(input, detection, options);
+            const content = await FileDetector.loadContent(input, detection, options);
             const errors = [];
             // Try each allowed type in order of specificity
             for (const allowedType of options.allowedTypes) {
                 try {
-                    const result = await this.tryFallbackParsing(content, allowedType, options);
+                    const result = await FileDetector.tryFallbackParsing(content, allowedType, options);
                     if (result) {
                         logger.info(`[FileDetector] ✅ ${allowedType.toUpperCase()} fallback successful`);
                         return result;
@@ -214,10 +214,10 @@ export class FileDetector {
             // All fallbacks failed
             throw new Error(`File type detection failed and all fallback parsing attempts failed. Original detection: ${detection.type}. Attempted types: ${options.allowedTypes.join(", ")}. Errors: ${errors.join("; ")}`);
         }
-        const content = await this.loadContent(input, detection, options);
+        const content = await FileDetector.loadContent(input, detection, options);
         // Extract CSV-specific options from FileDetectorOptions
         const csvOptions = options?.csvOptions;
-        return await this.processFile(content, detection, csvOptions, options?.provider);
+        return await FileDetector.processFile(content, detection, csvOptions, options?.provider);
     }
     /**
      * Try fallback parsing for a specific file type
@@ -237,11 +237,11 @@ export class FileDetector {
                 // Try text parsing - check if content is valid UTF-8 text
                 const textContent = content.toString("utf-8");
                 // Validate it's actually text (no null bytes, mostly printable)
-                if (this.isValidText(textContent)) {
+                if (FileDetector.isValidText(textContent)) {
                     return {
                         type: "text",
                         content: textContent,
-                        mimeType: this.guessTextMimeType(textContent),
+                        mimeType: FileDetector.guessTextMimeType(textContent),
                         metadata: {
                             confidence: 70,
                             size: content.length,
@@ -307,7 +307,7 @@ export class FileDetector {
             }
         }
         // Check for XML/HTML using stricter detection
-        if (this.looksLikeXMLStrict(trimmed)) {
+        if (FileDetector.looksLikeXMLStrict(trimmed)) {
             const isHTML = trimmed.includes("<!DOCTYPE html") ||
                 trimmed.toLowerCase().includes("<html") ||
                 trimmed.includes("<head") ||
@@ -315,7 +315,7 @@ export class FileDetector {
             return isHTML ? "text/html" : "application/xml";
         }
         // Check for YAML using robust multi-indicator detection
-        if (this.looksLikeYAMLStrict(trimmed)) {
+        if (FileDetector.looksLikeYAMLStrict(trimmed)) {
             return "application/yaml";
         }
         // Default to plain text
@@ -427,13 +427,13 @@ export class FileDetector {
         }
         switch (source) {
             case "url":
-                return await this.loadFromURL(input, options);
+                return await FileDetector.loadFromURL(input, options);
             case "path":
-                return await this.loadFromPath(input, options);
+                return await FileDetector.loadFromPath(input, options);
             case "buffer":
                 return input;
             case "datauri":
-                return this.loadFromDataURI(input);
+                return FileDetector.loadFromDataURI(input);
             default:
                 throw new Error(`Unknown source: ${source}`);
         }
@@ -454,6 +454,10 @@ export class FileDetector {
                 return await ImageProcessor.process(content);
             case "pdf":
                 return await PDFProcessor.process(content, { provider });
+            case "svg":
+                // SVG is processed as text content (sanitized XML markup)
+                // AI providers don't support SVG as image format, so we extract text content
+                return await FileDetector.processSvgAsText(content, detection);
             case "text":
                 return {
                     type: "text",
@@ -465,12 +469,74 @@ export class FileDetector {
                 throw new Error(`Unsupported file type: ${detection.type}`);
         }
     }
+    /**
+     * Process SVG file as text content
+     * Uses SvgProcessor for security sanitization (removes XSS vectors)
+     * Returns sanitized SVG markup as text for AI analysis
+     */
+    static async processSvgAsText(content, detection) {
+        try {
+            // Dynamic import to avoid circular dependencies
+            const { processSvg } = await import("../processors/markup/SvgProcessor.js");
+            const result = await processSvg({
+                id: "svg-file",
+                name: detection.metadata.filename || "image.svg",
+                mimetype: "image/svg+xml",
+                size: content.length,
+                buffer: content,
+            });
+            if (result.success && result.data) {
+                logger.info(`[FileDetector] SVG processed as text: ${detection.metadata.filename || "image.svg"}`);
+                return {
+                    type: "svg",
+                    content: result.data.textContent, // Sanitized SVG content
+                    mimeType: "image/svg+xml",
+                    metadata: {
+                        confidence: detection.metadata.confidence,
+                        size: content.length,
+                        filename: detection.metadata.filename,
+                        extension: detection.extension,
+                    },
+                };
+            }
+            else {
+                // Fail closed: return safe empty SVG instead of raw unsanitized content
+                logger.warn(`[FileDetector] SVG processor failed, returning safe empty SVG: ${result.error?.userMessage}`);
+                return {
+                    type: "svg",
+                    content: '<svg xmlns="http://www.w3.org/2000/svg"></svg>',
+                    mimeType: "image/svg+xml",
+                    metadata: {
+                        confidence: detection.metadata.confidence,
+                        size: content.length,
+                        filename: detection.metadata.filename,
+                        extension: detection.extension,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            // Fail closed: return safe empty SVG instead of raw unsanitized content
+            logger.warn(`[FileDetector] SVG processor not available, returning safe empty SVG: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                type: "svg",
+                content: '<svg xmlns="http://www.w3.org/2000/svg"></svg>',
+                mimeType: "image/svg+xml",
+                metadata: {
+                    confidence: detection.metadata.confidence,
+                    size: content.length,
+                    filename: detection.metadata.filename,
+                    extension: detection.extension,
+                },
+            };
+        }
+    }
     /**
      * 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 timeout = options?.timeout || FileDetector.DEFAULT_NETWORK_TIMEOUT;
         const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
         const retryDelay = options?.retryDelay ?? DEFAULT_RETRY_DELAY;
         return withRetry(async () => {
@@ -627,6 +693,11 @@ class MimeTypeStrategy {
         if (mime.includes("text/tab-separated-values")) {
             return "csv";
         }
+        // SVG is processed as text/markup, NOT as image
+        // Must check before generic image/ check
+        if (mime.includes("image/svg+xml")) {
+            return "svg";
+        }
         if (mime.includes("image/")) {
             return "image";
         }
@@ -675,7 +746,9 @@ class ExtensionStrategy {
             bmp: "image",
             tiff: "image",
             tif: "image",
-            svg: "image",
+            // SVG is handled as text/markup, NOT as image
+            // AI providers don't support SVG format, so we process it as sanitized text
+            svg: "svg",
             avif: "image",
             pdf: "pdf",
             txt: "text",
@@ -865,7 +938,7 @@ class ContentHeuristicStrategy {
             // (data values like IDs, codes, numbers - not varied content)
             const lengths = lines.map((l) => l.length);
             const avgLength = lengths.reduce((a, b) => a + b, 0) / lengths.length;
-            const variance = lengths.reduce((sum, len) => sum + Math.pow(len - avgLength, 2), 0) /
+            const variance = lengths.reduce((sum, len) => sum + (len - avgLength) ** 2, 0) /
                 lengths.length;
             const stdDev = Math.sqrt(variance);
             // Single-column CSVs can contain varied data (names, cities, emails, etc.)

package/dist/utils/json/extract.d.ts

@@ -0,0 +1,103 @@
+/**
+ * JSON Extraction Utilities
+ *
+ * Utilities for extracting JSON from mixed text content.
+ * Particularly useful for parsing AI responses that contain JSON within prose.
+ */
+/**
+ * Extract JSON string from text that may contain surrounding content.
+ *
+ * Searches for valid JSON in the following order:
+ * 1. Direct parse of the entire text
+ * 2. JSON within markdown code blocks (```json ... ``` or ``` ... ```)
+ * 3. JSON object pattern ({ ... })
+ * 4. JSON array pattern ([ ... ])
+ *
+ * @param text - Text that may contain JSON
+ * @returns Extracted JSON string or null if none found
+ *
+ * @example
+ * ```typescript
+ * const response = "Here's the data: {\"name\": \"test\"} Let me know if you need more.";
+ * const json = extractJsonStringFromText(response);
+ * // Returns: '{"name": "test"}'
+ * ```
+ */
+export declare function extractJsonStringFromText(text: string): string | null;
+/**
+ * Extract and parse JSON from mixed text content.
+ *
+ * Useful for parsing AI responses that contain JSON within prose.
+ * Combines extraction and parsing in one step.
+ *
+ * @param text - Text that may contain JSON
+ * @returns Parsed JSON value or null if not found/invalid
+ *
+ * @example
+ * ```typescript
+ * const response = `
+ *   Here is your configuration:
+ *   \`\`\`json
+ *   {"theme": "dark", "fontSize": 14}
+ *   \`\`\`
+ *   Let me know if you need changes.
+ * `;
+ * const config = extractJsonFromText(response);
+ * // Returns: { theme: "dark", fontSize: 14 }
+ * ```
+ */
+export declare function extractJsonFromText(text: string): unknown | null;
+export type { JsonTypeGuard } from "../../processors/base/types.js";
+import type { JsonTypeGuard } from "../../processors/base/types.js";
+/**
+ * Parse JSON from text with optional type validation.
+ *
+ * Extracts JSON from text and optionally validates it against a type guard.
+ * Useful when you need type-safe parsing of AI responses.
+ *
+ * @param text - Text that may contain JSON
+ * @param validator - Optional type guard to validate the parsed result
+ * @returns Parsed and validated JSON or null if not found/invalid/fails validation
+ *
+ * @example
+ * ```typescript
+ * interface UserConfig {
+ *   theme: string;
+ *   fontSize: number;
+ * }
+ *
+ * function isUserConfig(obj: unknown): obj is UserConfig {
+ *   return (
+ *     typeof obj === 'object' &&
+ *     obj !== null &&
+ *     'theme' in obj &&
+ *     'fontSize' in obj &&
+ *     typeof (obj as UserConfig).theme === 'string' &&
+ *     typeof (obj as UserConfig).fontSize === 'number'
+ *   );
+ * }
+ *
+ * const config = parseJsonFromText<UserConfig>(aiResponse, isUserConfig);
+ * if (config) {
+ *   // config is typed as UserConfig
+ *   console.log(config.theme, config.fontSize);
+ * }
+ * ```
+ */
+export declare function parseJsonFromText<T>(text: string, validator?: JsonTypeGuard<T>): T | null;
+/**
+ * Extract all JSON objects/arrays from text.
+ *
+ * Useful when text contains multiple JSON blocks.
+ *
+ * @param text - Text that may contain multiple JSON values
+ * @returns Array of parsed JSON values
+ *
+ * @example
+ * ```typescript
+ * const text = 'First: {"a": 1} Second: {"b": 2}';
+ * const results = extractAllJsonFromText(text);
+ * // Returns: [{ a: 1 }, { b: 2 }]
+ * ```
+ */
+export declare function extractAllJsonFromText(text: string): unknown[];