mepcli 0.5.5 → 0.6.1

package/README.md

@@ -1,12 +1,14 @@
 # Mep
 
-**Mep** is a minimalist and zero-dependency library for creating interactive command-line prompts in Node.js. It focuses on simplicity, modern design, and robust input handling, including support for cursor movement and input validation.
+**Mep** is a lightweight and zero-dependency library for creating interactive command-line prompts in Node.js. It focuses on simplicity, modern design, and robust input handling, including support for cursor movement and input validation.
+
+A **CodeTease** project. 
 
 ## Features
 
 - **Zero Dependency:** Keeps your project clean and fast.
-- **Comprehensive Prompts:** Includes `text`, `password`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `date`, `file`, `multiSelect`, `autocomplete`, `sort`, `table`, `rating`, `editor`, `tree`, and `keypress`.
-- **Mouse Support:** Built-in support for mouse interaction (SGR 1006 protocol). Scroll to navigate lists or change values; click to select.
+- **Comprehensive Prompts:** Includes `text`, `password`, `secret`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `range`, `date`, `file`, `multiSelect`, `autocomplete`, `sort`, `transfer`, `cron`, `table`, `rating`, `editor`, `tree`, `keypress`, `color`, `grid`, and `calendar`.
+- **Mouse Support:** Built-in support for mouse interaction (SGR 1006 protocol). Scroll to navigate lists or change values.
 - **Responsive Input:** Supports cursor movement (Left/Right) and character insertion/deletion in text-based prompts.
 - **Validation:** Built-in support for input validation (sync and async) with custom error messages.
 - **Elegant Look:** Uses ANSI colors for a clean, modern CLI experience.
@@ -104,13 +106,79 @@ async function main() {
         ]
     });
 
+    // Color (RGB Picker)
+    const color = await MepCLI.color({
+        message: "Choose theme color:",
+        initial: "#3B82F6"
+    });
+
+    // Grid (Matrix Selection)
+    const permissions = await MepCLI.grid({
+        message: "Manage Permissions:",
+        rows: ["Admin", "User", "Guest"],
+        columns: ["Read", "Write", "Delete"]
+    });
+
+    // Calendar (Date/Range Picker)
+    const booking = await MepCLI.calendar({
+        message: "Select dates:",
+        mode: "range"
+    });
+
     // Editor (External text editor)
     const bio = await MepCLI.editor({
         message: "Write your biography:",
         extension: ".md"
     });
 
-    console.log({ name, age, newsletter, lang, tools, stars, city, priorities, user, bio });
+    // Form (Multi-field input)
+    const userDetails = await MepCLI.form({
+        message: "User Details:",
+        fields: [
+            { name: "firstname", message: "First Name", initial: "John" },
+            { name: "lastname", message: "Last Name", validate: (v) => v.length > 0 ? true : "Required" },
+            { name: "email", message: "Email", validate: (v) => v.includes("@") || "Invalid email" }
+        ]
+    });
+
+    // Snippet (Template filling)
+    const commitMsg = await MepCLI.snippet({
+        message: "Commit Message:",
+        template: "feat(${scope}): ${message}",
+        values: {
+            scope: "core"
+        }
+    });
+
+    // Code Prompt (JSON/YAML Editing)
+    const config = await MepCLI.code({
+        message: "Configure Server:",
+        language: "json",
+        template: `
+{
+  "host": "\${host}",
+  "port": \${port},
+  "debug": \${debug}
+}
+`
+    });
+
+    // Tree Select (Hierarchical Multi-Select)
+    const selectedFiles = await MepCLI.treeSelect({
+        message: "Select files to backup:",
+        data: [
+            {
+                title: "src",
+                value: "src",
+                children: [
+                    { title: "index.ts", value: "src/index.ts" },
+                    { title: "utils.ts", value: "src/utils.ts" }
+                ]
+            }
+        ]
+    });
+
+    console.log({ name, age, newsletter, lang, tools, stars, city, priorities, user, color, permissions, booking, bio, userDetails, commitMsg, config, selectedFiles });
 }
 
 main();
@@ -122,6 +190,7 @@ main();
 
 *   `text(options)` - Single line or multiline text input.
 *   `password(options)` - Masked text input.
+*   `secret(options)` - Completely hidden text input.
 *   `number(options)` - Numeric input with increment/decrement support.
 *   `confirm(options)` - Yes/No question.
 *   `toggle(options)` - On/Off switch.
@@ -130,15 +199,27 @@ main();
 *   `checkbox(options)` - Classic checkbox selection.
 *   `list(options)` - Enter a list of tags/strings.
 *   `slider(options)` - Select a number within a range using a visual slider.
+*   `range(options)` - Select a numerical range (min/max) using a dual-handle slider.
 *   `rating(options)` - Star rating input.
 *   `date(options)` - Date and time picker.
+*   `color(options)` - RGB color picker with hex output and TrueColor preview.
+*   `grid(options)` - 2D matrix selection (rows x columns).
+*   `calendar(options)` - Interactive monthly calendar for single dates or ranges.
 *   `file(options)` - File system navigator and selector.
 *   `autocomplete(options)` - Searchable selection with async suggestions.
 *   `sort(options)` - Reorder a list of items.
+*   `transfer(options)` - Move items between two lists (Source/Target).
+*   `cron(options)` - Visually build a cron schedule (Minute, Hour, Day, Month, Weekday).
 *   `table(options)` - Display data in columns and select rows.
 *   `tree(options)` - Navigate and select from a hierarchical tree structure.
 *   `keypress(options)` - Wait for a specific key press or any key.
 *   `editor(options)` - Launch an external editor (Vim, Nano, Notepad, etc.) to capture multi-line content.
+*   `form(options)` - Multi-field input form with navigation.
+*   `snippet(options)` - Template string filling with variable navigation.
+*   `code(options)` - Edit variables within a code block (JSON/YAML). Syntax highlighting is supported (Experimental).
+*   `treeSelect(options)` - Hierarchical multi-selection with cascading checkboxes.
+*   `spam(options)` - Confirm a dangerous action or fun.
+*   `wait(options)` - Wait for a specified number of seconds.
 *   `spinner(message)` - Returns a `Spinner` instance for manual control (`start`, `stop`, `update`, `success`, `error`).
 
 ## Mouse Support
@@ -146,14 +227,100 @@ main();
 MepCLI automatically detects modern terminals and enables **Mouse Tracking** (using SGR 1006 protocol).
 
 *   **Scrolling:**
-    *   `select`, `multiSelect`, `checkbox`, `autocomplete`, `table`, `tree`: Scroll to navigate the list.
-    *   `number`, `slider`, `rating`, `date`: Scroll to increment/decrement values or fields.
+    *   `select`, `multiSelect`, `checkbox`, `autocomplete`, `table`, `tree`, `transfer`: Scroll to navigate the list.
+    *   `form`, `snippet`, `cron`: Scroll to navigate between fields or values.
+    *   `number`, `slider`, `range`, `rating`, `date`: Scroll to increment/decrement values or fields.
     *   `sort`: Scroll to navigate or reorder items (when grabbed).
     *   `toggle`, `confirm`: Scroll to toggle the state.
+    *   `calendar`: Scroll to switch months.
+    *   `color`: Scroll to adjust RGB channels.
+    *   `grid`: Scroll to move selection.
 *   **Configuration:**
     *   Mouse support is enabled by default if the terminal supports it.
     *   You can explicitly disable it per prompt by setting `mouse: false` in the options.
 
+## Advanced Shortcuts
+
+### Calendar Prompt
+
+Mep's Calendar prompt supports advanced navigation and selection shortcuts for power users.
+
+*   **Keyboard:**
+    *   `Arrow Keys`: Move cursor day by day.
+    *   `PageUp` / `PageDown`: Jump to previous/next **Month**.
+    *   `Ctrl + Up` / `Ctrl + Down`: Jump to previous/next **Year**.
+    *   `Home` / `End`: Jump to the first/last day of the current month.
+    *   `t`: Jump immediately to **Today**.
+    *   `Enter`: Select date (or start/end of range).
+
+*   **Mouse:**
+    *   `Scroll`: Navigate **Months**.
+    *   `Ctrl + Scroll`: Adjust the selected **Day** (cursor movement).
+
+### Color Prompt
+
+*   **Keyboard:**
+    *   `Tab`: Switch between RGB channels.
+    *   `Up` / `Down`: Move between channels.
+    *   `Left` / `Right`: Adjust current channel value.
+    *   `Shift + Left` / `Shift + Right`: Fast adjust current channel value.
+
+*   **Mouse:**
+    *   `Scroll`: Adjust the current channel value.
+    *   `Ctrl + Scroll`: Fast adjust.
+
+### Checkbox Prompt
+
+*   **Keyboard:**
+    *   `Space`: Toggle selection.
+    *   `a`: Select **All**.
+    *   `x` / `n`: Select **None**.
+    *   `i`: **Invert** selection.
+
+### MultiSelect Prompt
+
+*   **Keyboard:**
+    *   `Space`: Toggle selection.
+    *   `Ctrl + A`: Select **All** (Visible).
+    *   `Ctrl + X`: Deselect **All** (Visible).
+    *   `Typing`: Filter list.
+
+### Transfer Prompt
+
+*   **Keyboard:**
+    *   `Tab` / `Left` / `Right`: Switch focus between Source and Target.
+    *   `Space`: Move selected item.
+    *   `a` / `>`: Move **All** to Target.
+    *   `r` / `<`: Move **All** to Source (Reset).
+
+### Tree & TreeSelect Prompt
+
+*   **Keyboard:**
+    *   `Right`: Expand folder or jump to child.
+    *   `Left`: Collapse folder or jump to parent.
+    *   `Space`: Toggle expansion (Tree) or Checkbox (TreeSelect).
+    *   `e`: **Expand** all recursively.
+    *   `c`: **Collapse** all recursively.
+
+### Grid Prompt
+
+The Grid prompt (Matrix selection) includes robust shortcuts for bulk actions.
+
+*   **Keyboard:**
+    *   `Arrow Keys`: Move cursor.
+    *   `PageUp` / `PageDown`: Jump to the first/last **Row**.
+    *   `Home` / `End`: Jump to the first/last **Column**.
+    *   `Space`: Toggle current cell.
+    *   `r`: Toggle entire **Row**.
+    *   `c`: Toggle entire **Column**.
+    *   `a`: Select **All**.
+    *   `x`: Deselect **All** (None).
+    *   `i`: **Invert** selection.
+
+*   **Mouse:**
+    *   `Scroll`: Vertical navigation (Rows).
+    *   `Shift + Scroll`: Horizontal navigation (Columns).
+
 ## License
 
 This project is under the **MIT License**.

package/dist/ansi.d.ts

@@ -8,6 +8,7 @@ export declare const ANSI: {
     DIM: string;
     ITALIC: string;
     UNDERLINE: string;
+    REVERSE: string;
     FG_GREEN: string;
     FG_CYAN: string;
     FG_YELLOW: string;

package/dist/ansi.js

@@ -11,6 +11,7 @@ exports.ANSI = {
     DIM: '\x1b[2m',
     ITALIC: '\x1b[3m',
     UNDERLINE: '\x1b[4m',
+    REVERSE: '\x1b[7m',
     // Colors
     FG_GREEN: '\x1b[32m',
     FG_CYAN: '\x1b[36m',

package/dist/base.d.ts

@@ -2,8 +2,7 @@ import { MouseEvent } from './types';
 import { detectCapabilities } from './utils';
 /**
  * Abstract base class for all prompts.
- * Handles common logic like stdin management, raw mode, and cleanup
- * to enforce DRY (Don't Repeat Yourself) principles.
+ * Implements a Robust Linear Scan Diffing Engine.
  */
 export declare abstract class Prompt<T, O> {
     protected options: O;
@@ -15,48 +14,20 @@ export declare abstract class Prompt<T, O> {
     private _inputParser;
     private _onKeyHandler?;
     private _onDataHandler?;
-    protected lastRenderHeight: number;
     protected lastRenderLines: string[];
+    protected lastRenderHeight: number;
     protected capabilities: ReturnType<typeof detectCapabilities>;
     constructor(options: O);
-    /**
-     * Renders the UI. Must be implemented by subclasses.
-     * @param firstRender Indicates if this is the initial render.
-     */
     protected abstract render(firstRender: boolean): void;
-    /**
-     * Handles specific key inputs. Must be implemented by subclasses.
-     * @param char The string representation of the key.
-     * @param key The raw buffer.
-     */
     protected abstract handleInput(char: string, key: Buffer): void;
-    /**
-     * Optional method to handle mouse events.
-     * Subclasses can override this to implement mouse interaction.
-     */
-    protected handleMouse(event: MouseEvent): void;
+    protected handleMouse(_event: MouseEvent): void;
     protected print(text: string): void;
-    /**
-     * Starts the prompt interaction.
-     * Sets up raw mode and listeners, returning a Promise.
-     */
     run(): Promise<T>;
-    /**
-     * Cleans up listeners and restores stdin state.
-     */
     protected cleanup(): void;
-    /**
-     * Submits the final value and resolves the promise.
-     */
     protected submit(result: T): void;
     /**
-     * Render Method with Diffing (Virtual DOM for CLI).
-     * Calculates new lines, compares with old lines, and updates only changed parts.
-     */
-    /**
-     * Renders the current frame by clearing the previous output and writing the new content.
-     * This approach ("Move Up -> Erase Down -> Print") is more robust against artifacts
-     * than line-by-line diffing, especially when the number of lines changes (e.g., filtering).
+     * Renders the frame using a linear scan diffing algorithm.
+     * Prevents flicker and handles height changes (expand/collapse) robustly.
      */
     protected renderFrame(content: string): void;
     protected stripAnsi(str: string): string;

package/dist/base.js

@@ -6,32 +6,22 @@ const input_1 = require("./input");
 const utils_1 = require("./utils");
 /**
  * Abstract base class for all prompts.
- * Handles common logic like stdin management, raw mode, and cleanup
- * to enforce DRY (Don't Repeat Yourself) principles.
+ * Implements a Robust Linear Scan Diffing Engine.
  */
 class Prompt {
     constructor(options) {
-        // Smart Cursor State
-        this.lastRenderHeight = 0;
         this.lastRenderLines = [];
+        this.lastRenderHeight = 0;
         this.options = options;
         this.stdin = process.stdin;
         this.stdout = process.stdout;
         this._inputParser = new input_1.InputParser();
         this.capabilities = (0, utils_1.detectCapabilities)();
     }
-    /**
-     * Optional method to handle mouse events.
-     * Subclasses can override this to implement mouse interaction.
-     */
-    handleMouse(event) { }
+    handleMouse(_event) { }
     print(text) {
         this.stdout.write(text);
     }
-    /**
-     * Starts the prompt interaction.
-     * Sets up raw mode and listeners, returning a Promise.
-     */
     run() {
         return new Promise((resolve, reject) => {
             this._resolve = resolve;
@@ -41,24 +31,15 @@ class Prompt {
             }
             this.stdin.resume();
             this.stdin.setEncoding('utf8');
-            // Enable Mouse Tracking if supported and requested
-            // Default to true if capabilities support it, unless explicitly disabled in options
             const shouldEnableMouse = this.options.mouse !== false && this.capabilities.hasMouse;
             if (shouldEnableMouse) {
                 this.print(ansi_1.ANSI.SET_ANY_EVENT_MOUSE + ansi_1.ANSI.SET_SGR_EXT_MODE_MOUSE);
             }
-            // Initial render: Default to hidden cursor (good for menus)
-            // Subclasses like TextPrompt will explicitly show it if needed.
-            if (this.capabilities.isCI) {
-                // In CI, maybe don't hide cursor or do nothing?
-                // But for now follow standard flow.
-            }
             this.print(ansi_1.ANSI.HIDE_CURSOR);
+            // Initial render
             this.render(true);
-            // Setup Input Parser Listeners
             this._onKeyHandler = (char, buffer) => {
-                // Global Exit Handler (Ctrl+C)
-                if (char === '\u0003') {
+                if (char === '\u0003') { // Ctrl+C
                     this.cleanup();
                     this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
                     if (this._reject)
@@ -68,7 +49,6 @@ class Prompt {
                 this.handleInput(char, buffer);
             };
             this._inputParser.on('keypress', this._onKeyHandler);
-            // Listen to mouse events
             this._inputParser.on('mouse', (event) => {
                 this.handleMouse(event);
             });
@@ -78,9 +58,6 @@ class Prompt {
             this.stdin.on('data', this._onDataHandler);
         });
     }
-    /**
-     * Cleans up listeners and restores stdin state.
-     */
     cleanup() {
         if (this._onDataHandler) {
             this.stdin.removeListener('data', this._onDataHandler);
@@ -88,8 +65,6 @@ class Prompt {
         if (this._onKeyHandler) {
             this._inputParser.removeListener('keypress', this._onKeyHandler);
         }
-        // Cleanup mouse listener - though InputParser is instance specific, so it's fine.
-        // Disable Mouse Tracking
         this.print(ansi_1.ANSI.DISABLE_MOUSE);
         if (typeof this.stdin.setRawMode === 'function') {
             this.stdin.setRawMode(false);
@@ -97,51 +72,74 @@ class Prompt {
         this.stdin.pause();
         this.print(ansi_1.ANSI.SHOW_CURSOR);
     }
-    /**
-     * Submits the final value and resolves the promise.
-     */
     submit(result) {
         this.cleanup();
         this.print('\n');
         if (this._resolve)
             this._resolve(result);
     }
-    // --- Rendering Utilities ---
-    /**
-     * Render Method with Diffing (Virtual DOM for CLI).
-     * Calculates new lines, compares with old lines, and updates only changed parts.
-     */
     /**
-     * Renders the current frame by clearing the previous output and writing the new content.
-     * This approach ("Move Up -> Erase Down -> Print") is more robust against artifacts
-     * than line-by-line diffing, especially when the number of lines changes (e.g., filtering).
+     * Renders the frame using a linear scan diffing algorithm.
+     * Prevents flicker and handles height changes (expand/collapse) robustly.
      */
     renderFrame(content) {
         const width = this.stdout.columns || 80;
         const rawLines = content.split('\n');
-        // Truncate each line to fit terminal width to avoid wrapping issues
+        // Truncate lines to prevent wrapping artifacts
         const newLines = rawLines.map(line => this.truncate(line, width));
-        // 1. Move cursor to the start of the current line
-        this.print(ansi_1.ANSI.CURSOR_LEFT);
-        // 2. Move cursor up to the top of the previously rendered frame
-        if (this.lastRenderHeight > 0) {
-            // If the previous render had multiple lines, move up to the first line
-            if (this.lastRenderHeight > 1) {
-                this.print(`\x1b[${this.lastRenderHeight - 1}A`);
-            }
+        // 1. First Render Case
+        if (this.lastRenderLines.length === 0) {
+            this.print(newLines.join('\n'));
+            this.lastRenderLines = newLines;
+            this.lastRenderHeight = newLines.length;
+            return;
+        }
+        let outputBuffer = '';
+        // 2. Return Cursor to the Top of the Prompt
+        if (this.lastRenderHeight > 1) {
+            outputBuffer += `\x1b[${this.lastRenderHeight - 1}A`;
         }
-        // 3. Clear everything from the cursor down
-        // This ensures all previous content (including "ghost" lines) is removed
-        this.print(ansi_1.ANSI.ERASE_DOWN);
-        // 4. Print the new frame content
+        outputBuffer += '\r'; // Ensure column 0
+        // 3. Linear Scan & Update
         for (let i = 0; i < newLines.length; i++) {
-            this.print(newLines[i]);
-            // Add newline character between lines, but not after the last line
-            if (i < newLines.length - 1) {
-                this.print('\n');
+            const newLine = newLines[i];
+            // Logic for moving to the next line
+            if (i > 0) {
+                if (i < this.lastRenderLines.length) {
+                    // Moving within the previously existing area.
+                    // Use 'Down' (B) to avoid scrolling/shifting existing content.
+                    outputBuffer += '\x1b[B\r';
+                }
+                else {
+                    // Moving into NEW area (Append).
+                    // Must use '\n' to create the new line.
+                    outputBuffer += '\n';
+                }
+            }
+            // Printing logic
+            if (i < this.lastRenderLines.length) {
+                const oldLine = this.lastRenderLines[i];
+                if (newLine !== oldLine) {
+                    // Overwrite existing line
+                    outputBuffer += ansi_1.ANSI.ERASE_LINE + newLine;
+                }
+            }
+            else {
+                // Print new line (we are already at start due to '\n' above)
+                outputBuffer += newLine;
             }
         }
-        // 5. Update state for the next render cycle
+        // 4. Handle Shrinkage (Clear garbage below)
+        if (newLines.length < this.lastRenderLines.length) {
+            // Move down to the first obsolete line
+            outputBuffer += '\n';
+            // Clear everything below
+            outputBuffer += ansi_1.ANSI.ERASE_DOWN;
+            // Move back up to the last valid line to maintain cursor state consistency
+            outputBuffer += `\x1b[A`;
+        }
+        this.print(outputBuffer);
+        // Update State
         this.lastRenderLines = newLines;
         this.lastRenderHeight = newLines.length;
     }
@@ -153,59 +151,28 @@ class Prompt {
         if (visualWidth <= width) {
             return str;
         }
-        // Heuristic truncation using stringWidth
-        // We iterate and sum width until we hit limit - 3
         let currentWidth = 0;
         let cutIndex = 0;
         let inAnsi = false;
         for (let i = 0; i < str.length; i++) {
-            const code = str.charCodeAt(i);
-            if (str[i] === '\x1b') {
+            if (str[i] === '\x1b')
                 inAnsi = true;
-            }
-            if (inAnsi) {
-                if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
-                    inAnsi = false;
-                }
-            }
-            else {
-                // Width check
-                // Handle surrogates roughly (we don't need perfect width here during loop, just enough to stop)
-                // But wait, we imported `stringWidth`.
-                // We can't easily use `stringWidth` incrementally without re-parsing.
-                // Let's just trust the loop for cut index.
-                // Re-implement basic width logic here for the cut index finding
-                let charWidth = 1;
-                let cp = code;
-                if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
-                    const next = str.charCodeAt(i + 1);
-                    if (next >= 0xDC00 && next <= 0xDFFF) {
-                        cp = (code - 0xD800) * 0x400 + (next - 0xDC00) + 0x10000;
-                        // i is incremented in main loop but we need to skip next char
-                        // We'll handle i increment in the loop
-                    }
-                }
-                // Check range (simplified or call helper)
-                // We don't have isWideCodePoint exported. 
-                // But generally, we can just say:
-                if (cp >= 0x1100) { // Quick check for potentially wide
-                    // It's acceptable to be slightly aggressive on wide chars for truncation
-                    charWidth = 2;
-                }
+            if (!inAnsi) {
+                const code = str.charCodeAt(i);
+                const charWidth = code > 255 ? 2 : 1;
                 if (currentWidth + charWidth > width - 3) {
-                    cutIndex = i;
                     break;
                 }
                 currentWidth += charWidth;
-                if (cp > 0xFFFF) {
-                    i++; // Skip low surrogate
-                }
+            }
+            else {
+                if (str[i] === 'm' || (str[i] >= 'A' && str[i] <= 'Z'))
+                    inAnsi = false;
             }
             cutIndex = i + 1;
         }
         return str.substring(0, cutIndex) + '...' + ansi_1.ANSI.RESET;
     }
-    // Helper to check for arrow keys including application mode
     isUp(char) {
         return char === '\u001b[A' || char === '\u001bOA';
     }

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions, EditorOptions, TreeOptions, KeypressOptions } from './types';
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions, EditorOptions, TreeOptions, KeypressOptions, FormOptions, SnippetOptions, SpamOptions, WaitOptions, CodeOptions, TreeSelectOptions, RangeOptions, TransferOptions, CronOptions, ColorOptions, GridOptions, CalendarOptions } from './types';
 import { Spinner } from './spinner';
 /**
  * Public Facade for MepCLI
@@ -14,10 +14,14 @@ export declare class MepCLI {
     static checkbox<const V>(options: CheckboxOptions<V>): Promise<V[]>;
     static confirm(options: ConfirmOptions): Promise<boolean>;
     static password(options: TextOptions): Promise<string>;
+    static secret(options: TextOptions): Promise<string>;
     static number(options: NumberOptions): Promise<number>;
     static toggle(options: ToggleOptions): Promise<boolean>;
     static list(options: ListOptions): Promise<string[]>;
     static slider(options: SliderOptions): Promise<number>;
+    static range(options: RangeOptions): Promise<[number, number]>;
+    static transfer<const V>(options: TransferOptions<V>): Promise<[V[], V[]]>;
+    static cron(options: CronOptions): Promise<string>;
     static date(options: DateOptions): Promise<Date>;
     static file(options: FileOptions): Promise<string>;
     static multiSelect<const V>(options: MultiSelectOptions<V>): Promise<V[]>;
@@ -28,4 +32,22 @@ export declare class MepCLI {
     static editor(options: EditorOptions): Promise<string>;
     static tree<const V>(options: TreeOptions<V>): Promise<V>;
     static keypress(options: KeypressOptions): Promise<string>;
+    static form(options: FormOptions): Promise<Record<string, string>>;
+    static snippet(options: SnippetOptions): Promise<string>;
+    static spam(options: SpamOptions): Promise<boolean>;
+    static wait(options: WaitOptions): Promise<void>;
+    static code(options: CodeOptions): Promise<string>;
+    /**
+     * Tree Select Prompt (Multi-selection)
+     * * @param options Configuration for the tree selection
+     * @returns A promise that resolves to an array of selected values
+     * * @notice Windows Compatibility:
+     * When used in a long sequence of prompts, this component may experience
+     * an input delay. If it feels "blocked", simply press 'Enter' once
+     * to refresh the TTY stream.
+     */
+    static treeSelect<const V>(options: TreeSelectOptions<V>): Promise<V[]>;
+    static color(options: ColorOptions): Promise<string>;
+    static grid(options: GridOptions): Promise<boolean[][]>;
+    static calendar(options: CalendarOptions): Promise<Date | [Date, Date]>;
 }