@willwade/aac-processors 0.0.3

package/dist/core/stringCasing.d.ts

@@ -0,0 +1,37 @@
+/**
+ * String casing utilities for AAC text processing
+ * Used for detecting and managing text casing across different AAC formats
+ */
+export declare enum StringCasing {
+    LOWER = "lower",
+    SNAKE = "snake",
+    CONSTANT = "constant",
+    CAMEL = "camel",
+    UPPER = "upper",
+    KEBAB = "kebab",
+    CAPITAL = "capital",
+    HEADER = "header",
+    PASCAL = "pascal",
+    TITLE = "title",
+    SENTENCE = "sentence"
+}
+/**
+ * Detects the casing pattern of a given text string
+ * @param text - The text to analyze for casing pattern
+ * @returns StringCasing enum value representing the detected casing
+ */
+export declare function detectCasing(text: string): StringCasing;
+/**
+ * Converts text to the specified casing
+ * @param text - The text to convert
+ * @param targetCasing - The desired casing format
+ * @returns The text converted to the target casing
+ */
+export declare function convertCasing(text: string, targetCasing: StringCasing): string;
+/**
+ * Utility function to check if text is primarily numeric or empty
+ * Used for filtering out non-meaningful text content
+ * @param text - The text to check
+ * @returns True if the text should be considered non-meaningful
+ */
+export declare function isNumericOrEmpty(text: string): boolean;

package/dist/core/stringCasing.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * String casing utilities for AAC text processing
+ * Used for detecting and managing text casing across different AAC formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringCasing = void 0;
+exports.detectCasing = detectCasing;
+exports.convertCasing = convertCasing;
+exports.isNumericOrEmpty = isNumericOrEmpty;
+var StringCasing;
+(function (StringCasing) {
+    StringCasing["LOWER"] = "lower";
+    StringCasing["SNAKE"] = "snake";
+    StringCasing["CONSTANT"] = "constant";
+    StringCasing["CAMEL"] = "camel";
+    StringCasing["UPPER"] = "upper";
+    StringCasing["KEBAB"] = "kebab";
+    StringCasing["CAPITAL"] = "capital";
+    StringCasing["HEADER"] = "header";
+    StringCasing["PASCAL"] = "pascal";
+    StringCasing["TITLE"] = "title";
+    StringCasing["SENTENCE"] = "sentence";
+})(StringCasing || (exports.StringCasing = StringCasing = {}));
+/**
+ * Detects the casing pattern of a given text string
+ * @param text - The text to analyze for casing pattern
+ * @returns StringCasing enum value representing the detected casing
+ */
+function detectCasing(text) {
+    if (!text || text.length === 0)
+        return StringCasing.LOWER;
+    // Remove leading/trailing whitespace for analysis
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return StringCasing.LOWER;
+    // Check for specific patterns
+    // CONSTANT_CASE (ALL_CAPS_WITH_UNDERSCORES)
+    if (/^[A-Z][A-Z0-9_]*$/.test(trimmed) && trimmed.includes('_')) {
+        return StringCasing.CONSTANT;
+    }
+    // snake_case (lowercase_with_underscores)
+    if (/^[a-z][a-z0-9_]*$/.test(trimmed) && trimmed.includes('_')) {
+        return StringCasing.SNAKE;
+    }
+    // kebab-case (lowercase-with-hyphens)
+    if (/^[a-z][a-z0-9-]*$/.test(trimmed) && trimmed.includes('-')) {
+        return StringCasing.KEBAB;
+    }
+    // camelCase (firstWordLowerCaseFollowingWordsCapitalized)
+    if (/^[a-z][a-zA-Z0-9]*$/.test(trimmed) && /[A-Z]/.test(trimmed)) {
+        return StringCasing.CAMEL;
+    }
+    // PascalCase (FirstWordAndFollowingWordsCapitalized)
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(trimmed) &&
+        /[a-z]/.test(trimmed) &&
+        /[A-Z].*[A-Z]/.test(trimmed)) {
+        return StringCasing.PASCAL;
+    }
+    // UPPER CASE (ALL UPPERCASE) - but only if more than one character
+    if (trimmed === trimmed.toUpperCase() && /[A-Z]/.test(trimmed) && trimmed.length > 1) {
+        return StringCasing.UPPER;
+    }
+    // lower case (all lowercase)
+    if (trimmed === trimmed.toLowerCase() && /[a-z]/.test(trimmed)) {
+        return StringCasing.LOWER;
+    }
+    // Title Case (First Letter Of Each Word Capitalized)
+    const words = trimmed.split(/\s+/);
+    if (words.length > 1 &&
+        words.every((word) => word.length > 0 &&
+            word[0] === word[0].toUpperCase() &&
+            (word.length === 1 || word.slice(1) === word.slice(1).toLowerCase()))) {
+        return StringCasing.TITLE;
+    }
+    // Header-Case (First-Letter-Of-Each-Word-Capitalized-With-Hyphens)
+    if (trimmed.includes('-')) {
+        const hyphenWords = trimmed.split('-');
+        if (hyphenWords.length > 1 &&
+            hyphenWords.every((word) => word.length > 0 &&
+                word[0] === word[0].toUpperCase() &&
+                (word.length === 1 || word.slice(1) === word.slice(1).toLowerCase()))) {
+            return StringCasing.HEADER;
+        }
+    }
+    // Sentence case (First letter capitalized, rest lowercase)
+    if (trimmed.length > 1 &&
+        trimmed[0] === trimmed[0].toUpperCase() &&
+        trimmed.slice(1) === trimmed.slice(1).toLowerCase()) {
+        return StringCasing.SENTENCE;
+    }
+    // Capital case (Just first letter capitalized, may have mixed case after)
+    if (trimmed[0] === trimmed[0].toUpperCase()) {
+        return StringCasing.CAPITAL;
+    }
+    // Default fallback
+    return StringCasing.LOWER;
+}
+/**
+ * Converts text to the specified casing
+ * @param text - The text to convert
+ * @param targetCasing - The desired casing format
+ * @returns The text converted to the target casing
+ */
+function convertCasing(text, targetCasing) {
+    if (!text || text.length === 0)
+        return text;
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return text;
+    switch (targetCasing) {
+        case StringCasing.LOWER:
+            return trimmed.toLowerCase();
+        case StringCasing.UPPER:
+            return trimmed.toUpperCase();
+        case StringCasing.CAPITAL:
+            return trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+        case StringCasing.SENTENCE:
+            return trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+        case StringCasing.TITLE:
+            return trimmed
+                .split(/\s+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join(' ');
+        case StringCasing.CAMEL:
+            return trimmed
+                .split(/[\s_-]+/)
+                .map((word, index) => index === 0
+                ? word.toLowerCase()
+                : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('');
+        case StringCasing.PASCAL:
+            return trimmed
+                .split(/[\s_-]+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('');
+        case StringCasing.SNAKE:
+            return trimmed
+                .split(/[\s-]+/)
+                .map((word) => word.toLowerCase())
+                .join('_');
+        case StringCasing.CONSTANT:
+            return trimmed
+                .split(/[\s-]+/)
+                .map((word) => word.toUpperCase())
+                .join('_');
+        case StringCasing.KEBAB:
+            return trimmed
+                .split(/[\s_]+/)
+                .map((word) => word.toLowerCase())
+                .join('-');
+        case StringCasing.HEADER:
+            return trimmed
+                .split(/[\s_]+/)
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join('-');
+        default:
+            return trimmed;
+    }
+}
+/**
+ * Utility function to check if text is primarily numeric or empty
+ * Used for filtering out non-meaningful text content
+ * @param text - The text to check
+ * @returns True if the text should be considered non-meaningful
+ */
+function isNumericOrEmpty(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= 1)
+        return true;
+    // Check if the entire string is numeric
+    const numericValue = parseInt(trimmed, 10);
+    return !isNaN(numericValue) && numericValue.toString() === trimmed;
+}

package/dist/core/treeStructure.d.ts

@@ -0,0 +1,190 @@
+import { AACButton as IAACButton, AACPage as IAACPage, AACTree as IAACTree, AACStyle } from '../types/aac';
+export declare enum AACSemanticCategory {
+    COMMUNICATION = "communication",// Speech, text output
+    NAVIGATION = "navigation",// Page/grid navigation
+    TEXT_EDITING = "text_editing",// Text manipulation
+    SYSTEM_CONTROL = "system_control",// Device/app control
+    MEDIA = "media",// Audio/video playback
+    ACCESSIBILITY = "accessibility",// Switch scanning, etc.
+    CUSTOM = "custom"
+}
+export declare enum AACSemanticIntent {
+    SPEAK_TEXT = "SPEAK_TEXT",
+    SPEAK_IMMEDIATE = "SPEAK_IMMEDIATE",
+    STOP_SPEECH = "STOP_SPEECH",
+    INSERT_TEXT = "INSERT_TEXT",
+    NAVIGATE_TO = "NAVIGATE_TO",
+    GO_BACK = "GO_BACK",
+    GO_HOME = "GO_HOME",
+    DELETE_WORD = "DELETE_WORD",
+    DELETE_CHARACTER = "DELETE_CHARACTER",
+    CLEAR_TEXT = "CLEAR_TEXT",
+    COPY_TEXT = "COPY_TEXT",
+    PASTE_TEXT = "PASTE_TEXT",
+    SEND_KEYS = "SEND_KEYS",
+    MOUSE_CLICK = "MOUSE_CLICK",
+    PLAY_SOUND = "PLAY_SOUND",
+    PLAY_VIDEO = "PLAY_VIDEO",
+    SCAN_NEXT = "SCAN_NEXT",
+    SCAN_SELECT = "SCAN_SELECT",
+    PLATFORM_SPECIFIC = "PLATFORM_SPECIFIC"
+}
+export interface AACSemanticAction {
+    category?: AACSemanticCategory;
+    intent: AACSemanticIntent | string;
+    text?: string;
+    targetId?: string;
+    audioData?: Buffer;
+    richText?: {
+        text: string;
+        symbols?: Array<{
+            text: string;
+            image?: string;
+        }>;
+        grammar?: {
+            partOfSpeech?: string;
+            person?: string;
+            number?: string;
+            verbState?: string;
+        };
+    };
+    parameters?: {
+        [key: string]: any;
+    };
+    platformData?: {
+        grid3?: {
+            commandId: string;
+            parameters: {
+                [key: string]: any;
+            };
+        };
+        astericsGrid?: {
+            modelName: string;
+            properties: {
+                [key: string]: any;
+            };
+        };
+        touchChat?: {
+            actionCode: number;
+            actionData: string;
+        };
+        snap?: {
+            navigatePageId?: number;
+            elementReferenceId?: number;
+        };
+        applePanels?: {
+            actionType: string;
+            parameters: {
+                [key: string]: any;
+            };
+        };
+    };
+    fallback?: {
+        type: 'SPEAK' | 'NAVIGATE' | 'ACTION';
+        message?: string;
+        targetPageId?: string;
+    };
+}
+export declare class AACButton implements IAACButton {
+    id: string;
+    label: string;
+    message: string;
+    semanticAction?: AACSemanticAction;
+    targetPageId?: string;
+    style?: AACStyle;
+    audioRecording?: {
+        id?: number;
+        data?: Buffer;
+        identifier?: string;
+        metadata?: string;
+    };
+    contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell';
+    contentSubType?: string;
+    image?: string;
+    resolvedImageEntry?: string;
+    symbolLibrary?: string;
+    symbolPath?: string;
+    x?: number;
+    y?: number;
+    columnSpan?: number;
+    rowSpan?: number;
+    scanBlocks?: number[];
+    visibility?: 'Visible' | 'Hidden' | 'Disabled' | 'PointerAndTouchOnly' | 'Empty';
+    directActivate?: boolean;
+    audioDescription?: string;
+    parameters?: {
+        [key: string]: any;
+    };
+    constructor({ id, label, message, targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, x, y, columnSpan, rowSpan, scanBlocks, visibility, directActivate, parameters, type, action, }: {
+        id: string;
+        label?: string;
+        message?: string;
+        targetPageId?: string;
+        semanticAction?: AACSemanticAction;
+        audioRecording?: {
+            id?: number;
+            data?: Buffer;
+            identifier?: string;
+            metadata?: string;
+        };
+        style?: AACStyle;
+        contentType?: 'Normal' | 'AutoContent' | 'Workspace' | 'LiveCell';
+        contentSubType?: string;
+        image?: string;
+        resolvedImageEntry?: string;
+        x?: number;
+        y?: number;
+        columnSpan?: number;
+        rowSpan?: number;
+        scanBlocks?: number[];
+        visibility?: 'Visible' | 'Hidden' | 'Disabled' | 'PointerAndTouchOnly' | 'Empty';
+        directActivate?: boolean;
+        parameters?: {
+            [key: string]: any;
+        };
+        type?: 'SPEAK' | 'NAVIGATE' | 'ACTION';
+        action?: {
+            type: 'SPEAK' | 'NAVIGATE' | 'ACTION';
+            targetPageId?: string;
+            message?: string;
+        } | null;
+    });
+    get type(): 'SPEAK' | 'NAVIGATE' | 'ACTION' | undefined;
+    get action(): {
+        type: 'SPEAK' | 'NAVIGATE' | 'ACTION';
+        targetPageId?: string;
+        message?: string;
+    } | null;
+}
+export declare class AACPage implements IAACPage {
+    id: string;
+    name: string;
+    grid: Array<Array<AACButton | null>>;
+    buttons: AACButton[];
+    parentId: string | null;
+    style?: AACStyle;
+    constructor({ id, name, grid, buttons, parentId, style, }: {
+        id: string;
+        name?: string;
+        grid?: Array<Array<AACButton | null>> | {
+            columns: number;
+            rows: number;
+        };
+        buttons?: AACButton[];
+        parentId?: string | null;
+        style?: AACStyle;
+    });
+    addButton(button: AACButton): void;
+}
+export declare class AACTree implements IAACTree {
+    pages: {
+        [key: string]: AACPage;
+    };
+    private _rootId;
+    get rootId(): string | null;
+    set rootId(id: string | null);
+    constructor();
+    addPage(page: AACPage): void;
+    getPage(id: string): AACPage | undefined;
+    traverse(callback: (page: AACPage) => void): void;
+}

package/dist/core/treeStructure.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AACTree = exports.AACPage = exports.AACButton = exports.AACSemanticIntent = exports.AACSemanticCategory = void 0;
+// Semantic action categories for cross-platform compatibility
+var AACSemanticCategory;
+(function (AACSemanticCategory) {
+    AACSemanticCategory["COMMUNICATION"] = "communication";
+    AACSemanticCategory["NAVIGATION"] = "navigation";
+    AACSemanticCategory["TEXT_EDITING"] = "text_editing";
+    AACSemanticCategory["SYSTEM_CONTROL"] = "system_control";
+    AACSemanticCategory["MEDIA"] = "media";
+    AACSemanticCategory["ACCESSIBILITY"] = "accessibility";
+    AACSemanticCategory["CUSTOM"] = "custom";
+})(AACSemanticCategory || (exports.AACSemanticCategory = AACSemanticCategory = {}));
+// Semantic intents within each category
+var AACSemanticIntent;
+(function (AACSemanticIntent) {
+    // Communication
+    AACSemanticIntent["SPEAK_TEXT"] = "SPEAK_TEXT";
+    AACSemanticIntent["SPEAK_IMMEDIATE"] = "SPEAK_IMMEDIATE";
+    AACSemanticIntent["STOP_SPEECH"] = "STOP_SPEECH";
+    AACSemanticIntent["INSERT_TEXT"] = "INSERT_TEXT";
+    // Navigation
+    AACSemanticIntent["NAVIGATE_TO"] = "NAVIGATE_TO";
+    AACSemanticIntent["GO_BACK"] = "GO_BACK";
+    AACSemanticIntent["GO_HOME"] = "GO_HOME";
+    // Text Editing
+    AACSemanticIntent["DELETE_WORD"] = "DELETE_WORD";
+    AACSemanticIntent["DELETE_CHARACTER"] = "DELETE_CHARACTER";
+    AACSemanticIntent["CLEAR_TEXT"] = "CLEAR_TEXT";
+    AACSemanticIntent["COPY_TEXT"] = "COPY_TEXT";
+    AACSemanticIntent["PASTE_TEXT"] = "PASTE_TEXT";
+    // System Control
+    AACSemanticIntent["SEND_KEYS"] = "SEND_KEYS";
+    AACSemanticIntent["MOUSE_CLICK"] = "MOUSE_CLICK";
+    // Media
+    AACSemanticIntent["PLAY_SOUND"] = "PLAY_SOUND";
+    AACSemanticIntent["PLAY_VIDEO"] = "PLAY_VIDEO";
+    // Accessibility
+    AACSemanticIntent["SCAN_NEXT"] = "SCAN_NEXT";
+    AACSemanticIntent["SCAN_SELECT"] = "SCAN_SELECT";
+    // Custom
+    AACSemanticIntent["PLATFORM_SPECIFIC"] = "PLATFORM_SPECIFIC";
+})(AACSemanticIntent || (exports.AACSemanticIntent = AACSemanticIntent = {}));
+class AACButton {
+    constructor({ id, label = '', message = '', targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, x, y, columnSpan, rowSpan, scanBlocks, visibility, directActivate, parameters, 
+    // Legacy input support
+    type, action, }) {
+        this.id = id;
+        this.label = label;
+        this.message = message;
+        this.targetPageId = targetPageId;
+        this.semanticAction = semanticAction;
+        this.audioRecording = audioRecording;
+        this.style = style;
+        this.contentType = contentType;
+        this.contentSubType = contentSubType;
+        this.image = image;
+        this.resolvedImageEntry = resolvedImageEntry;
+        this.x = x;
+        this.y = y;
+        this.columnSpan = columnSpan;
+        this.rowSpan = rowSpan;
+        this.scanBlocks = scanBlocks;
+        this.visibility = visibility;
+        this.directActivate = directActivate;
+        this.parameters = parameters;
+        // Legacy mapping: if no semanticAction provided, derive from legacy `action` first
+        if (!this.semanticAction && action) {
+            if (action.type === 'NAVIGATE' && (action.targetPageId || this.targetPageId)) {
+                if (!this.targetPageId)
+                    this.targetPageId = action.targetPageId;
+                this.semanticAction = {
+                    category: AACSemanticCategory.NAVIGATION,
+                    intent: AACSemanticIntent.NAVIGATE_TO,
+                    targetId: this.targetPageId,
+                    fallback: { type: 'NAVIGATE', targetPageId: this.targetPageId },
+                };
+            }
+            else if (action.type === 'SPEAK') {
+                const text = action.message || this.message || this.label || '';
+                if (!this.message)
+                    this.message = text;
+                this.semanticAction = {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text,
+                    fallback: { type: 'SPEAK', message: text },
+                };
+            }
+            else {
+                this.semanticAction = {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    fallback: { type: 'ACTION' },
+                };
+            }
+        }
+        // Legacy mapping: if still no semanticAction and `type` provided
+        if (!this.semanticAction && type) {
+            if (type === 'NAVIGATE' && this.targetPageId) {
+                this.semanticAction = {
+                    category: AACSemanticCategory.NAVIGATION,
+                    intent: AACSemanticIntent.NAVIGATE_TO,
+                    targetId: this.targetPageId,
+                    fallback: { type: 'NAVIGATE', targetPageId: this.targetPageId },
+                };
+            }
+            else if (type === 'SPEAK') {
+                const text = this.message || this.label || '';
+                this.semanticAction = {
+                    category: AACSemanticCategory.COMMUNICATION,
+                    intent: AACSemanticIntent.SPEAK_TEXT,
+                    text,
+                    fallback: { type: 'SPEAK', message: text },
+                };
+            }
+            else {
+                this.semanticAction = {
+                    category: AACSemanticCategory.SYSTEM_CONTROL,
+                    intent: AACSemanticIntent.PLATFORM_SPECIFIC,
+                    fallback: { type: 'ACTION' },
+                };
+            }
+        }
+    }
+    // Legacy compatibility properties
+    get type() {
+        if (this.semanticAction) {
+            const i = String(this.semanticAction.intent);
+            if (i === 'NAVIGATE_TO')
+                return 'NAVIGATE';
+            if (i === 'SPEAK_TEXT' || i === 'SPEAK_IMMEDIATE')
+                return 'SPEAK';
+            return 'ACTION';
+        }
+        if (this.targetPageId)
+            return 'NAVIGATE';
+        if (this.message)
+            return 'SPEAK';
+        return 'SPEAK';
+    }
+    get action() {
+        const t = this.type;
+        if (!t)
+            return null;
+        if (t === 'SPEAK' && !this.message && !this.label && !this.semanticAction) {
+            return null;
+        }
+        return { type: t, targetPageId: this.targetPageId, message: this.message };
+    }
+}
+exports.AACButton = AACButton;
+class AACPage {
+    constructor({ id, name = '', grid = [], buttons = [], parentId = null, style, }) {
+        this.id = id;
+        this.name = name;
+        if (Array.isArray(grid)) {
+            this.grid = grid;
+        }
+        else if (grid && typeof grid === 'object' && 'columns' in grid && 'rows' in grid) {
+            const cols = grid.columns;
+            const rows = grid.rows;
+            this.grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => null));
+        }
+        else {
+            this.grid = [];
+        }
+        this.buttons = buttons;
+        this.parentId = parentId;
+        this.style = style;
+    }
+    addButton(button) {
+        this.buttons.push(button);
+    }
+}
+exports.AACPage = AACPage;
+class AACTree {
+    get rootId() {
+        return this._rootId;
+    }
+    set rootId(id) {
+        this._rootId = id;
+    }
+    constructor() {
+        this.pages = {};
+        this._rootId = null;
+    }
+    addPage(page) {
+        this.pages[page.id] = page;
+        if (!this._rootId)
+            this._rootId = page.id;
+    }
+    getPage(id) {
+        return this.pages[id];
+    }
+    traverse(callback) {
+        const queue = Object.keys(this.pages);
+        const visited = new Set();
+        while (queue.length > 0) {
+            const id = queue.shift();
+            if (!id || visited.has(id))
+                continue;
+            visited.add(id);
+            const page = this.pages[id];
+            if (page) {
+                callback(page);
+                // Add child pages to queue
+                page.buttons
+                    .filter((b) => {
+                    const i = String(b.semanticAction?.intent);
+                    return i === 'NAVIGATE_TO' || !!b.semanticAction?.targetId || !!b.targetPageId;
+                })
+                    .forEach((b) => {
+                    const target = b.semanticAction?.targetId || b.targetPageId;
+                    if (target)
+                        queue.push(target);
+                });
+            }
+        }
+    }
+}
+exports.AACTree = AACTree;

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export * from './core/treeStructure';
+export * from './core/baseProcessor';
+export * from './core/stringCasing';
+export * from './processors';
+import { BaseProcessor } from './core/baseProcessor';
+/**
+ * Factory function to get the appropriate processor for a file extension
+ * @param filePathOrExtension - File path or extension (e.g., '.dot', '/path/to/file.obf')
+ * @returns The appropriate processor instance
+ * @throws Error if the file extension is not supported
+ */
+export declare function getProcessor(filePathOrExtension: string): BaseProcessor;
+/**
+ * Get all supported file extensions
+ * @returns Array of supported file extensions
+ */
+export declare function getSupportedExtensions(): string[];
+/**
+ * Check if a file extension is supported
+ * @param extension - File extension to check
+ * @returns True if the extension is supported
+ */
+export declare function isExtensionSupported(extension: string): boolean;