toolcraft-openapi 0.0.39 → 0.0.41

package/node_modules/toolcraft-design/dist/prompts/interactive/core.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from "node:events";
+import { CANCEL } from "./cancel-symbol.js";
+export type PromptStateName = "initial" | "active" | "submit" | "cancel" | "error";
+export interface PromptState<Value> {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    cursor: number;
+    userInput: string;
+}
+export interface PromptOptions<Value> {
+    render: (state: Prompt<Value>) => string;
+    initialValue?: Value;
+    initialUserInput?: string;
+    validate?: (value: Value | undefined) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+type InputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+    setRawMode?: (enabled: boolean) => void;
+    unpipe?: () => void;
+};
+export declare class Prompt<Value> extends EventEmitter {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    userInput: string;
+    protected _cursor: number;
+    protected input: InputStream;
+    protected output: NodeJS.WritableStream;
+    private readonly renderFrame;
+    private readonly validate?;
+    private readonly signal?;
+    private readonly trackValue;
+    private previousFrame;
+    private readlineInterface?;
+    private abortListener?;
+    private closed;
+    constructor(opts: PromptOptions<Value>, trackValue?: boolean);
+    get cursor(): number;
+    prompt(): Promise<Value | typeof CANCEL>;
+    protected promptNonTty(): Promise<Value | typeof CANCEL>;
+    protected readNonTtyLine(): Promise<string>;
+    protected setValue(value: Value | undefined): void;
+    protected setError(message: string): void;
+    protected setUserInput(value: string): void;
+    protected clearUserInput(): void;
+    private readonly onKeypress;
+    private updateTrackedInput;
+    protected readonly render: () => void;
+    protected close(): void;
+}
+export {};

package/node_modules/toolcraft-design/dist/prompts/interactive/core.js

@@ -0,0 +1,274 @@
+import { EventEmitter } from "node:events";
+import * as readline from "node:readline";
+import { CANCEL } from "./cancel-symbol.js";
+import { mapKey } from "./keys.js";
+import { wrapFrame } from "./wrap.js";
+const cursor = {
+    hide: "\x1b[?25l",
+    show: "\x1b[?25h",
+    move: (x, y) => {
+        let output = "";
+        if (x < 0)
+            output += `\x1b[${-x}D`;
+        if (x > 0)
+            output += `\x1b[${x}C`;
+        if (y < 0)
+            output += `\x1b[${-y}A`;
+        if (y > 0)
+            output += `\x1b[${y}B`;
+        return output;
+    }
+};
+const erase = {
+    down: "\x1b[J"
+};
+export class Prompt extends EventEmitter {
+    state = "initial";
+    value;
+    error = "";
+    userInput = "";
+    _cursor = 0;
+    input;
+    output;
+    renderFrame;
+    validate;
+    signal;
+    trackValue;
+    previousFrame = "";
+    readlineInterface;
+    abortListener;
+    closed = false;
+    constructor(opts, trackValue = true) {
+        super();
+        this.input = (opts.input ?? process.stdin);
+        this.output = opts.output ?? process.stdout;
+        this.renderFrame = opts.render;
+        this.validate = opts.validate;
+        this.signal = opts.signal;
+        this.value = opts.initialValue;
+        this.trackValue = trackValue;
+        this.userInput = opts.initialUserInput ?? "";
+        this._cursor = this.userInput.length;
+    }
+    get cursor() {
+        return this._cursor;
+    }
+    prompt() {
+        if (this.signal?.aborted) {
+            this.state = "cancel";
+            return Promise.resolve(CANCEL);
+        }
+        if (this.input.isTTY !== true) {
+            return this.promptNonTty();
+        }
+        return new Promise((resolve) => {
+            const onSubmit = (value) => resolve(value);
+            const onCancel = () => resolve(CANCEL);
+            this.once("submit", onSubmit);
+            this.once("cancel", onCancel);
+            this.abortListener = () => {
+                this.state = "cancel";
+                this.emit("finalize");
+                this.render();
+                this.close();
+            };
+            this.signal?.addEventListener("abort", this.abortListener, { once: true });
+            this.readlineInterface = readline.createInterface({
+                input: this.input,
+                output: undefined,
+                tabSize: 2,
+                prompt: "",
+                escapeCodeTimeout: 50,
+                terminal: true
+            });
+            readline.emitKeypressEvents(this.input, this.readlineInterface);
+            this.readlineInterface.prompt();
+            this.input.on("keypress", this.onKeypress);
+            if (this.input.setRawMode) {
+                this.input.setRawMode(true);
+            }
+            this.output.on("resize", this.render);
+            this.render();
+        });
+    }
+    promptNonTty() {
+        return Promise.reject(new Error("Interactive prompt requires a TTY. Set POE_NO_PROMPT=1 to accept defaults non-interactively."));
+    }
+    readNonTtyLine() {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({ input: this.input, terminal: false });
+            let settled = false;
+            const settle = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                rl.close();
+                resolve(value);
+            };
+            rl.once("line", settle);
+            rl.once("close", () => settle(rl.line));
+        });
+    }
+    setValue(value) {
+        this.value = value;
+        this.emit("value", value);
+    }
+    setError(message) {
+        this.error = message;
+    }
+    setUserInput(value) {
+        this.userInput = value;
+        this._cursor = Math.min(this._cursor, this.userInput.length);
+        this.emit("userInput", this.userInput);
+    }
+    clearUserInput() {
+        this.userInput = "";
+        this._cursor = 0;
+        this.emit("userInput", this.userInput);
+    }
+    onKeypress = (char, key = {}) => {
+        let action = mapKey(key.name, char);
+        if (this.trackValue && char && char >= " " && key.name !== "return" && key.name !== "enter" && key.name !== "escape") {
+            action = undefined;
+        }
+        if (this.trackValue && action !== "enter") {
+            this.updateTrackedInput(char, key, action);
+        }
+        if (this.state === "error") {
+            this.state = "active";
+            this.error = "";
+        }
+        if (!this.trackValue && action) {
+            this.emit("cursor", action);
+        }
+        else if (this.trackValue && action && action !== "enter") {
+            this.emit("cursor", action);
+        }
+        if (char && /^[yn]$/i.test(char)) {
+            this.emit("confirm", char.toLowerCase() === "y");
+        }
+        if (char) {
+            this.emit("key", char.toLowerCase(), key);
+        }
+        if (action === "enter") {
+            const error = this.validate?.(this.value);
+            if (error) {
+                this.error = error instanceof Error ? error.message : error;
+                this.state = "error";
+            }
+            else {
+                this.state = "submit";
+            }
+        }
+        if (action === "cancel") {
+            this.state = "cancel";
+        }
+        if (this.state === "submit" || this.state === "cancel") {
+            this.emit("finalize");
+        }
+        this.render();
+        if (this.state === "submit" || this.state === "cancel") {
+            this.close();
+        }
+    };
+    updateTrackedInput(char, key, action) {
+        if (key.ctrl) {
+            if (key.name === "a") {
+                this._cursor = 0;
+                return;
+            }
+            if (key.name === "e") {
+                this._cursor = this.userInput.length;
+                return;
+            }
+            if (key.name === "u") {
+                this.userInput = this.userInput.slice(this._cursor);
+                this._cursor = 0;
+                this.emit("userInput", this.userInput);
+                return;
+            }
+            if (key.name === "k") {
+                this.userInput = this.userInput.slice(0, this._cursor);
+                this.emit("userInput", this.userInput);
+                return;
+            }
+        }
+        if (action === "left") {
+            this._cursor = Math.max(0, this._cursor - 1);
+            return;
+        }
+        if (action === "right") {
+            this._cursor = Math.min(this.userInput.length, this._cursor + 1);
+            return;
+        }
+        if (action === "cancel" || action === "up" || action === "down" || action === "space") {
+            return;
+        }
+        if (key.name === "backspace" || char === "\b" || char === "\x7f") {
+            if (this._cursor > 0) {
+                this.userInput = `${this.userInput.slice(0, this._cursor - 1)}${this.userInput.slice(this._cursor)}`;
+                this._cursor -= 1;
+                this.emit("userInput", this.userInput);
+            }
+            return;
+        }
+        if (key.name === "delete") {
+            if (this._cursor < this.userInput.length) {
+                this.userInput = `${this.userInput.slice(0, this._cursor)}${this.userInput.slice(this._cursor + 1)}`;
+                this.emit("userInput", this.userInput);
+            }
+            return;
+        }
+        if (!char || char < " " || key.ctrl) {
+            return;
+        }
+        this.userInput = `${this.userInput.slice(0, this._cursor)}${char}${this.userInput.slice(this._cursor)}`;
+        this._cursor += char.length;
+        this.emit("userInput", this.userInput);
+    }
+    render = () => {
+        if (this.closed) {
+            return;
+        }
+        const frame = wrapFrame(this.output, this.renderFrame(this) ?? "");
+        if (frame === this.previousFrame) {
+            return;
+        }
+        if (!this.previousFrame) {
+            this.output.write(`${cursor.hide}${frame}`);
+            this.previousFrame = frame;
+            if (this.state === "initial") {
+                this.state = "active";
+            }
+            return;
+        }
+        const previousLineCount = this.previousFrame.split("\n").length - 1;
+        this.output.write(`${cursor.move(-999, -previousLineCount)}${erase.down}${frame}`);
+        this.previousFrame = frame;
+    };
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.input.removeListener("keypress", this.onKeypress);
+        this.output.removeListener("resize", this.render);
+        if (this.abortListener) {
+            this.signal?.removeEventListener("abort", this.abortListener);
+        }
+        this.output.write(`${cursor.show}\n`);
+        if (!process.platform.startsWith("win") && this.input.setRawMode) {
+            this.input.setRawMode(false);
+        }
+        this.readlineInterface?.close();
+        this.input.unpipe?.();
+        if (this.state === "cancel") {
+            this.emit("cancel");
+        }
+        else {
+            this.emit("submit", this.value);
+        }
+        this.removeAllListeners();
+    }
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.d.ts

@@ -0,0 +1,20 @@
+import type { PromptStateName } from "./core.js";
+export declare const UNICODE: boolean;
+export declare const GLYPHS: {
+    readonly stepActive: string;
+    readonly stepCancel: string;
+    readonly stepError: string;
+    readonly stepSubmit: string;
+    readonly barStart: string;
+    readonly bar: string;
+    readonly barEnd: string;
+    readonly radioActive: string;
+    readonly radioInactive: string;
+    readonly checkboxActive: string;
+    readonly checkboxSelected: string;
+    readonly checkboxInactive: string;
+    readonly passwordMask: string;
+    readonly ellipsis: "...";
+};
+export declare function symbol(state: PromptStateName): string;
+export declare function symbolBar(state: PromptStateName): string;

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.js

@@ -0,0 +1,53 @@
+import { color } from "../../components/color.js";
+function supportsUnicode() {
+    if (!process.platform.startsWith("win")) {
+        return process.env.TERM !== "linux";
+    }
+    return Boolean(process.env.CI ||
+        process.env.WT_SESSION ||
+        process.env.TERMINUS_SUBLIME ||
+        process.env.ConEmuTask === "{cmd::Cmder}" ||
+        process.env.TERM_PROGRAM === "Terminus-Sublime" ||
+        process.env.TERM_PROGRAM === "vscode" ||
+        process.env.TERM === "xterm-256color" ||
+        process.env.TERM === "alacritty" ||
+        process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+export const UNICODE = supportsUnicode();
+function glyph(unicode, ascii) {
+    return UNICODE ? unicode : ascii;
+}
+export const GLYPHS = {
+    stepActive: glyph("◆", "*"),
+    stepCancel: glyph("■", "x"),
+    stepError: glyph("▲", "x"),
+    stepSubmit: glyph("◇", "o"),
+    barStart: glyph("┌", "T"),
+    bar: glyph("│", "|"),
+    barEnd: glyph("└", "-"),
+    radioActive: glyph("●", ">"),
+    radioInactive: glyph("○", " "),
+    checkboxActive: glyph("◻", "[ ]"),
+    checkboxSelected: glyph("◼", "[+]"),
+    checkboxInactive: glyph("◻", "[ ]"),
+    passwordMask: glyph("•", "*"),
+    ellipsis: "..."
+};
+export function symbol(state) {
+    if (state === "cancel")
+        return color.red(GLYPHS.stepCancel);
+    if (state === "error")
+        return color.yellow(GLYPHS.stepError);
+    if (state === "submit")
+        return color.green(GLYPHS.stepSubmit);
+    return color.cyan(GLYPHS.stepActive);
+}
+export function symbolBar(state) {
+    if (state === "cancel")
+        return color.red(GLYPHS.bar);
+    if (state === "error")
+        return color.yellow(GLYPHS.bar);
+    if (state === "submit")
+        return color.green(GLYPHS.bar);
+    return color.cyan(GLYPHS.bar);
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/index.d.ts

@@ -0,0 +1,6 @@
+export { CANCEL, isCancel } from "./cancel-symbol.js";
+export { textPrompt, type TextOptions } from "./text.js";
+export { passwordPrompt, type PasswordOptions } from "./password.js";
+export { confirmPrompt, type ConfirmOptions } from "./confirm.js";
+export { selectPrompt, type SelectOption, type SelectOptions } from "./select.js";
+export { multiselectPrompt, type MultiselectOptions } from "./multiselect.js";

package/node_modules/toolcraft-design/dist/prompts/interactive/index.js

@@ -0,0 +1,6 @@
+export { CANCEL, isCancel } from "./cancel-symbol.js";
+export { textPrompt } from "./text.js";
+export { passwordPrompt } from "./password.js";
+export { confirmPrompt } from "./confirm.js";
+export { selectPrompt } from "./select.js";
+export { multiselectPrompt } from "./multiselect.js";

package/node_modules/toolcraft-design/dist/prompts/interactive/keys.d.ts

@@ -0,0 +1,2 @@
+export type Action = "up" | "down" | "left" | "right" | "space" | "enter" | "cancel";
+export declare function mapKey(name: string | undefined, char: string | undefined): Action | undefined;

package/node_modules/toolcraft-design/dist/prompts/interactive/keys.js

@@ -0,0 +1,28 @@
+const aliases = {
+    k: "up",
+    j: "down",
+    h: "left",
+    l: "right"
+};
+const keyActions = {
+    up: "up",
+    down: "down",
+    left: "left",
+    right: "right",
+    space: "space",
+    return: "enter",
+    enter: "enter",
+    escape: "cancel"
+};
+export function mapKey(name, char) {
+    if (char === "\x03") {
+        return "cancel";
+    }
+    if (char === " ") {
+        return "space";
+    }
+    if (!name) {
+        return undefined;
+    }
+    return keyActions[name] ?? aliases[name];
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/multiselect.d.ts

@@ -0,0 +1,13 @@
+import { CANCEL } from "./cancel-symbol.js";
+import { type SelectOption } from "./select.js";
+export interface MultiselectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValues?: Value[];
+    required?: boolean;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function multiselectPrompt<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/multiselect.js

@@ -0,0 +1,131 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol } from "./glyphs.js";
+import { Prompt } from "./core.js";
+import { limitOptions } from "./pagination.js";
+import { findNonDisabled } from "./select.js";
+class MultiselectPrompt extends Prompt {
+    options;
+    constructor(opts) {
+        if (opts.options.length === 0) {
+            throw new Error("Multiselect prompt requires at least one option.");
+        }
+        if (opts.options.every((option) => option.disabled)) {
+            throw new Error("Multiselect prompt requires at least one enabled option.");
+        }
+        const cursor = findNonDisabled(0, 1, opts.options);
+        super({
+            ...opts,
+            initialValue: [...(opts.initialValues ?? [])],
+            validate: (value) => {
+                if (opts.required && (!value || value.length === 0)) {
+                    return "Please select at least one option.\nPress SPACE to select, ENTER to submit";
+                }
+                return undefined;
+            },
+            render: (prompt) => renderMultiselectPrompt(prompt, opts)
+        }, false);
+        this.options = opts.options;
+        this._cursor = cursor;
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "left") {
+                this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+            }
+            else if (action === "down" || action === "right") {
+                this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+            }
+            else if (action === "space") {
+                this.toggleFocused();
+            }
+        });
+        this.on("key", (key) => {
+            if (key === "a") {
+                this.toggleAll();
+            }
+            else if (key === "i") {
+                this.invert();
+            }
+        });
+    }
+    get visibleOptions() {
+        return this.options;
+    }
+    enabledOptions() {
+        return this.options.filter((option) => !option.disabled);
+    }
+    toggleFocused() {
+        const option = this.options[this.cursor];
+        if (!option || option.disabled) {
+            return;
+        }
+        this.toggleValue(option.value);
+    }
+    toggleValue(value) {
+        const current = this.value ?? [];
+        this.setValue(current.includes(value)
+            ? current.filter((item) => item !== value)
+            : [...current, value]);
+    }
+    toggleAll() {
+        const enabledValues = this.enabledOptions().map((option) => option.value);
+        const current = this.value ?? [];
+        const allSelected = enabledValues.every((value) => current.includes(value));
+        this.setValue(allSelected ? [] : enabledValues);
+    }
+    invert() {
+        const current = this.value ?? [];
+        this.setValue(this.enabledOptions().map((option) => option.value).filter((value) => !current.includes(value)));
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value ?? []);
+        }
+        return super.promptNonTty();
+    }
+}
+function hasValue(values, value) {
+    return (values ?? []).includes(value);
+}
+function renderOption(option, values, active, submitted, cancelled) {
+    const selected = hasValue(values, option.value);
+    const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+    if (submitted)
+        return color.dim(option.label);
+    if (cancelled)
+        return color.dim.strikethrough(option.label);
+    if (option.disabled)
+        return `${color.gray(GLYPHS.checkboxInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+    if (selected)
+        return `${color.green(GLYPHS.checkboxSelected)} ${active ? option.label : color.dim(option.label)}${hint}`;
+    if (active)
+        return `${color.cyan(GLYPHS.checkboxActive)} ${option.label}${hint}`;
+    return `${color.dim(GLYPHS.checkboxInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderMultiselectPrompt(prompt, opts) {
+    if (prompt.state === "submit" || prompt.state === "cancel") {
+        const labels = prompt.visibleOptions
+            .filter((option) => hasValue(prompt.value, option.value))
+            .map((option) => prompt.state === "submit" ? color.dim(option.label) : color.dim.strikethrough(option.label))
+            .join(", ");
+        const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${labels}\n${end}`;
+    }
+    const lines = limitOptions({
+        cursor: prompt.cursor,
+        options: prompt.visibleOptions,
+        output: opts.output ?? process.stdout,
+        maxItems: opts.maxItems,
+        columnPadding: 3,
+        style: (option, active) => renderOption(option, prompt.value, active, false, false)
+    }).map((line) => `${prompt.state === "error" ? color.yellow(GLYPHS.bar) : color.cyan(GLYPHS.bar)}  ${line}`);
+    const body = [`${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}`, ...lines];
+    if (prompt.state === "error") {
+        body.push(`${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`);
+    }
+    else {
+        body.push(color.cyan(GLYPHS.barEnd));
+    }
+    return body.join("\n");
+}
+export function multiselectPrompt(opts) {
+    return new MultiselectPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/pagination.d.ts

@@ -0,0 +1,10 @@
+export interface PaginationOptions<Option> {
+    cursor: number;
+    options: Option[];
+    style: (option: Option, active: boolean) => string;
+    output: NodeJS.WritableStream;
+    maxItems?: number;
+    columnPadding?: number;
+    rowPadding?: number;
+}
+export declare function limitOptions<Option>(opts: PaginationOptions<Option>): string[];

package/node_modules/toolcraft-design/dist/prompts/interactive/pagination.js

@@ -0,0 +1,52 @@
+import { color } from "../../components/color.js";
+import { GLYPHS } from "./glyphs.js";
+import { getColumns, getRows } from "./wrap.js";
+import { wrapAnsi } from "fast-wrap-ansi";
+function countLines(values) {
+    return values.reduce((sum, value) => sum + value.split("\n").length, 0);
+}
+function trimToRows(values, cursorOffset, rows, hasTop, hasBottom) {
+    const output = [...values];
+    while (countLines(output) > rows && output.length > 1) {
+        const removeFromTop = hasTop && cursorOffset > 0;
+        const removeFromBottom = hasBottom && cursorOffset < output.length - 1;
+        if (removeFromTop) {
+            output.shift();
+            cursorOffset -= 1;
+        }
+        else if (removeFromBottom) {
+            output.pop();
+        }
+        else {
+            output.pop();
+        }
+    }
+    return output;
+}
+export function limitOptions(opts) {
+    const { cursor, options, style, output, maxItems = Number.POSITIVE_INFINITY, columnPadding = 0, rowPadding = 4 } = opts;
+    if (options.length === 0) {
+        return [];
+    }
+    const columns = Math.max(1, getColumns(output) - columnPadding);
+    const rowBudget = Math.max(getRows(output) - rowPadding, 0);
+    const visibleCount = Math.max(Math.min(maxItems, rowBudget), 5);
+    const cappedVisibleCount = Math.min(visibleCount, options.length);
+    let start = 0;
+    if (cursor >= cappedVisibleCount - 3) {
+        start = Math.max(Math.min(cursor - cappedVisibleCount + 3, options.length - cappedVisibleCount), 0);
+    }
+    const hasTopMarker = cappedVisibleCount < options.length && start > 0;
+    const hasBottomMarker = cappedVisibleCount < options.length && start + cappedVisibleCount < options.length;
+    const visible = options
+        .slice(start, start + cappedVisibleCount)
+        .map((option, index) => wrapAnsi(style(option, start + index === cursor), columns, { hard: true, trim: false }));
+    const trimmed = trimToRows(visible, Math.max(cursor - start, 0), Math.max(rowBudget - Number(hasTopMarker) - Number(hasBottomMarker), 1), hasTopMarker, hasBottomMarker);
+    if (hasTopMarker) {
+        trimmed.unshift(color.dim(GLYPHS.ellipsis));
+    }
+    if (hasBottomMarker) {
+        trimmed.push(color.dim(GLYPHS.ellipsis));
+    }
+    return trimmed;
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/password.d.ts

@@ -0,0 +1,10 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function passwordPrompt(opts: PasswordOptions): Promise<string | typeof CANCEL>;