whale-code 6.4.0

package/dist/cli/services/format-server-response.js

@@ -0,0 +1,440 @@
+/**
+ * Server Response Formatter — converts raw JSON to readable markdown
+ *
+ * Transforms server tool JSON responses into:
+ * - Markdown tables for arrays of flat objects
+ * - Bold key-value pairs for single objects
+ * - JSON fences for complex nested data
+ */
+// ============================================================================
+// COLUMN PRIORITIES — per tool category
+// ============================================================================
+const PRIORITY_COLUMNS = {
+    analytics: ["name", "revenue", "quantity", "total", "count", "average", "period"],
+    products: ["name", "sku", "status", "category_name", "cost_price", "stock_quantity"],
+    inventory: ["product_name", "quantity", "location_name", "product_sku", "product_id"],
+    customers: ["first_name", "last_name", "email", "phone", "status", "loyalty_tier"],
+    orders: ["order_number", "status", "total", "customer_name", "created_at"],
+    supply_chain: ["name", "status", "quantity", "supplier", "location", "expected_delivery_date"],
+    workflows: ["name", "status", "trigger_type", "created_at", "last_run"],
+    email: ["subject", "to", "status", "sent_at", "category"],
+};
+// Keys that are always deprioritized (shown last or hidden)
+const LOW_PRIORITY_KEYS = new Set([
+    "id", "store_id", "created_at", "updated_at", "deleted_at",
+    "created_by", "updated_by", "metadata", "raw_data",
+]);
+// ============================================================================
+// FORMATTERS
+// ============================================================================
+function isNarrow() {
+    return (process.stdout.columns || 80) < 90;
+}
+function truncateUuid(val) {
+    // UUID pattern: 8-4-4-4-12 hex chars
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val)) {
+        return val.slice(0, 8);
+    }
+    return val;
+}
+function formatValue(val, key) {
+    if (val === null || val === undefined)
+        return "—";
+    if (typeof val === "boolean")
+        return val ? "\u2713" : "\u2715";
+    if (typeof val === "number") {
+        if (key && isPercentageKey(key))
+            return `${val}%`;
+        return val.toLocaleString();
+    }
+    if (typeof val === "string") {
+        // Money detection
+        if (/^\d+\.\d{2}$/.test(val) && parseFloat(val) > 0) {
+            return `$${parseFloat(val).toLocaleString(undefined, { minimumFractionDigits: 2 })}`;
+        }
+        // Keys the LLM needs verbatim (IDs, file paths, URLs) — skip all truncation
+        if (key && NEVER_TRUNCATE_KEYS.has(key))
+            return val;
+        // UUID truncation for display-only columns
+        const truncated = truncateUuid(val);
+        // Date formatting
+        if (/^\d{4}-\d{2}-\d{2}T/.test(val)) {
+            return val.slice(0, 10);
+        }
+        // Truncate long strings
+        if (truncated.length > 200)
+            return truncated.slice(0, 197) + "...";
+        return truncated;
+    }
+    if (Array.isArray(val)) {
+        if (val.length === 0)
+            return "—";
+        // Extract names from array of objects for useful display
+        if (typeof val[0] === "object" && val[0] !== null) {
+            const names = val.slice(0, 3)
+                .map(v => {
+                const o = v;
+                return o.name || o.location_name || o.title || o.label;
+            })
+                .filter(Boolean)
+                .map(String);
+            if (names.length > 0) {
+                return names.join(", ") + (val.length > 3 ? ` +${val.length - 3} more` : "");
+            }
+        }
+        return `[${val.length} items]`;
+    }
+    if (typeof val === "object") {
+        const obj = val;
+        // Extract name/title from nested objects instead of showing {...}
+        if (typeof obj.name === "string")
+            return obj.name;
+        if (typeof obj.title === "string")
+            return obj.title;
+        if (typeof obj.label === "string")
+            return obj.label;
+        if (typeof obj.id === "string")
+            return obj.id;
+        return "{...}";
+    }
+    return String(val);
+}
+/** Keys whose values must never be truncated (file paths, URLs, IDs the LLM needs verbatim) */
+const NEVER_TRUNCATE_KEYS = new Set([
+    "id", "product_id", "category_id", "location_id", "supplier_id", "customer_id",
+    "store_id", "order_id", "workflow_id", "schema_id", "field_schema_id", "pricing_schema_id",
+    "transfer_id", "run_id", "step_id", "audit_id", "media_id", "creation_id", "job_id",
+    "collection_id", "source_id", "thread_id", "form_id", "template_id", "webhook_id",
+    "rule_id", "subscription_id", "span_id", "trace_id", "ad_id", "ad_set_id", "campaign_id",
+    "audience_id", "pixel_id", "key_id", "catalog_id", "purchase_order_id",
+    "primary_category_id", "parent_id", "from_location_id", "to_location_id",
+    "local_file", "file_url", "file_path", "download", "url",
+    "preview_url", "thumbnail_url", "audio_file",
+    "stdout", "stderr", "command", "output",
+]);
+function formatMoneyValue(val) {
+    if (typeof val === "number") {
+        return `$${val.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    }
+    return formatValue(val);
+}
+function isPercentageKey(key) {
+    return /percentage|_pct$|percent/i.test(key);
+}
+function isMoneyKey(key) {
+    // Bare "total" is almost always a count, not money. Only "total_revenue", "total_amount" etc. are money.
+    if (key === "total")
+        return false;
+    // Exclude "total_" when followed by non-money qualifiers
+    if (/^total[_](stock|products|items|orders|units|count|quantity|customers|runs|pages|results|employees)/i.test(key))
+        return false;
+    return /price|cost|revenue|total_revenue|total_amount|amount|subtotal|tax|discount|budget/i.test(key);
+}
+function prettifyKey(key) {
+    return key
+        .replace(/_/g, " ")
+        .replace(/\bid\b/gi, "ID")
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+// ============================================================================
+// COLUMN SELECTION
+// ============================================================================
+function selectColumns(rows, toolName) {
+    if (rows.length === 0)
+        return [];
+    // Collect all keys from first few rows
+    const allKeys = new Set();
+    for (const row of rows.slice(0, 5)) {
+        for (const key of Object.keys(row))
+            allKeys.add(key);
+    }
+    // Find matching priority list
+    const maxCols = isNarrow() ? 4 : 6;
+    let priority = [];
+    if (toolName) {
+        // Match tool name to category
+        for (const [category, cols] of Object.entries(PRIORITY_COLUMNS)) {
+            if (toolName.toLowerCase().includes(category)) {
+                priority = cols;
+                break;
+            }
+        }
+    }
+    // Build ordered column list: priority first, then remaining non-low-priority
+    const selected = [];
+    for (const col of priority) {
+        if (allKeys.has(col) && selected.length < maxCols) {
+            selected.push(col);
+        }
+    }
+    // Fill remaining slots with non-priority, non-low-priority keys
+    for (const key of allKeys) {
+        if (selected.length >= maxCols)
+            break;
+        if (selected.includes(key))
+            continue;
+        if (LOW_PRIORITY_KEYS.has(key))
+            continue;
+        // Skip arrays and nested objects from table columns — they don't render well
+        // in fixed-width tables. Nested objects show as "{...}" which is not useful.
+        const sample = rows[0][key];
+        if (Array.isArray(sample))
+            continue;
+        if (typeof sample === "object" && sample !== null)
+            continue;
+        selected.push(key);
+    }
+    return selected;
+}
+// ============================================================================
+// TABLE BUILDER
+// ============================================================================
+function buildTable(rows, columns) {
+    if (columns.length === 0 || rows.length === 0)
+        return "";
+    const headers = columns.map(prettifyKey);
+    // Calculate column widths
+    const widths = columns.map((col, i) => {
+        let max = headers[i].length;
+        for (const row of rows) {
+            const val = isMoneyKey(col) ? formatMoneyValue(row[col]) : formatValue(row[col], col);
+            max = Math.max(max, val.length);
+        }
+        return Math.min(max, 30); // Cap individual column width
+    });
+    // Header row
+    const headerRow = columns.map((_, i) => headers[i].padEnd(widths[i])).join(" | ");
+    const separator = widths.map(w => "-".repeat(w)).join(" | ");
+    // Data rows
+    const dataRows = rows.map(row => columns.map((col, i) => {
+        const val = isMoneyKey(col) ? formatMoneyValue(row[col]) : formatValue(row[col], col);
+        // Right-align numbers and money
+        const isNum = typeof row[col] === "number" || isMoneyKey(col);
+        return isNum ? val.padStart(widths[i]) : val.padEnd(widths[i]);
+    }).join(" | "));
+    return [
+        `| ${headerRow} |`,
+        `| ${separator} |`,
+        ...dataRows.map(r => `| ${r} |`),
+    ].join("\n");
+}
+// ============================================================================
+// ID REFERENCE — gives the LLM full UUIDs for follow-up calls
+// ============================================================================
+/** After a table, append a compact name→UUID mapping so the LLM can reference IDs */
+function buildIdReference(rows) {
+    if (rows.length === 0)
+        return "";
+    // Find the primary ID column — prefer 'id', fall back to 'product_id', 'customer_id', etc.
+    const idKey = ["id", "product_id", "customer_id", "order_id", "workflow_id"]
+        .find(k => rows.some(r => r[k] && typeof r[k] === "string"));
+    if (!idKey)
+        return "";
+    // Find a human-readable label key
+    const nameKey = ["name", "product_name", "first_name", "title", "subject", "label", "slug", "order_number"]
+        .find(k => rows[0][k] !== undefined) || null;
+    const entries = [];
+    for (const row of rows) {
+        const idVal = row[idKey];
+        if (!idVal || typeof idVal !== "string")
+            continue;
+        const label = nameKey && row[nameKey] ? String(row[nameKey]) : String(idVal).slice(0, 8);
+        entries.push(`${label}=${idVal}`);
+    }
+    if (entries.length === 0)
+        return "";
+    return `\nIDs: ${entries.join(", ")}`;
+}
+// ============================================================================
+// MAIN FORMATTER
+// ============================================================================
+function detectToolCategory(toolName) {
+    if (!toolName)
+        return undefined;
+    const name = toolName.toLowerCase();
+    for (const category of Object.keys(PRIORITY_COLUMNS)) {
+        if (name.includes(category))
+            return category;
+    }
+    return undefined;
+}
+/**
+ * Format a server tool response as readable markdown.
+ *
+ * @param data - The raw response data (parsed JSON)
+ * @param toolName - Optional tool name for smart column selection
+ * @returns Formatted markdown string
+ */
+export function formatServerResponse(data, toolName) {
+    // String passthrough
+    if (typeof data === "string")
+        return data;
+    // Shell execution tools (local_agent, kali) — stdout is the main content
+    if (toolName && (toolName === "local_agent" || toolName === "kali") && typeof data === "object" && data !== null && !Array.isArray(data)) {
+        const obj = data;
+        if ("stdout" in obj || "stderr" in obj || "exit_code" in obj) {
+            const stdout = String(obj.stdout || "").trim();
+            const stderr = String(obj.stderr || "").trim();
+            const exitCode = obj.exit_code;
+            const durationMs = obj.duration_ms;
+            // For successful commands, show stdout as primary output (like bash tool)
+            if (exitCode === 0 && stdout) {
+                const parts = [stdout];
+                if (stderr)
+                    parts.push(`\n**Stderr**: ${stderr}`);
+                // Compact metadata footer
+                const meta = [];
+                if (durationMs !== undefined)
+                    meta.push(`${durationMs}ms`);
+                if (obj.cwd)
+                    meta.push(`cwd: ${obj.cwd}`);
+                if (meta.length > 0)
+                    parts.push(`\n*${meta.join(" | ")}*`);
+                return parts.join("\n");
+            }
+            // For errors or no-stdout results, show structured output
+            const lines = [];
+            if (obj.error)
+                lines.push(`**Error**: ${String(obj.error)}`);
+            if (exitCode !== undefined && exitCode !== 0)
+                lines.push(`**Exit Code**: ${exitCode}`);
+            if (stdout)
+                lines.push(stdout);
+            if (stderr)
+                lines.push(`**Stderr**: ${stderr}`);
+            if (obj.killed)
+                lines.push(`**Killed**: process was terminated`);
+            if (durationMs !== undefined)
+                lines.push(`*${durationMs}ms${obj.cwd ? ` | cwd: ${obj.cwd}` : ""}*`);
+            return lines.join("\n") || "Command completed with no output.";
+        }
+    }
+    // Null/undefined
+    if (data === null || data === undefined)
+        return "No data returned.";
+    // Empty array
+    if (Array.isArray(data) && data.length === 0)
+        return "No results found.";
+    // Array of flat objects → markdown table
+    if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null) {
+        const rows = data;
+        const columns = selectColumns(rows, toolName);
+        if (columns.length > 0) {
+            const category = detectToolCategory(toolName);
+            const label = category ? prettifyKey(category) : "Results";
+            const header = `**${label}** (${rows.length} result${rows.length !== 1 ? "s" : ""})`;
+            const table = buildTable(rows, columns);
+            const idRef = buildIdReference(rows);
+            return `${header}\n\n${table}${idRef}`;
+        }
+    }
+    // Single object → bold key-value pairs + expand nested arrays as sub-tables
+    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+        const obj = data;
+        const scalarEntries = Object.entries(obj)
+            .filter(([key, val]) => {
+            if (LOW_PRIORITY_KEYS.has(key) && key !== "id")
+                return false;
+            return typeof val !== "object" || val === null;
+        });
+        // Nested objects (e.g. supplier, customer, profile joins) — extract their scalar fields
+        const nestedObjectEntries = Object.entries(obj)
+            .filter(([key, val]) => {
+            if (LOW_PRIORITY_KEYS.has(key))
+                return false;
+            return typeof val === "object" && val !== null && !Array.isArray(val);
+        });
+        const arrayEntries = Object.entries(obj)
+            .filter(([, val]) => Array.isArray(val) && val.length > 0 &&
+            typeof val[0] === "object");
+        if (scalarEntries.length > 0 || nestedObjectEntries.length > 0 || arrayEntries.length > 0) {
+            const parts = [];
+            // Scalar key-value pairs (with pagination awareness)
+            if (scalarEntries.length > 0 && scalarEntries.length <= 20) {
+                const hasPagination = typeof obj.total === "number" && typeof obj.count === "number";
+                const filteredScalars = scalarEntries.filter(([key]) => {
+                    if (!hasPagination)
+                        return true;
+                    // Skip raw pagination fields — shown as "Showing X of Y" instead
+                    if (key === "count" || key === "offset" || key === "limit")
+                        return false;
+                    return true;
+                });
+                const scalarLines = filteredScalars.map(([key, val]) => {
+                    // Replace "total" with "Showing X of Y" when pagination data exists
+                    if (hasPagination && key === "total" && typeof val === "number" && val > obj.count) {
+                        return `**Showing**: ${obj.count} of ${val}`;
+                    }
+                    const fmtVal = isMoneyKey(key) ? formatMoneyValue(val) : formatValue(val, key);
+                    return `**${prettifyKey(key)}**: ${fmtVal}`;
+                });
+                if (scalarLines.length > 0)
+                    parts.push(scalarLines.join("\n"));
+            }
+            // Nested objects — expand their scalar fields with parent key prefix
+            for (const [key, val] of nestedObjectEntries) {
+                const nested = val;
+                const nestedScalars = Object.entries(nested)
+                    .filter(([k, v]) => !LOW_PRIORITY_KEYS.has(k) && (typeof v !== "object" || v === null));
+                if (nestedScalars.length > 0 && nestedScalars.length <= 10) {
+                    const prefix = prettifyKey(key);
+                    const lines = nestedScalars.map(([k, v]) => {
+                        const fmtVal = isMoneyKey(k) ? formatMoneyValue(v) : formatValue(v, k);
+                        return `**${prefix} ${prettifyKey(k)}**: ${fmtVal}`;
+                    });
+                    parts.push(lines.join("\n"));
+                }
+            }
+            // Nested arrays as sub-tables (e.g. by_location, items, steps)
+            for (const [key, val] of arrayEntries) {
+                const rows = val;
+                // Use toolName for priority matching when the key is generic ("data", "results", etc.)
+                const colHint = ["data", "results", "items", "rows", "records"].includes(key) ? toolName : key;
+                const columns = selectColumns(rows, colHint);
+                if (columns.length > 0) {
+                    const table = buildTable(rows, columns);
+                    const idRef = buildIdReference(rows);
+                    parts.push(`\n**${prettifyKey(key)}** (${rows.length}):\n${table}${idRef}`);
+                }
+            }
+            if (parts.length > 0)
+                return parts.join("\n");
+        }
+    }
+    // Object with a data/results/items array (common API wrapper pattern)
+    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+        const obj = data;
+        for (const key of ["data", "results", "items", "rows", "records"]) {
+            if (Array.isArray(obj[key]) && obj[key].length > 0) {
+                // Format the nested array and prepend any summary fields
+                const summaryFields = [];
+                for (const [k, v] of Object.entries(obj)) {
+                    if (k === key)
+                        continue;
+                    if (typeof v !== "object" || v === null) {
+                        // Show total/offset/limit for pagination context
+                        if (k === "total" && typeof v === "number" && typeof obj.count === "number" && v > obj.count) {
+                            summaryFields.push(`**Showing**: ${obj.count} of ${v}`);
+                        }
+                        else if (k === "count" && obj.total !== undefined) {
+                            continue; // skip count when total is present (shown in "Showing X of Y")
+                        }
+                        else if (k === "offset" || k === "limit") {
+                            continue; // skip raw pagination params
+                        }
+                        else {
+                            summaryFields.push(`**${prettifyKey(k)}**: ${formatValue(v, k)}`);
+                        }
+                    }
+                }
+                const arrayResult = formatServerResponse(obj[key], toolName);
+                return summaryFields.length > 0
+                    ? `${summaryFields.join(" | ")}\n\n${arrayResult}`
+                    : arrayResult;
+            }
+        }
+    }
+    // Fallback: JSON fence
+    const json = JSON.stringify(data, null, 2);
+    return "```json\n" + json + "\n```";
+}

package/dist/cli/services/git-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Git Context — gather branch, status, recent commits for system prompt
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+export declare function gatherGitContext(): Promise<string>;
+/** Force refresh of git context (e.g. after a commit) */
+export declare function refreshGitContext(): void;
+/** Reset git context cache (called by resetSessionState) */
+export declare function resetGitContext(): void;

package/dist/cli/services/git-context.js

@@ -0,0 +1,66 @@
+/**
+ * Git Context — gather branch, status, recent commits for system prompt
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/** CLI-only: cached git context (cleared by refreshGitContext/resetGitContext) */
+let cachedGitContext = null;
+let gitContextCwd = null;
+export async function gatherGitContext() {
+    const cwd = process.cwd();
+    // Return cached if same cwd
+    if (cachedGitContext !== null && gitContextCwd === cwd)
+        return cachedGitContext;
+    gitContextCwd = cwd;
+    try {
+        await execAsync("git rev-parse --is-inside-work-tree", { cwd, timeout: 3000 });
+    }
+    catch {
+        cachedGitContext = "";
+        return "";
+    }
+    const parts = [];
+    try {
+        const { stdout } = await execAsync("git branch --show-current", { cwd, timeout: 3000 });
+        const branch = stdout.trim();
+        if (branch)
+            parts.push(`Branch: ${branch}`);
+    }
+    catch { /* skip */ }
+    try {
+        const { stdout } = await execAsync("git status --short 2>/dev/null | head -20", { cwd, timeout: 3000 });
+        const status = stdout.trim();
+        if (status) {
+            const lines = status.split("\n");
+            parts.push(`Status: ${lines.length} changed file${lines.length !== 1 ? "s" : ""}`);
+            parts.push(status);
+        }
+        else {
+            parts.push("Status: clean");
+        }
+    }
+    catch { /* skip */ }
+    try {
+        const { stdout } = await execAsync("git log --oneline -5 2>/dev/null", { cwd, timeout: 3000 });
+        const log = stdout.trim();
+        if (log)
+            parts.push(`Recent commits:\n${log}`);
+    }
+    catch { /* skip */ }
+    cachedGitContext = parts.length > 0 ? parts.join("\n") : "";
+    return cachedGitContext;
+}
+/** Force refresh of git context (e.g. after a commit) */
+export function refreshGitContext() {
+    cachedGitContext = null;
+    gitContextCwd = null;
+}
+/** Reset git context cache (called by resetSessionState) */
+export function resetGitContext() {
+    cachedGitContext = null;
+    gitContextCwd = null;
+}

package/dist/cli/services/hooks.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Hooks System — shell commands that run before/after tool calls and at session lifecycle events.
+ *
+ * Hooks are configured in:
+ *   - Project: .whale/hooks.json (array of HookConfig)
+ *   - User: ~/.swagmanager/hooks.json (array of HookConfig)
+ *
+ * Both are loaded and merged (project hooks run first).
+ *
+ * Hook process receives JSON on stdin:
+ *   { event, tool_name?, tool_input?, tool_output?, tool_success?, session_id? }
+ *
+ * Hook process may output JSON on stdout:
+ *   { allow?: boolean, message?: string, modified_input?: object, modified_output?: string }
+ *
+ * If allow: false, the tool call is blocked and message is returned as the tool result.
+ * If hook exits non-zero, it is logged as a warning but does not crash the session.
+ */
+export type HookEvent = "BeforeTool" | "AfterTool" | "SessionStart" | "SessionEnd" | "Notification";
+export interface HookConfig {
+    /** Which event triggers this hook */
+    event: HookEvent;
+    /** Shell command to run */
+    command: string;
+    /** Optional: only trigger for matching tool names (glob pattern) */
+    pattern?: string;
+    /** Max ms to wait for hook process (default 10000) */
+    timeout?: number;
+    /** Can hook modify the tool input/output? (default false) */
+    allowModify?: boolean;
+}
+/** JSON sent to hook process on stdin */
+interface HookPayload {
+    event: HookEvent;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: string;
+    tool_success?: boolean;
+    session_id?: string;
+}
+/** JSON output from hook process on stdout */
+interface HookResponse {
+    allow?: boolean;
+    message?: string;
+    modified_input?: Record<string, unknown>;
+    modified_output?: string;
+}
+/**
+ * Match a tool name against a simple glob pattern.
+ * Supports * (any chars) and ? (single char).
+ */
+export declare function matchGlob(pattern: string, name: string): boolean;
+/**
+ * Load hooks from project (.whale/hooks.json) and user (~/.swagmanager/hooks.json).
+ * Project hooks come first in the array, then user hooks.
+ * Invalid files are skipped with a warning.
+ */
+export declare function loadHooks(cwd: string): HookConfig[];
+/**
+ * Execute a hook command with JSON payload on stdin.
+ * Returns parsed JSON response from stdout, or null on error/timeout.
+ */
+export declare function executeHook(hook: HookConfig, payload: HookPayload): Promise<HookResponse | null>;
+/**
+ * Run BeforeTool hooks for a given tool call.
+ * Returns whether the tool call should proceed and optionally modified input.
+ */
+export declare function runBeforeToolHook(hooks: HookConfig[], toolName: string, input: Record<string, unknown>): Promise<{
+    allow: boolean;
+    message?: string;
+    modifiedInput?: Record<string, unknown>;
+}>;
+/**
+ * Run AfterTool hooks for a given tool result.
+ * Returns optionally modified output.
+ */
+export declare function runAfterToolHook(hooks: HookConfig[], toolName: string, output: string, success: boolean): Promise<{
+    modifiedOutput?: string;
+}>;
+/**
+ * Run session lifecycle hooks (SessionStart, SessionEnd, Notification).
+ * Fire-and-forget — errors are logged but don't affect session.
+ */
+export declare function runSessionHook(hooks: HookConfig[], event: "SessionStart" | "SessionEnd" | "Notification", data?: Record<string, unknown>): Promise<void>;
+export {};