toolcraft 0.0.39 → 0.0.41

package/node_modules/@poe-code/frontmatter/dist/parse.js

@@ -0,0 +1,137 @@
+import { LineCounter, parse, parseDocument } from "yaml";
+import { splitFrontmatterBlock } from "./fences.js";
+export class FrontmatterParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FrontmatterParseError";
+    }
+}
+export function parseFrontmatter(source, options = {}) {
+    const split = splitFrontmatter(source);
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body
+        };
+    }
+    return {
+        frontmatter: parseYamlFrontmatter(split.raw, options),
+        body: split.body
+    };
+}
+export function parseFrontmatterDocument(source, options = {}) {
+    const split = splitFrontmatter(source);
+    const lineCounter = new LineCounter();
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors: [],
+            lineCounter
+        };
+    }
+    const document = parseDocument(normalizeYamlLineEndings(split.raw), {
+        lineCounter,
+        prettyErrors: false,
+        uniqueKeys: options.uniqueKeys ?? false
+    });
+    const errors = document.errors.map((error) => ({
+        message: error.message,
+        ...(error.pos === undefined ? {} : { pos: error.pos })
+    }));
+    if (errors.length > 0) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors,
+            lineCounter
+        };
+    }
+    return {
+        frontmatter: normalizeYamlFrontmatter(document.toJSON()),
+        body: split.body,
+        errors,
+        lineCounter
+    };
+}
+function splitFrontmatter(source) {
+    try {
+        return splitFrontmatterBlock(source);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new FrontmatterParseError(error.message);
+        }
+        throw error;
+    }
+}
+function parseYamlFrontmatter(yamlBlock, options) {
+    let parsed;
+    try {
+        parsed = parse(normalizeYamlLineEndings(yamlBlock), {
+            uniqueKeys: options.uniqueKeys ?? false
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+    return normalizeYamlFrontmatter(parsed);
+}
+function normalizeYamlLineEndings(value) {
+    if (!value.includes("\r")) {
+        return value;
+    }
+    let normalized = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== "\r") {
+            normalized += character;
+            continue;
+        }
+        if (value[index + 1] === "\n") {
+            normalized += "\r\n";
+            index += 1;
+            continue;
+        }
+        normalized += "\n";
+    }
+    return normalized;
+}
+function normalizeYamlFrontmatter(value) {
+    if (value === null || value === undefined) {
+        return {};
+    }
+    if (!isRecord(value)) {
+        throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
+    }
+    return normalizeYamlValue(value);
+}
+function normalizeYamlValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeYamlValue(item));
+    }
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            value: normalizeYamlValue(entryValue),
+            writable: true
+        });
+    }
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/node_modules/@poe-code/frontmatter/dist/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringifyFrontmatter(frontmatter: Record<string, unknown>, body: string): string;

package/node_modules/@poe-code/frontmatter/dist/stringify.js

@@ -0,0 +1,35 @@
+import { stringify } from "yaml";
+import { FrontmatterParseError } from "./parse.js";
+export function stringifyFrontmatter(frontmatter, body) {
+    try {
+        assertAcyclic(frontmatter);
+        return `---\n${stringify(frontmatter, { aliasDuplicateObjects: false }).trimEnd()}\n---\n${body}`;
+    }
+    catch (error) {
+        if (error instanceof FrontmatterParseError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : "Unknown YAML stringify error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+}
+function assertAcyclic(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null) {
+        return;
+    }
+    if (seen.has(value)) {
+        throw new FrontmatterParseError("Cannot stringify cyclic frontmatter.");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertAcyclic(item, seen);
+        }
+    }
+    else {
+        for (const item of Object.values(value)) {
+            assertAcyclic(item, seen);
+        }
+    }
+    seen.delete(value);
+}

package/node_modules/@poe-code/frontmatter/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/frontmatter",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test": "cd ../.. && vitest run packages/frontmatter/src",
+    "test:unit": "cd ../.. && vitest run packages/frontmatter/src"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}

package/node_modules/mcp-oauth/dist/server/jwks-token-verifier.d.ts

@@ -3,6 +3,7 @@ export interface JwksTokenVerifierOptions {
     jwksUrl: string | URL;
     clockSkewSeconds?: number;
     allowedAlgorithms?: readonly string[];
+    jwksCacheTtlMs?: number;
     fetch?: FetchLike;
 }
 export interface JwksVerifiedAccessToken {

package/node_modules/mcp-oauth/dist/server/jwks-token-verifier.js

@@ -243,16 +243,40 @@ export function createJwksTokenVerifier(options) {
     const jwksUrl = toUrl(options.jwksUrl, "jwksUrl");
     const clockSkewSeconds = options.clockSkewSeconds ?? 30;
     const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS;
+    const jwksCacheTtlMs = options.jwksCacheTtlMs ?? 300_000;
     const fetchImplementation = options.fetch ?? globalThis.fetch;
+    let cachedJwks;
+    let pendingJwks;
     if (typeof fetchImplementation !== "function") {
         throw new Error("fetch is not available; pass options.fetch explicitly");
     }
+    async function getJwks() {
+        const now = Date.now();
+        if (cachedJwks !== undefined && cachedJwks.expiresAt > now) {
+            return cachedJwks.value;
+        }
+        if (pendingJwks !== undefined) {
+            return pendingJwks;
+        }
+        pendingJwks = loadJwks(jwksUrl, fetchImplementation)
+            .then((jwks) => {
+            cachedJwks = {
+                value: jwks,
+                expiresAt: Date.now() + jwksCacheTtlMs,
+            };
+            return jwks;
+        })
+            .finally(() => {
+            pendingJwks = undefined;
+        });
+        return pendingJwks;
+    }
     return {
         async verify(input) {
             const expectedResource = canonicalizeResourceIndicator(input.resource);
             const algorithm = resolveAlgorithm(input.token, allowedAlgorithms);
             try {
-                const jwks = await loadJwks(jwksUrl, fetchImplementation);
+                const jwks = await getJwks();
                 const verified = await verifyJwtAgainstJwks({
                     token: input.token,
                     jwks,

package/node_modules/tiny-mcp-client/README.md

@@ -14,9 +14,16 @@ const client = new McpClient({
 await client.connect(new HttpTransport({ url: "http://127.0.0.1:3000/mcp" }));
 const tools = await client.listTools();
 console.log(tools);
+const result = await client.callTool({
+  name: "search",
+  arguments: { query: "typed outputs" },
+});
+console.log(result.structuredContent);
 await client.close();
 ```
 
+`Tool` includes MCP `outputSchema` when a server advertises typed tool output. `CallToolResult` includes `structuredContent?: Record<string, unknown>` for typed results; legacy/content-block tools still use `content[]`.
+
 ## Transports
 
 | Transport | Description |

package/node_modules/tiny-mcp-client/dist/internal.d.ts

@@ -123,6 +123,7 @@ export interface Tool {
     name: string;
     description?: string;
     inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
     annotations?: ToolAnnotations;
 }
 export interface ToolAnnotations {
@@ -216,6 +217,7 @@ export interface GetPromptParams {
 }
 export interface CallToolResult {
     content: ContentItem[];
+    structuredContent?: Record<string, unknown>;
     isError?: boolean;
 }
 export interface Root {

package/node_modules/tiny-mcp-client/dist/internal.js

@@ -2421,6 +2421,9 @@ function isCallToolResult(value) {
     if (!isObjectRecord(value) || !Array.isArray(value.content)) {
         return false;
     }
+    if (value.structuredContent !== undefined && !isObjectRecord(value.structuredContent)) {
+        return false;
+    }
     if (value.isError !== undefined && typeof value.isError !== "boolean") {
         return false;
     }

package/node_modules/tiny-mcp-client/dist/mcp-tool-types.compile-check.js

@@ -14,6 +14,13 @@ const tool = {
             locale: { type: "string" },
         },
     },
+    outputSchema: {
+        type: "object",
+        properties: {
+            word: { type: "string" },
+        },
+        required: ["word"],
+    },
     annotations,
 };
 const callToolParams = {
@@ -52,6 +59,9 @@ const contentItems = [
 ];
 const callToolResult = {
     content: contentItems,
+    structuredContent: {
+        word: "quotidian",
+    },
 };
 const callToolErrorResult = {
     content: [textContent],

package/node_modules/tiny-mcp-client/src/http-oauth.test.ts

@@ -1,5 +1,5 @@
-import http from "node:http";
 import { describe, expect, it, vi } from "vitest";
+import { nodeFetch } from "tiny-http-mcp-server/testing";
 import type { OAuthSessionStore, StoredOAuthSession } from "mcp-oauth";
 import {
   HttpTransport,
@@ -918,11 +918,5 @@ function readTransportLine(transport: HttpTransport): Promise<string> {
 }
 
 async function requestLoopbackCallback(url: string): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    const request = http.get(url, (response) => {
-      response.resume();
-      response.once("end", resolve);
-    });
-    request.once("error", reject);
-  });
+  await nodeFetch(url);
 }

package/node_modules/tiny-mcp-client/src/internal.ts

@@ -670,6 +670,7 @@ export interface Tool {
   name: string;
   description?: string;
   inputSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
   annotations?: ToolAnnotations;
 }
 
@@ -785,6 +786,7 @@ export interface GetPromptParams {
 
 export interface CallToolResult {
   content: ContentItem[];
+  structuredContent?: Record<string, unknown>;
   isError?: boolean;
 }
 
@@ -3578,6 +3580,10 @@ function isCallToolResult(value: unknown): value is CallToolResult {
     return false;
   }
 
+  if (value.structuredContent !== undefined && !isObjectRecord(value.structuredContent)) {
+    return false;
+  }
+
   if (value.isError !== undefined && typeof value.isError !== "boolean") {
     return false;
   }

package/node_modules/tiny-mcp-client/src/mcp-tool-types.compile-check.ts

@@ -28,6 +28,13 @@ const tool: Tool = {
       locale: { type: "string" },
     },
   },
+  outputSchema: {
+    type: "object",
+    properties: {
+      word: { type: "string" },
+    },
+    required: ["word"],
+  },
   annotations,
 };
 
@@ -74,6 +81,9 @@ const contentItems: ContentItem[] = [
 
 const callToolResult: CallToolResult = {
   content: contentItems,
+  structuredContent: {
+    word: "quotidian",
+  },
 };
 
 const callToolErrorResult: CallToolResult = {

package/node_modules/toolcraft-design/README.md

@@ -139,6 +139,18 @@ The registry key and `Brand.name` should match. Brand primary colors are CSS-sty
 - `VSCODE_COLOR_THEME_KIND`: automatic VS Code theme hint used after the macOS hint.
 - `COLORFGBG`: terminal foreground/background hint used after the macOS and VS Code hints. Rendering defaults to dark when no hint resolves a mode.
 
+### Prompts
+
+- `POE_NO_PROMPT`: when set to `1` in non-TTY contexts, `confirm`, `select`, and `multiselect` accept their default or initial values instead of throwing an interactive TTY error.
+
+### Node 18 Smoke
+
+After building the package, verify the prompt entrypoint under Node 18 with:
+
+```sh
+nvm exec 18.18 node packages/toolcraft-design/scripts/check-node18.mjs
+```
+
 ### Output and Color
 
 - `OUTPUT_FORMAT`: selects `terminal`, `markdown`, or `json` output for components that use the output-format resolver. Invalid or missing values default to `terminal`.

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

@@ -1,4 +1,5 @@
-import * as clack from "@clack/prompts";
+import type { CANCEL } from "./interactive/cancel-symbol.js";
+import { type SelectOption } from "./interactive/select.js";
 import { cancel, isCancel } from "./primitives/cancel.js";
 import { intro } from "./primitives/intro.js";
 import { log } from "./primitives/log.js";
@@ -10,15 +11,24 @@ export { intro, outro, note, spinner };
 export declare function introPlain(title: string): void;
 export interface SelectOptions<Value> {
     message: string;
-    options: Array<{
-        value: Value;
-        label: string;
-        hint?: string;
-    }>;
+    options: Array<SelectOption<Value>>;
     initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function select<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;
+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 select<Value>(opts: SelectOptions<Value>): Promise<Value | symbol>;
-export type MultiselectOptions<Value> = Parameters<typeof clack.multiselect<Value>>[0];
 /**
  * Prompts the user to select one or more values from a list.
  *
@@ -35,23 +45,38 @@ export type MultiselectOptions<Value> = Parameters<typeof clack.multiselect<Valu
  *   // result is Value[]
  * }
  */
-export declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | symbol>;
-export type TextOptions = Parameters<typeof clack.text>[0];
-export declare function text(opts: TextOptions): Promise<string | symbol>;
+export declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | typeof CANCEL>;
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function text(opts: TextOptions): Promise<string | typeof CANCEL>;
 export interface ConfirmOptions {
     message: string;
     initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
 }
-export declare function confirm(opts: ConfirmOptions): Promise<boolean | symbol>;
+export declare function confirm(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;
 export declare class PromptCancelledError extends Error {
     constructor(message?: string);
 }
 export declare function confirmOrCancel(opts: ConfirmOptions): Promise<boolean>;
 export interface PasswordOptions {
     message: string;
-    validate?: (value: string) => string | undefined;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
 }
-export declare function password(opts: PasswordOptions): Promise<string | symbol>;
+export declare function password(opts: PasswordOptions): Promise<string | typeof CANCEL>;
 export type SpinnerOptions = {
     start: (message?: string) => void;
     stop: (message?: string, code?: number) => void;

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

@@ -1,7 +1,11 @@
 import { color } from "../components/color.js";
-import * as clack from "@clack/prompts";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
+import { confirmPrompt } from "./interactive/confirm.js";
+import { multiselectPrompt } from "./interactive/multiselect.js";
+import { passwordPrompt } from "./interactive/password.js";
+import { selectPrompt } from "./interactive/select.js";
+import { textPrompt } from "./interactive/text.js";
 import { cancel, isCancel } from "./primitives/cancel.js";
 import { intro } from "./primitives/intro.js";
 import { log } from "./primitives/log.js";
@@ -22,7 +26,7 @@ export function introPlain(title) {
     process.stdout.write(`${color.gray("┌")}  ${title}\n`);
 }
 export async function select(opts) {
-    return clack.select(opts);
+    return selectPrompt(opts);
 }
 /**
  * Prompts the user to select one or more values from a list.
@@ -41,13 +45,13 @@ export async function select(opts) {
  * }
  */
 export async function multiselect(opts) {
-    return clack.multiselect(opts);
+    return multiselectPrompt(opts);
 }
 export async function text(opts) {
-    return clack.text(opts);
+    return textPrompt(opts);
 }
 export async function confirm(opts) {
-    return clack.confirm(opts);
+    return confirmPrompt(opts);
 }
 export class PromptCancelledError extends Error {
     constructor(message = "Operation cancelled.") {
@@ -67,7 +71,7 @@ export async function confirmOrCancel(opts) {
     return result === true;
 }
 export async function password(opts) {
-    return clack.password(opts);
+    return passwordPrompt(opts);
 }
 function formatElapsed(ms) {
     const totalSeconds = Math.floor(ms / 1000);

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

@@ -0,0 +1,2 @@
+export declare const CANCEL: unique symbol;
+export declare function isCancel(value: unknown): value is typeof CANCEL;

package/node_modules/toolcraft-design/dist/prompts/interactive/cancel-symbol.js

@@ -0,0 +1,4 @@
+export const CANCEL = Symbol.for("poe.cancel");
+export function isCancel(value) {
+    return value === CANCEL;
+}

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

@@ -0,0 +1,9 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface ConfirmOptions {
+    message: string;
+    initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function confirmPrompt(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;

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

@@ -0,0 +1,47 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class ConfirmPrompt extends Prompt {
+    constructor(opts) {
+        super({
+            ...opts,
+            initialValue: opts.initialValue ?? true,
+            render: (prompt) => renderConfirmPrompt(prompt, opts)
+        }, false);
+        this.on("confirm", (value) => {
+            this.setValue(value);
+            this.state = "submit";
+            this.emit("finalize");
+            this.render();
+            this.close();
+        });
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "down" || action === "left" || action === "right") {
+                this.setValue(!this.value);
+            }
+        });
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value ?? true);
+        }
+        return super.promptNonTty();
+    }
+}
+function choices(value) {
+    const yes = value ? `${color.green(GLYPHS.radioActive)} ${color.bold("Yes")}` : `${color.dim(GLYPHS.radioInactive)} ${color.dim("Yes")}`;
+    const no = value ? `${color.dim(GLYPHS.radioInactive)} ${color.dim("No")}` : `${color.green(GLYPHS.radioActive)} ${color.bold("No")}`;
+    return `${yes} ${color.dim("/")} ${no}`;
+}
+function renderConfirmPrompt(prompt, opts) {
+    if (prompt.state === "submit") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim(prompt.value ? "Yes" : "No")}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(prompt.value ? "Yes" : "No")}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${symbolBar(prompt.state)}  ${choices(prompt.value)}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function confirmPrompt(opts) {
+    return new ConfirmPrompt(opts).prompt();
+}

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 {};