@hope666/melu 1.0.0

package/dist/i18n.d.ts

@@ -0,0 +1,995 @@
+import { type MirrorName, type UiLanguage } from "./config.js";
+type TranslationParams = Record<string, string | number>;
+declare const MESSAGES: {
+    readonly en: {
+        readonly programDescription: "Melu - transparent AI memory proxy";
+        readonly cmdInitDescription: "Initial setup: create directories, config, and the default memory file";
+        readonly cmdRunDescription: "Run any agent with persistent memory";
+        readonly cmdStopDescription: "Stop the background proxy service";
+        readonly cmdListDescription: "List current memory entries";
+        readonly cmdDeleteDescription: "Delete a memory entry by ID prefix";
+        readonly cmdClearDescription: "Clear current memory entries (with confirmation)";
+        readonly cmdExportDescription: "Export current memory to a .memory file";
+        readonly cmdImportDescription: "Import memories from a .memory file";
+        readonly cmdStatusDescription: "Show service status, memory count, and model info";
+        readonly optMirrorDescription: "Model mirror source (huggingface | modelscope)";
+        readonly optMemoryDescription: "Memory file";
+        readonly optMemoryNameOrPathDescription: "Memory name or path";
+        readonly optAllDescription: "Include inactive memories";
+        readonly optYesDescription: "Skip confirmation";
+        readonly optPortDescription: "Proxy port";
+        readonly optOutputDescription: "Output file path";
+        readonly argCommandDescription: "Command to execute";
+        readonly initTitle: "Melu setup";
+        readonly labelDirectory: "Directory";
+        readonly labelConfig: "Config";
+        readonly labelMemory: "Memory";
+        readonly initComplete: "Setup complete!";
+        readonly labelMirrorSource: "Mirror source";
+        readonly embeddingModelReady: "Embedding model is ready.";
+        readonly usageRunClaude: "Usage: melu run -- claude";
+        readonly runProxy: "Proxy";
+        readonly runMemory: "Memory";
+        readonly memoryExtractionFailed: "[Melu] Memory extraction failed:";
+        readonly proxyNotRunning: "Proxy service is not running";
+        readonly proxyStopped: "Proxy service stopped (PID: {pid})";
+        readonly proxyAlreadyGone: "Proxy service is no longer running";
+        readonly memoryFileNotFound: "Memory file not found: {path}";
+        readonly noMemories: "No memories yet";
+        readonly memoriesTitle: "Memories ({count})";
+        readonly tableType: "Type";
+        readonly tableSubject: "Subject";
+        readonly tableSummary: "Summary";
+        readonly tableCreatedAt: "Created At";
+        readonly tableStatus: "Status";
+        readonly listShowHint: "Use \"melu show <id-prefix>\" to view full details of a memory.";
+        readonly memoryNotFoundByPrefix: "No memory found with ID prefix '{id}'";
+        readonly multipleMemoryMatches: "Multiple memories matched. Please provide a more specific ID.";
+        readonly deletedMemory: "Deleted: {summary}";
+        readonly memoryAlreadyEmpty: "Memory is already empty";
+        readonly confirmClearMemories: "Clear {count} memories? This cannot be undone (y/N): ";
+        readonly clearedMemories: "Cleared {count} memories";
+        readonly exportedTo: "Exported to: {path}";
+        readonly sourceFileNotFound: "File not found: {path}";
+        readonly importedMemories: "Imported {count} memories";
+        readonly statusRunning: "Proxy status: running (PID: {pid}, port: {port})";
+        readonly statusStopped: "Proxy status: stopped";
+        readonly statusMemoryFile: "Memory file: {path}";
+        readonly statusActiveMemories: "Active memories: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "Mirror source: {label}";
+        readonly statusModelFile: "Model file: {status}";
+        readonly statusDownloaded: "downloaded";
+        readonly statusNotDownloaded: "not downloaded";
+        readonly notSet: "Not set";
+        readonly portInUse: "Port {port} is already in use. Stop the conflicting process or choose a different port.";
+        readonly proxyStartupTimeout: "Proxy service startup timed out";
+        readonly extractingConversationMemories: "[Melu] Extracting memories from {count} conversations...";
+        readonly singleExtractionFailed: "[Melu] Failed to extract one queued item:";
+        readonly extractedNewMemories: "[Melu] Extracted {count} new memories this run";
+        readonly noNewMemories: "[Melu] No new memories this run";
+        readonly runSummaryTitle: "[Melu] Run summary ({runId})";
+        readonly runSummaryProcessed: "[Melu] Processed: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] Effective new memories: {count}";
+        readonly runSummaryFailed: "[Melu] Failed: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] Remaining queue: {count}";
+        readonly languagePromptTitle: "Select the display language for Melu:";
+        readonly menuHint: "Use arrow keys to move, Enter to confirm.";
+        readonly languagePromptInput: "Select a language:";
+        readonly languagePromptRetry: "Please select a valid option.";
+        readonly languageSet: "Display language: {language}";
+        readonly mirrorPromptTitle: "Select the source for the GGUF embedding model:";
+        readonly mirrorPromptInput: "Select a model source:";
+        readonly mirrorPromptRetry: "Please select a valid option.";
+        readonly mirrorHintHuggingFace: "Best for global network access";
+        readonly mirrorHintModelScope: "Best for mainland China network access";
+        readonly mirrorSelectionRequired: "A mirror source must be selected before model setup. Run `melu init --mirror huggingface` or `melu init --mirror modelscope`.";
+        readonly embeddingDownload: "[Melu] Downloading embedding model: {file}";
+        readonly labelSource: "[Melu] Source: {label}";
+        readonly labelSavedTo: "[Melu] Saving to: {path}";
+        readonly downloadProgressDownloadingTo: "Downloading to";
+        readonly downloadProgressDownloadedTo: "Downloaded to";
+        readonly modelAlreadyAvailable: "[Melu] Embedding model already found: {path}";
+        readonly modelSkipDownload: "[Melu] Skipping download.";
+        readonly runtimeBinaryUnavailable: "No prebuilt llama.cpp runtime is available on this platform. Melu does not auto-compile local native dependencies. Use Node 20+ on macOS, Linux, or Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Memory updated: '{summary}' replaced '{previous}'";
+        readonly memoryNew: "[Melu] New memory: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding failed:";
+        readonly claudePExtracting: "[Melu:DEBUG] Extracting memory via claude -p";
+        readonly claudePExitCode: "[Melu] claude -p exited with code {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] Failed to start claude -p: {message}";
+    };
+    readonly "zh-CN": {
+        readonly programDescription: "Melu - 透明 AI 记忆代理";
+        readonly cmdInitDescription: "首次初始化：创建目录、配置和默认记忆文件";
+        readonly cmdRunDescription: "带记忆启动任意 Agent";
+        readonly cmdStopDescription: "停止后台代理服务";
+        readonly cmdListDescription: "列出当前记忆条目";
+        readonly cmdDeleteDescription: "按 ID 前缀删除某条记忆";
+        readonly cmdClearDescription: "清空当前记忆（需确认）";
+        readonly cmdExportDescription: "导出当前记忆为 .memory 文件";
+        readonly cmdImportDescription: "从 .memory 文件导入记忆";
+        readonly cmdStatusDescription: "查看服务状态、记忆数量和模型信息";
+        readonly optMirrorDescription: "模型镜像源 (huggingface | modelscope)";
+        readonly optMemoryDescription: "记忆文件";
+        readonly optMemoryNameOrPathDescription: "记忆名称或路径";
+        readonly optAllDescription: "包含已失效的记忆";
+        readonly optYesDescription: "跳过确认";
+        readonly optPortDescription: "代理端口";
+        readonly optOutputDescription: "输出文件路径";
+        readonly argCommandDescription: "要执行的命令";
+        readonly initTitle: "Melu 初始化";
+        readonly labelDirectory: "目录";
+        readonly labelConfig: "配置";
+        readonly labelMemory: "记忆";
+        readonly initComplete: "初始化完成！";
+        readonly labelMirrorSource: "镜像源";
+        readonly embeddingModelReady: "Embedding 模型已准备完成。";
+        readonly usageRunClaude: "使用: melu run -- claude";
+        readonly runProxy: "代理";
+        readonly runMemory: "记忆";
+        readonly memoryExtractionFailed: "[Melu] 记忆提取失败:";
+        readonly proxyNotRunning: "代理服务未在运行";
+        readonly proxyStopped: "代理服务已停止 (PID: {pid})";
+        readonly proxyAlreadyGone: "代理服务已不存在";
+        readonly memoryFileNotFound: "记忆文件不存在: {path}";
+        readonly noMemories: "暂无记忆";
+        readonly memoriesTitle: "记忆 ({count} 条)";
+        readonly tableType: "类型";
+        readonly tableSubject: "主题";
+        readonly tableSummary: "摘要";
+        readonly tableCreatedAt: "创建时间";
+        readonly tableStatus: "状态";
+        readonly listShowHint: "使用 \"melu show <ID前缀>\" 查看记忆详情。";
+        readonly memoryNotFoundByPrefix: "未找到 ID 以 '{id}' 开头的记忆";
+        readonly multipleMemoryMatches: "匹配到多条记忆，请提供更精确的 ID。";
+        readonly deletedMemory: "已删除: {summary}";
+        readonly memoryAlreadyEmpty: "记忆已经是空的";
+        readonly confirmClearMemories: "确认清空 {count} 条记忆？此操作不可恢复 (y/N): ";
+        readonly clearedMemories: "已清空 {count} 条记忆";
+        readonly exportedTo: "已导出到: {path}";
+        readonly sourceFileNotFound: "文件不存在: {path}";
+        readonly importedMemories: "已导入 {count} 条记忆";
+        readonly statusRunning: "代理状态: 运行中 (PID: {pid}, 端口: {port})";
+        readonly statusStopped: "代理状态: 未运行";
+        readonly statusMemoryFile: "记忆文件: {path}";
+        readonly statusActiveMemories: "活跃记忆: {count} 条";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "镜像源: {label}";
+        readonly statusModelFile: "模型文件: {status}";
+        readonly statusDownloaded: "已下载";
+        readonly statusNotDownloaded: "未下载";
+        readonly notSet: "未设置";
+        readonly portInUse: "端口 {port} 已被占用，请先关闭占用进程或换一个端口。";
+        readonly proxyStartupTimeout: "代理服务启动超时";
+        readonly extractingConversationMemories: "[Melu] 正在提取 {count} 条对话的记忆...";
+        readonly singleExtractionFailed: "[Melu] 提取单条失败:";
+        readonly extractedNewMemories: "[Melu] 本次提取 {count} 条新记忆";
+        readonly noNewMemories: "[Melu] 本次无新记忆";
+        readonly runSummaryTitle: "[Melu] 运行摘要 ({runId})";
+        readonly runSummaryProcessed: "[Melu] 已处理: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] 有效新记忆: {count}";
+        readonly runSummaryFailed: "[Melu] 失败: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] 剩余队列: {count}";
+        readonly languagePromptTitle: "请选择 Melu 的显示语言：";
+        readonly menuHint: "使用方向键切换，按 Enter 确认。";
+        readonly languagePromptInput: "请选择语言：";
+        readonly languagePromptRetry: "请选择有效选项。";
+        readonly languageSet: "显示语言: {language}";
+        readonly mirrorPromptTitle: "请选择 GGUF embedding 模型的来源：";
+        readonly mirrorPromptInput: "请选择模型来源：";
+        readonly mirrorPromptRetry: "请选择有效选项。";
+        readonly mirrorHintHuggingFace: "适合全球网络环境";
+        readonly mirrorHintModelScope: "适合中国大陆网络环境";
+        readonly mirrorSelectionRequired: "首次准备模型前需要先选择镜像源。请运行 `melu init --mirror huggingface` 或 `melu init --mirror modelscope`。";
+        readonly embeddingDownload: "[Melu] 下载 embedding 模型: {file}";
+        readonly labelSource: "[Melu] 来源: {label}";
+        readonly labelSavedTo: "[Melu] 保存到: {path}";
+        readonly downloadProgressDownloadingTo: "下载到";
+        readonly downloadProgressDownloadedTo: "已下载到";
+        readonly modelAlreadyAvailable: "[Melu] 已检测到 embedding 模型: {path}";
+        readonly modelSkipDownload: "[Melu] 跳过下载。";
+        readonly runtimeBinaryUnavailable: "当前平台没有可用的 llama.cpp 预编译运行时。Melu 默认不会在用户机器上自动编译本地依赖。请使用 Node 20+，并在 macOS、Linux 或 Windows 的 arm64/x64 环境运行。";
+        readonly memoryUpdated: "[Melu] 记忆更新: '{summary}' 取代 '{previous}'";
+        readonly memoryNew: "[Melu] 新记忆: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding 失败:";
+        readonly claudePExtracting: "[Melu:DEBUG] 通过 claude -p 提取记忆";
+        readonly claudePExitCode: "[Melu] claude -p 退出码: {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] claude -p 启动失败: {message}";
+    };
+    readonly "zh-TW": {
+        readonly programDescription: "Melu - 透明 AI 記憶代理";
+        readonly cmdInitDescription: "首次初始化：建立目錄、設定與預設記憶檔案";
+        readonly cmdRunDescription: "帶著記憶啟動任意 Agent";
+        readonly cmdStopDescription: "停止背景代理服務";
+        readonly cmdListDescription: "列出目前的記憶項目";
+        readonly cmdDeleteDescription: "依 ID 前綴刪除記憶";
+        readonly cmdClearDescription: "清空目前記憶（需確認）";
+        readonly cmdExportDescription: "將目前記憶匯出為 .memory 檔案";
+        readonly cmdImportDescription: "從 .memory 檔案匯入記憶";
+        readonly cmdStatusDescription: "查看服務狀態、記憶數量與模型資訊";
+        readonly optMirrorDescription: "模型鏡像來源 (huggingface | modelscope)";
+        readonly optMemoryDescription: "記憶檔案";
+        readonly optMemoryNameOrPathDescription: "記憶名稱或路徑";
+        readonly optAllDescription: "包含已失效記憶";
+        readonly optYesDescription: "跳過確認";
+        readonly optPortDescription: "代理埠";
+        readonly optOutputDescription: "輸出檔案路徑";
+        readonly argCommandDescription: "要執行的命令";
+        readonly initTitle: "Melu 初始化";
+        readonly labelDirectory: "目錄";
+        readonly labelConfig: "設定";
+        readonly labelMemory: "記憶";
+        readonly initComplete: "初始化完成！";
+        readonly labelMirrorSource: "鏡像來源";
+        readonly embeddingModelReady: "Embedding 模型已準備完成。";
+        readonly usageRunClaude: "用法: melu run -- claude";
+        readonly runProxy: "代理";
+        readonly runMemory: "記憶";
+        readonly memoryExtractionFailed: "[Melu] 記憶提取失敗:";
+        readonly proxyNotRunning: "代理服務尚未運行";
+        readonly proxyStopped: "代理服務已停止 (PID: {pid})";
+        readonly proxyAlreadyGone: "代理服務已不存在";
+        readonly memoryFileNotFound: "找不到記憶檔案: {path}";
+        readonly noMemories: "目前沒有記憶";
+        readonly memoriesTitle: "記憶（{count} 條）";
+        readonly tableType: "類型";
+        readonly tableSubject: "主題";
+        readonly tableSummary: "摘要";
+        readonly tableCreatedAt: "建立時間";
+        readonly tableStatus: "狀態";
+        readonly listShowHint: "使用 \"melu show <ID前綴>\" 查看記憶詳情。";
+        readonly memoryNotFoundByPrefix: "找不到 ID 以前綴 '{id}' 開頭的記憶";
+        readonly multipleMemoryMatches: "找到多條相符記憶，請提供更精確的 ID。";
+        readonly deletedMemory: "已刪除: {summary}";
+        readonly memoryAlreadyEmpty: "記憶已經是空的";
+        readonly confirmClearMemories: "確認清空 {count} 條記憶？此操作無法復原 (y/N): ";
+        readonly clearedMemories: "已清空 {count} 條記憶";
+        readonly exportedTo: "已匯出到: {path}";
+        readonly sourceFileNotFound: "找不到檔案: {path}";
+        readonly importedMemories: "已匯入 {count} 條記憶";
+        readonly statusRunning: "代理狀態: 運行中 (PID: {pid}, 埠: {port})";
+        readonly statusStopped: "代理狀態: 未運行";
+        readonly statusMemoryFile: "記憶檔案: {path}";
+        readonly statusActiveMemories: "有效記憶: {count} 條";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "鏡像來源: {label}";
+        readonly statusModelFile: "模型檔案: {status}";
+        readonly statusDownloaded: "已下載";
+        readonly statusNotDownloaded: "未下載";
+        readonly notSet: "未設定";
+        readonly portInUse: "埠 {port} 已被占用，請先關閉占用程序或改用其他埠。";
+        readonly proxyStartupTimeout: "代理服務啟動逾時";
+        readonly extractingConversationMemories: "[Melu] 正在提取 {count} 條對話記憶...";
+        readonly singleExtractionFailed: "[Melu] 單條提取失敗:";
+        readonly extractedNewMemories: "[Melu] 本次提取了 {count} 條新記憶";
+        readonly noNewMemories: "[Melu] 本次沒有新記憶";
+        readonly runSummaryTitle: "[Melu] 運行摘要 ({runId})";
+        readonly runSummaryProcessed: "[Melu] 已處理: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] 有效新記憶: {count}";
+        readonly runSummaryFailed: "[Melu] 失敗: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] 剩餘佇列: {count}";
+        readonly languagePromptTitle: "請選擇 Melu 的顯示語言：";
+        readonly menuHint: "使用方向鍵切換，按 Enter 確認。";
+        readonly languagePromptInput: "請選擇語言：";
+        readonly languagePromptRetry: "請選擇有效選項。";
+        readonly languageSet: "顯示語言: {language}";
+        readonly mirrorPromptTitle: "請選擇 GGUF embedding 模型來源：";
+        readonly mirrorPromptInput: "請選擇模型來源：";
+        readonly mirrorPromptRetry: "請選擇有效選項。";
+        readonly mirrorHintHuggingFace: "適合全球網路環境";
+        readonly mirrorHintModelScope: "適合中國大陸網路環境";
+        readonly mirrorSelectionRequired: "首次準備模型前需要先選擇鏡像來源。請執行 `melu init --mirror huggingface` 或 `melu init --mirror modelscope`。";
+        readonly embeddingDownload: "[Melu] 下載 embedding 模型: {file}";
+        readonly labelSource: "[Melu] 來源: {label}";
+        readonly labelSavedTo: "[Melu] 儲存到: {path}";
+        readonly downloadProgressDownloadingTo: "下載到";
+        readonly downloadProgressDownloadedTo: "已下載到";
+        readonly modelAlreadyAvailable: "[Melu] 已偵測到 embedding 模型: {path}";
+        readonly modelSkipDownload: "[Melu] 略過下載。";
+        readonly runtimeBinaryUnavailable: "目前平台沒有可用的 llama.cpp 預編譯執行環境。Melu 不會自動在使用者機器上編譯本地原生依賴。請使用 Node 20+，並在 macOS、Linux 或 Windows 的 arm64/x64 環境運行。";
+        readonly memoryUpdated: "[Melu] 記憶已更新: '{summary}' 取代 '{previous}'";
+        readonly memoryNew: "[Melu] 新記憶: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding 失敗:";
+        readonly claudePExtracting: "[Melu:DEBUG] 透過 claude -p 提取記憶";
+        readonly claudePExitCode: "[Melu] claude -p 結束碼: {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] 無法啟動 claude -p: {message}";
+    };
+    readonly ja: {
+        readonly programDescription: "Melu - 透過的な AI メモリプロキシ";
+        readonly cmdInitDescription: "初期設定: ディレクトリ、設定、既定メモリを作成";
+        readonly cmdRunDescription: "永続メモリ付きで任意の Agent を起動";
+        readonly cmdStopDescription: "バックグラウンドのプロキシサービスを停止";
+        readonly cmdListDescription: "現在のメモリエントリを一覧表示";
+        readonly cmdDeleteDescription: "ID プレフィックスでメモリを削除";
+        readonly cmdClearDescription: "現在のメモリを消去（確認あり）";
+        readonly cmdExportDescription: "現在のメモリを .memory ファイルとして書き出す";
+        readonly cmdImportDescription: ".memory ファイルからメモリを読み込む";
+        readonly cmdStatusDescription: "サービス状態、メモリ数、モデル情報を表示";
+        readonly optMirrorDescription: "モデルのミラー元 (huggingface | modelscope)";
+        readonly optMemoryDescription: "メモリファイル";
+        readonly optMemoryNameOrPathDescription: "メモリ名またはパス";
+        readonly optAllDescription: "無効なメモリも含める";
+        readonly optYesDescription: "確認を省略";
+        readonly optPortDescription: "プロキシポート";
+        readonly optOutputDescription: "出力ファイルのパス";
+        readonly argCommandDescription: "実行するコマンド";
+        readonly initTitle: "Melu セットアップ";
+        readonly labelDirectory: "ディレクトリ";
+        readonly labelConfig: "設定";
+        readonly labelMemory: "メモリ";
+        readonly initComplete: "セットアップが完了しました。";
+        readonly labelMirrorSource: "ミラー元";
+        readonly embeddingModelReady: "Embedding モデルの準備ができました。";
+        readonly usageRunClaude: "使い方: melu run -- claude";
+        readonly runProxy: "プロキシ";
+        readonly runMemory: "メモリ";
+        readonly memoryExtractionFailed: "[Melu] メモリ抽出に失敗しました:";
+        readonly proxyNotRunning: "プロキシサービスは実行されていません";
+        readonly proxyStopped: "プロキシサービスを停止しました (PID: {pid})";
+        readonly proxyAlreadyGone: "プロキシサービスはすでに存在しません";
+        readonly memoryFileNotFound: "メモリファイルが見つかりません: {path}";
+        readonly noMemories: "メモリはまだありません";
+        readonly memoriesTitle: "メモリ ({count})";
+        readonly tableType: "種類";
+        readonly tableSubject: "件名";
+        readonly tableSummary: "要約";
+        readonly tableCreatedAt: "作成日時";
+        readonly tableStatus: "状態";
+        readonly listShowHint: "\"melu show <IDプレフィックス>\" でメモリの詳細を表示できます。";
+        readonly memoryNotFoundByPrefix: "ID が '{id}' で始まるメモリは見つかりません";
+        readonly multipleMemoryMatches: "複数のメモリが一致しました。より具体的な ID を指定してください。";
+        readonly deletedMemory: "削除しました: {summary}";
+        readonly memoryAlreadyEmpty: "メモリはすでに空です";
+        readonly confirmClearMemories: "{count} 件のメモリを削除しますか？この操作は元に戻せません (y/N): ";
+        readonly clearedMemories: "{count} 件のメモリを削除しました";
+        readonly exportedTo: "書き出し先: {path}";
+        readonly sourceFileNotFound: "ファイルが見つかりません: {path}";
+        readonly importedMemories: "{count} 件のメモリを読み込みました";
+        readonly statusRunning: "プロキシ状態: 実行中 (PID: {pid}, ポート: {port})";
+        readonly statusStopped: "プロキシ状態: 停止中";
+        readonly statusMemoryFile: "メモリファイル: {path}";
+        readonly statusActiveMemories: "有効メモリ: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "ミラー元: {label}";
+        readonly statusModelFile: "モデルファイル: {status}";
+        readonly statusDownloaded: "ダウンロード済み";
+        readonly statusNotDownloaded: "未ダウンロード";
+        readonly notSet: "未設定";
+        readonly portInUse: "ポート {port} はすでに使用されています。競合するプロセスを停止するか、別のポートを指定してください。";
+        readonly proxyStartupTimeout: "プロキシサービスの起動がタイムアウトしました";
+        readonly extractingConversationMemories: "[Melu] {count} 件の会話からメモリを抽出しています...";
+        readonly singleExtractionFailed: "[Melu] 1 件の抽出に失敗しました:";
+        readonly extractedNewMemories: "[Melu] 今回新たに {count} 件のメモリを抽出しました";
+        readonly noNewMemories: "[Melu] 今回新しいメモリはありませんでした";
+        readonly runSummaryTitle: "[Melu] 実行サマリー ({runId})";
+        readonly runSummaryProcessed: "[Melu] 処理済み: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] 有効な新メモリ: {count}";
+        readonly runSummaryFailed: "[Melu] 失敗: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] 残りキュー: {count}";
+        readonly languagePromptTitle: "Melu の表示言語を選択してください:";
+        readonly menuHint: "矢印キーで移動し、Enter で確定します。";
+        readonly languagePromptInput: "言語を選択してください:";
+        readonly languagePromptRetry: "有効な選択肢を選んでください。";
+        readonly languageSet: "表示言語: {language}";
+        readonly mirrorPromptTitle: "GGUF embedding モデルの取得元を選択してください:";
+        readonly mirrorPromptInput: "モデルの取得元を選択してください:";
+        readonly mirrorPromptRetry: "有効な選択肢を選んでください。";
+        readonly mirrorHintHuggingFace: "グローバルなネットワーク環境向け";
+        readonly mirrorHintModelScope: "中国本土のネットワーク環境向け";
+        readonly mirrorSelectionRequired: "モデル準備の前にミラー元の選択が必要です。`melu init --mirror huggingface` または `melu init --mirror modelscope` を実行してください。";
+        readonly embeddingDownload: "[Melu] Embedding モデルをダウンロードしています: {file}";
+        readonly labelSource: "[Melu] 取得元: {label}";
+        readonly labelSavedTo: "[Melu] 保存先: {path}";
+        readonly downloadProgressDownloadingTo: "ダウンロード先";
+        readonly downloadProgressDownloadedTo: "ダウンロード済み";
+        readonly modelAlreadyAvailable: "[Melu] 既存の embedding モデルを検出しました: {path}";
+        readonly modelSkipDownload: "[Melu] ダウンロードをスキップします。";
+        readonly runtimeBinaryUnavailable: "このプラットフォームでは利用可能な事前ビルド済み llama.cpp ランタイムがありません。Melu はローカルのネイティブ依存関係を自動コンパイルしません。Node 20+ を使用し、macOS / Linux / Windows の arm64/x64 環境で実行してください。";
+        readonly memoryUpdated: "[Melu] メモリを更新しました: '{summary}' が '{previous}' を置き換えました";
+        readonly memoryNew: "[Melu] 新しいメモリ: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding に失敗しました:";
+        readonly claudePExtracting: "[Melu:DEBUG] claude -p でメモリを抽出しています";
+        readonly claudePExitCode: "[Melu] claude -p の終了コード: {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] claude -p の起動に失敗しました: {message}";
+    };
+    readonly ko: {
+        readonly programDescription: "Melu - 투명한 AI 메모리 프록시";
+        readonly cmdInitDescription: "초기 설정: 디렉터리, 설정, 기본 메모리 파일 생성";
+        readonly cmdRunDescription: "지속 메모리와 함께 Agent 실행";
+        readonly cmdStopDescription: "백그라운드 프록시 서비스 중지";
+        readonly cmdListDescription: "현재 메모리 항목 표시";
+        readonly cmdDeleteDescription: "ID 접두사로 메모리 삭제";
+        readonly cmdClearDescription: "현재 메모리 비우기(확인 필요)";
+        readonly cmdExportDescription: "현재 메모리를 .memory 파일로 내보내기";
+        readonly cmdImportDescription: ".memory 파일에서 메모리 가져오기";
+        readonly cmdStatusDescription: "서비스 상태, 메모리 수, 모델 정보 표시";
+        readonly optMirrorDescription: "모델 미러 소스 (huggingface | modelscope)";
+        readonly optMemoryDescription: "메모리 파일";
+        readonly optMemoryNameOrPathDescription: "메모리 이름 또는 경로";
+        readonly optAllDescription: "비활성 메모리 포함";
+        readonly optYesDescription: "확인 건너뛰기";
+        readonly optPortDescription: "프록시 포트";
+        readonly optOutputDescription: "출력 파일 경로";
+        readonly argCommandDescription: "실행할 명령";
+        readonly initTitle: "Melu 설정";
+        readonly labelDirectory: "디렉터리";
+        readonly labelConfig: "설정";
+        readonly labelMemory: "메모리";
+        readonly initComplete: "설정이 완료되었습니다.";
+        readonly labelMirrorSource: "미러 소스";
+        readonly embeddingModelReady: "Embedding 모델이 준비되었습니다.";
+        readonly usageRunClaude: "사용법: melu run -- claude";
+        readonly runProxy: "프록시";
+        readonly runMemory: "메모리";
+        readonly memoryExtractionFailed: "[Melu] 메모리 추출 실패:";
+        readonly proxyNotRunning: "프록시 서비스가 실행 중이 아닙니다";
+        readonly proxyStopped: "프록시 서비스가 중지되었습니다 (PID: {pid})";
+        readonly proxyAlreadyGone: "프록시 서비스가 이미 종료되었습니다";
+        readonly memoryFileNotFound: "메모리 파일을 찾을 수 없습니다: {path}";
+        readonly noMemories: "메모리가 없습니다";
+        readonly memoriesTitle: "메모리 ({count})";
+        readonly tableType: "유형";
+        readonly tableSubject: "주제";
+        readonly tableSummary: "요약";
+        readonly tableCreatedAt: "생성 시간";
+        readonly tableStatus: "상태";
+        readonly listShowHint: "\"melu show <ID접두사>\" 로 메모리 세부 정보를 확인할 수 있습니다.";
+        readonly memoryNotFoundByPrefix: "ID가 '{id}'로 시작하는 메모리를 찾을 수 없습니다";
+        readonly multipleMemoryMatches: "여러 메모리가 일치합니다. 더 구체적인 ID를 입력하세요.";
+        readonly deletedMemory: "삭제됨: {summary}";
+        readonly memoryAlreadyEmpty: "메모리가 이미 비어 있습니다";
+        readonly confirmClearMemories: "{count}개의 메모리를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다 (y/N): ";
+        readonly clearedMemories: "{count}개의 메모리를 삭제했습니다";
+        readonly exportedTo: "내보낸 위치: {path}";
+        readonly sourceFileNotFound: "파일을 찾을 수 없습니다: {path}";
+        readonly importedMemories: "{count}개의 메모리를 가져왔습니다";
+        readonly statusRunning: "프록시 상태: 실행 중 (PID: {pid}, 포트: {port})";
+        readonly statusStopped: "프록시 상태: 중지됨";
+        readonly statusMemoryFile: "메모리 파일: {path}";
+        readonly statusActiveMemories: "활성 메모리: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "미러 소스: {label}";
+        readonly statusModelFile: "모델 파일: {status}";
+        readonly statusDownloaded: "다운로드됨";
+        readonly statusNotDownloaded: "다운로드되지 않음";
+        readonly notSet: "설정되지 않음";
+        readonly portInUse: "포트 {port}가 이미 사용 중입니다. 충돌하는 프로세스를 종료하거나 다른 포트를 선택하세요.";
+        readonly proxyStartupTimeout: "프록시 서비스 시작 시간이 초과되었습니다";
+        readonly extractingConversationMemories: "[Melu] {count}개의 대화에서 메모리를 추출하는 중...";
+        readonly singleExtractionFailed: "[Melu] 대기 항목 1개 추출 실패:";
+        readonly extractedNewMemories: "[Melu] 이번 실행에서 {count}개의 새 메모리를 추출했습니다";
+        readonly noNewMemories: "[Melu] 이번 실행에서는 새 메모리가 없습니다";
+        readonly runSummaryTitle: "[Melu] 실행 요약 ({runId})";
+        readonly runSummaryProcessed: "[Melu] 처리됨: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] 유효한 새 메모리: {count}";
+        readonly runSummaryFailed: "[Melu] 실패: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] 남은 큐: {count}";
+        readonly languagePromptTitle: "Melu 표시 언어를 선택하세요:";
+        readonly menuHint: "방향키로 이동하고 Enter로 선택하세요.";
+        readonly languagePromptInput: "언어를 선택하세요:";
+        readonly languagePromptRetry: "유효한 항목을 선택하세요.";
+        readonly languageSet: "표시 언어: {language}";
+        readonly mirrorPromptTitle: "GGUF embedding 모델의 소스를 선택하세요:";
+        readonly mirrorPromptInput: "모델 소스를 선택하세요:";
+        readonly mirrorPromptRetry: "유효한 항목을 선택하세요.";
+        readonly mirrorHintHuggingFace: "전 세계 네트워크 환경에 적합";
+        readonly mirrorHintModelScope: "중국 본토 네트워크 환경에 적합";
+        readonly mirrorSelectionRequired: "모델 설정 전에 미러 소스를 선택해야 합니다. `melu init --mirror huggingface` 또는 `melu init --mirror modelscope`를 실행하세요.";
+        readonly embeddingDownload: "[Melu] Embedding 모델 다운로드 중: {file}";
+        readonly labelSource: "[Melu] 소스: {label}";
+        readonly labelSavedTo: "[Melu] 저장 위치: {path}";
+        readonly downloadProgressDownloadingTo: "다운로드 위치";
+        readonly downloadProgressDownloadedTo: "다운로드 완료 위치";
+        readonly modelAlreadyAvailable: "[Melu] 기존 embedding 모델을 찾았습니다: {path}";
+        readonly modelSkipDownload: "[Melu] 다운로드를 건너뜁니다.";
+        readonly runtimeBinaryUnavailable: "이 플랫폼에서는 사용할 수 있는 사전 빌드된 llama.cpp 런타임이 없습니다. Melu는 로컬 네이티브 의존성을 자동으로 컴파일하지 않습니다. Node 20+ 및 macOS / Linux / Windows arm64/x64 환경을 사용하세요.";
+        readonly memoryUpdated: "[Melu] 메모리 업데이트: '{summary}'가 '{previous}'를 대체했습니다";
+        readonly memoryNew: "[Melu] 새 메모리: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding 실패:";
+        readonly claudePExtracting: "[Melu:DEBUG] claude -p로 메모리를 추출하는 중";
+        readonly claudePExitCode: "[Melu] claude -p 종료 코드: {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] claude -p 시작 실패: {message}";
+    };
+    readonly fr: {
+        readonly programDescription: "Melu - proxy de mémoire IA transparent";
+        readonly cmdInitDescription: "Configuration initiale : créer les dossiers, la config et la mémoire par défaut";
+        readonly cmdRunDescription: "Exécuter un agent avec mémoire persistante";
+        readonly cmdStopDescription: "Arrêter le service proxy en arrière-plan";
+        readonly cmdListDescription: "Lister les entrées mémoire actuelles";
+        readonly cmdDeleteDescription: "Supprimer une mémoire via son préfixe d'ID";
+        readonly cmdClearDescription: "Vider la mémoire actuelle (avec confirmation)";
+        readonly cmdExportDescription: "Exporter la mémoire actuelle vers un fichier .memory";
+        readonly cmdImportDescription: "Importer des mémoires depuis un fichier .memory";
+        readonly cmdStatusDescription: "Afficher l'état du service, le nombre de mémoires et les infos du modèle";
+        readonly optMirrorDescription: "Source miroir du modèle (huggingface | modelscope)";
+        readonly optMemoryDescription: "Fichier mémoire";
+        readonly optMemoryNameOrPathDescription: "Nom ou chemin de la mémoire";
+        readonly optAllDescription: "Inclure les mémoires inactives";
+        readonly optYesDescription: "Ignorer la confirmation";
+        readonly optPortDescription: "Port du proxy";
+        readonly optOutputDescription: "Chemin du fichier de sortie";
+        readonly argCommandDescription: "Commande à exécuter";
+        readonly initTitle: "Configuration de Melu";
+        readonly labelDirectory: "Répertoire";
+        readonly labelConfig: "Config";
+        readonly labelMemory: "Mémoire";
+        readonly initComplete: "Configuration terminée.";
+        readonly labelMirrorSource: "Source miroir";
+        readonly embeddingModelReady: "Le modèle d'embedding est prêt.";
+        readonly usageRunClaude: "Utilisation : melu run -- claude";
+        readonly runProxy: "Proxy";
+        readonly runMemory: "Mémoire";
+        readonly memoryExtractionFailed: "[Melu] Échec de l'extraction de mémoire :";
+        readonly proxyNotRunning: "Le service proxy n'est pas en cours d'exécution";
+        readonly proxyStopped: "Service proxy arrêté (PID : {pid})";
+        readonly proxyAlreadyGone: "Le service proxy n'existe plus";
+        readonly memoryFileNotFound: "Fichier mémoire introuvable : {path}";
+        readonly noMemories: "Aucune mémoire pour le moment";
+        readonly memoriesTitle: "Mémoires ({count})";
+        readonly tableType: "Type";
+        readonly tableSubject: "Sujet";
+        readonly tableSummary: "Résumé";
+        readonly tableCreatedAt: "Créé le";
+        readonly tableStatus: "État";
+        readonly listShowHint: "Utilisez \"melu show <préfixe-ID>\" pour voir les détails d'une mémoire.";
+        readonly memoryNotFoundByPrefix: "Aucune mémoire trouvée avec le préfixe d'ID '{id}'";
+        readonly multipleMemoryMatches: "Plusieurs mémoires correspondent. Veuillez fournir un ID plus précis.";
+        readonly deletedMemory: "Supprimé : {summary}";
+        readonly memoryAlreadyEmpty: "La mémoire est déjà vide";
+        readonly confirmClearMemories: "Supprimer {count} mémoires ? Cette action est irréversible (y/N) : ";
+        readonly clearedMemories: "{count} mémoires supprimées";
+        readonly exportedTo: "Exporté vers : {path}";
+        readonly sourceFileNotFound: "Fichier introuvable : {path}";
+        readonly importedMemories: "{count} mémoires importées";
+        readonly statusRunning: "État du proxy : en cours (PID : {pid}, port : {port})";
+        readonly statusStopped: "État du proxy : arrêté";
+        readonly statusMemoryFile: "Fichier mémoire : {path}";
+        readonly statusActiveMemories: "Mémoires actives : {count}";
+        readonly statusEmbedding: "Embedding : {model}";
+        readonly statusMirrorSource: "Source miroir : {label}";
+        readonly statusModelFile: "Fichier modèle : {status}";
+        readonly statusDownloaded: "téléchargé";
+        readonly statusNotDownloaded: "non téléchargé";
+        readonly notSet: "non défini";
+        readonly portInUse: "Le port {port} est déjà utilisé. Arrêtez le processus en conflit ou choisissez un autre port.";
+        readonly proxyStartupTimeout: "Délai de démarrage du service proxy dépassé";
+        readonly extractingConversationMemories: "[Melu] Extraction des mémoires à partir de {count} conversations...";
+        readonly singleExtractionFailed: "[Melu] Échec de l'extraction d'un élément en attente :";
+        readonly extractedNewMemories: "[Melu] {count} nouvelles mémoires extraites lors de cette exécution";
+        readonly noNewMemories: "[Melu] Aucune nouvelle mémoire lors de cette exécution";
+        readonly runSummaryTitle: "[Melu] résumé d'exécution ({runId})";
+        readonly runSummaryProcessed: "[Melu] traités : {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] nouvelles mémoires utiles : {count}";
+        readonly runSummaryFailed: "[Melu] échecs : {count}";
+        readonly runSummaryRemainingQueue: "[Melu] file restante : {count}";
+        readonly languagePromptTitle: "Sélectionnez la langue d'affichage de Melu :";
+        readonly menuHint: "Utilisez les flèches pour naviguer, puis Entrée pour confirmer.";
+        readonly languagePromptInput: "Sélectionnez une langue :";
+        readonly languagePromptRetry: "Veuillez sélectionner une option valide.";
+        readonly languageSet: "Langue d'affichage : {language}";
+        readonly mirrorPromptTitle: "Sélectionnez la source du modèle GGUF d'embedding :";
+        readonly mirrorPromptInput: "Sélectionnez une source de modèle :";
+        readonly mirrorPromptRetry: "Veuillez sélectionner une option valide.";
+        readonly mirrorHintHuggingFace: "Recommandé pour un accès réseau mondial";
+        readonly mirrorHintModelScope: "Recommandé pour le réseau de Chine continentale";
+        readonly mirrorSelectionRequired: "Une source miroir doit être choisie avant la configuration du modèle. Exécutez `melu init --mirror huggingface` ou `melu init --mirror modelscope`.";
+        readonly embeddingDownload: "[Melu] Téléchargement du modèle d'embedding : {file}";
+        readonly labelSource: "[Melu] Source : {label}";
+        readonly labelSavedTo: "[Melu] Enregistrement dans : {path}";
+        readonly downloadProgressDownloadingTo: "Téléchargement vers";
+        readonly downloadProgressDownloadedTo: "Téléchargé vers";
+        readonly modelAlreadyAvailable: "[Melu] Modèle d'embedding déjà détecté : {path}";
+        readonly modelSkipDownload: "[Melu] Téléchargement ignoré.";
+        readonly runtimeBinaryUnavailable: "Aucun runtime llama.cpp précompilé n'est disponible sur cette plateforme. Melu ne compile pas automatiquement les dépendances natives locales. Utilisez Node 20+ sur macOS, Linux ou Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Mémoire mise à jour : '{summary}' a remplacé '{previous}'";
+        readonly memoryNew: "[Melu] Nouvelle mémoire : [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Échec de l'embedding :";
+        readonly claudePExtracting: "[Melu:DEBUG] Extraction de mémoire via claude -p";
+        readonly claudePExitCode: "[Melu] Code de sortie de claude -p : {code}, stderr : {stderr}";
+        readonly claudePStartFailed: "[Melu] Impossible de démarrer claude -p : {message}";
+    };
+    readonly ru: {
+        readonly programDescription: "Melu - прозрачный прокси долговременной памяти ИИ";
+        readonly cmdInitDescription: "Первичная настройка: создать каталоги, конфиг и файл памяти по умолчанию";
+        readonly cmdRunDescription: "Запустить любой Agent с постоянной памятью";
+        readonly cmdStopDescription: "Остановить фоновый прокси-сервис";
+        readonly cmdListDescription: "Показать текущие записи памяти";
+        readonly cmdDeleteDescription: "Удалить запись памяти по префиксу ID";
+        readonly cmdClearDescription: "Очистить текущую память (с подтверждением)";
+        readonly cmdExportDescription: "Экспортировать текущую память в файл .memory";
+        readonly cmdImportDescription: "Импортировать память из файла .memory";
+        readonly cmdStatusDescription: "Показать состояние сервиса, число записей памяти и сведения о модели";
+        readonly optMirrorDescription: "Источник зеркала модели (huggingface | modelscope)";
+        readonly optMemoryDescription: "Файл памяти";
+        readonly optMemoryNameOrPathDescription: "Имя памяти или путь";
+        readonly optAllDescription: "Включить неактивные записи памяти";
+        readonly optYesDescription: "Пропустить подтверждение";
+        readonly optPortDescription: "Порт прокси";
+        readonly optOutputDescription: "Путь к выходному файлу";
+        readonly argCommandDescription: "Команда для выполнения";
+        readonly initTitle: "Настройка Melu";
+        readonly labelDirectory: "Каталог";
+        readonly labelConfig: "Конфиг";
+        readonly labelMemory: "Память";
+        readonly initComplete: "Настройка завершена.";
+        readonly labelMirrorSource: "Источник зеркала";
+        readonly embeddingModelReady: "Модель embedding готова.";
+        readonly usageRunClaude: "Использование: melu run -- claude";
+        readonly runProxy: "Прокси";
+        readonly runMemory: "Память";
+        readonly memoryExtractionFailed: "[Melu] Не удалось извлечь память:";
+        readonly proxyNotRunning: "Прокси-сервис не запущен";
+        readonly proxyStopped: "Прокси-сервис остановлен (PID: {pid})";
+        readonly proxyAlreadyGone: "Прокси-сервис уже не существует";
+        readonly memoryFileNotFound: "Файл памяти не найден: {path}";
+        readonly noMemories: "Память пока пуста";
+        readonly memoriesTitle: "Память ({count})";
+        readonly tableType: "Тип";
+        readonly tableSubject: "Тема";
+        readonly tableSummary: "Сводка";
+        readonly tableCreatedAt: "Создано";
+        readonly tableStatus: "Статус";
+        readonly listShowHint: "Используйте \"melu show <префикс-ID>\" для просмотра подробностей.";
+        readonly memoryNotFoundByPrefix: "Запись памяти с префиксом ID '{id}' не найдена";
+        readonly multipleMemoryMatches: "Найдено несколько совпадений. Укажите более точный ID.";
+        readonly deletedMemory: "Удалено: {summary}";
+        readonly memoryAlreadyEmpty: "Память уже пуста";
+        readonly confirmClearMemories: "Очистить {count} записей памяти? Это действие нельзя отменить (y/N): ";
+        readonly clearedMemories: "Очищено {count} записей памяти";
+        readonly exportedTo: "Экспортировано в: {path}";
+        readonly sourceFileNotFound: "Файл не найден: {path}";
+        readonly importedMemories: "Импортировано {count} записей памяти";
+        readonly statusRunning: "Статус прокси: запущен (PID: {pid}, порт: {port})";
+        readonly statusStopped: "Статус прокси: остановлен";
+        readonly statusMemoryFile: "Файл памяти: {path}";
+        readonly statusActiveMemories: "Активных записей памяти: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "Источник зеркала: {label}";
+        readonly statusModelFile: "Файл модели: {status}";
+        readonly statusDownloaded: "загружен";
+        readonly statusNotDownloaded: "не загружен";
+        readonly notSet: "не задано";
+        readonly portInUse: "Порт {port} уже занят. Остановите конфликтующий процесс или выберите другой порт.";
+        readonly proxyStartupTimeout: "Истекло время запуска прокси-сервиса";
+        readonly extractingConversationMemories: "[Melu] Извлечение памяти из {count} диалогов...";
+        readonly singleExtractionFailed: "[Melu] Не удалось обработать один элемент очереди:";
+        readonly extractedNewMemories: "[Melu] За этот запуск извлечено {count} новых записей памяти";
+        readonly noNewMemories: "[Melu] В этом запуске новых записей памяти нет";
+        readonly runSummaryTitle: "[Melu] сводка запуска ({runId})";
+        readonly runSummaryProcessed: "[Melu] обработано: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] полезных новых записей: {count}";
+        readonly runSummaryFailed: "[Melu] ошибок: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] очередь осталась: {count}";
+        readonly languagePromptTitle: "Выберите язык интерфейса Melu:";
+        readonly menuHint: "Используйте стрелки для выбора и Enter для подтверждения.";
+        readonly languagePromptInput: "Выберите язык:";
+        readonly languagePromptRetry: "Выберите корректный вариант.";
+        readonly languageSet: "Язык интерфейса: {language}";
+        readonly mirrorPromptTitle: "Выберите источник GGUF embedding модели:";
+        readonly mirrorPromptInput: "Выберите источник модели:";
+        readonly mirrorPromptRetry: "Выберите корректный вариант.";
+        readonly mirrorHintHuggingFace: "Подходит для глобального доступа к сети";
+        readonly mirrorHintModelScope: "Подходит для сетевой среды материкового Китая";
+        readonly mirrorSelectionRequired: "Перед настройкой модели нужно выбрать источник зеркала. Выполните `melu init --mirror huggingface` или `melu init --mirror modelscope`.";
+        readonly embeddingDownload: "[Melu] Загрузка embedding модели: {file}";
+        readonly labelSource: "[Melu] Источник: {label}";
+        readonly labelSavedTo: "[Melu] Сохранение в: {path}";
+        readonly downloadProgressDownloadingTo: "Загрузка в";
+        readonly downloadProgressDownloadedTo: "Загружено в";
+        readonly modelAlreadyAvailable: "[Melu] Embedding модель уже найдена: {path}";
+        readonly modelSkipDownload: "[Melu] Загрузка пропущена.";
+        readonly runtimeBinaryUnavailable: "Для этой платформы нет доступного предсобранного runtime llama.cpp. Melu не компилирует локальные нативные зависимости автоматически. Используйте Node 20+ на macOS, Linux или Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Память обновлена: '{summary}' заменила '{previous}'";
+        readonly memoryNew: "[Melu] Новая память: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Ошибка embedding:";
+        readonly claudePExtracting: "[Melu:DEBUG] Извлечение памяти через claude -p";
+        readonly claudePExitCode: "[Melu] Код выхода claude -p: {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] Не удалось запустить claude -p: {message}";
+    };
+    readonly de: {
+        readonly programDescription: "Melu - transparenter KI-Speicher-Proxy";
+        readonly cmdInitDescription: "Ersteinrichtung: Verzeichnisse, Konfiguration und Standard-Speicherdatei erstellen";
+        readonly cmdRunDescription: "Beliebigen Agent mit dauerhaftem Speicher ausführen";
+        readonly cmdStopDescription: "Den Hintergrund-Proxy-Dienst beenden";
+        readonly cmdListDescription: "Aktuelle Speichereinträge auflisten";
+        readonly cmdDeleteDescription: "Einen Speichereintrag per ID-Präfix löschen";
+        readonly cmdClearDescription: "Aktuellen Speicher leeren (mit Bestätigung)";
+        readonly cmdExportDescription: "Aktuellen Speicher in eine .memory-Datei exportieren";
+        readonly cmdImportDescription: "Speicher aus einer .memory-Datei importieren";
+        readonly cmdStatusDescription: "Dienststatus, Anzahl der Erinnerungen und Modellinfos anzeigen";
+        readonly optMirrorDescription: "Modell-Spiegelquelle (huggingface | modelscope)";
+        readonly optMemoryDescription: "Speicherdatei";
+        readonly optMemoryNameOrPathDescription: "Speichername oder Pfad";
+        readonly optAllDescription: "Inaktive Erinnerungen einschließen";
+        readonly optYesDescription: "Bestätigung überspringen";
+        readonly optPortDescription: "Proxy-Port";
+        readonly optOutputDescription: "Pfad der Ausgabedatei";
+        readonly argCommandDescription: "Auszuführender Befehl";
+        readonly initTitle: "Melu-Einrichtung";
+        readonly labelDirectory: "Verzeichnis";
+        readonly labelConfig: "Konfiguration";
+        readonly labelMemory: "Speicher";
+        readonly initComplete: "Einrichtung abgeschlossen!";
+        readonly labelMirrorSource: "Spiegelquelle";
+        readonly embeddingModelReady: "Das Embedding-Modell ist bereit.";
+        readonly usageRunClaude: "Verwendung: melu run -- claude";
+        readonly runProxy: "Proxy";
+        readonly runMemory: "Speicher";
+        readonly memoryExtractionFailed: "[Melu] Speicherauszug fehlgeschlagen:";
+        readonly proxyNotRunning: "Der Proxy-Dienst läuft nicht";
+        readonly proxyStopped: "Proxy-Dienst gestoppt (PID: {pid})";
+        readonly proxyAlreadyGone: "Der Proxy-Dienst existiert nicht mehr";
+        readonly memoryFileNotFound: "Speicherdatei nicht gefunden: {path}";
+        readonly noMemories: "Noch keine Erinnerungen";
+        readonly memoriesTitle: "Erinnerungen ({count})";
+        readonly tableType: "Typ";
+        readonly tableSubject: "Thema";
+        readonly tableSummary: "Zusammenfassung";
+        readonly tableCreatedAt: "Erstellt am";
+        readonly tableStatus: "Status";
+        readonly listShowHint: "Verwenden Sie \"melu show <ID-Präfix>\" für Details einer Erinnerung.";
+        readonly memoryNotFoundByPrefix: "Keine Erinnerung mit ID-Präfix '{id}' gefunden";
+        readonly multipleMemoryMatches: "Mehrere Erinnerungen gefunden. Bitte gib eine genauere ID an.";
+        readonly deletedMemory: "Gelöscht: {summary}";
+        readonly memoryAlreadyEmpty: "Der Speicher ist bereits leer";
+        readonly confirmClearMemories: "{count} Erinnerungen löschen? Dieser Vorgang kann nicht rückgängig gemacht werden (y/N): ";
+        readonly clearedMemories: "{count} Erinnerungen gelöscht";
+        readonly exportedTo: "Exportiert nach: {path}";
+        readonly sourceFileNotFound: "Datei nicht gefunden: {path}";
+        readonly importedMemories: "{count} Erinnerungen importiert";
+        readonly statusRunning: "Proxy-Status: läuft (PID: {pid}, Port: {port})";
+        readonly statusStopped: "Proxy-Status: gestoppt";
+        readonly statusMemoryFile: "Speicherdatei: {path}";
+        readonly statusActiveMemories: "Aktive Erinnerungen: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "Spiegelquelle: {label}";
+        readonly statusModelFile: "Modelldatei: {status}";
+        readonly statusDownloaded: "heruntergeladen";
+        readonly statusNotDownloaded: "nicht heruntergeladen";
+        readonly notSet: "Nicht festgelegt";
+        readonly portInUse: "Port {port} wird bereits verwendet. Beende den Konfliktprozess oder wähle einen anderen Port.";
+        readonly proxyStartupTimeout: "Zeitüberschreitung beim Start des Proxy-Dienstes";
+        readonly extractingConversationMemories: "[Melu] Extrahiere Erinnerungen aus {count} Unterhaltungen...";
+        readonly singleExtractionFailed: "[Melu] Ein Eintrag aus der Warteschlange konnte nicht extrahiert werden:";
+        readonly extractedNewMemories: "[Melu] Bei diesem Lauf wurden {count} neue Erinnerungen extrahiert";
+        readonly noNewMemories: "[Melu] Bei diesem Lauf wurden keine neuen Erinnerungen extrahiert";
+        readonly runSummaryTitle: "[Melu] Ausführungsübersicht ({runId})";
+        readonly runSummaryProcessed: "[Melu] verarbeitet: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] nützliche neue Erinnerungen: {count}";
+        readonly runSummaryFailed: "[Melu] fehlgeschlagen: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] verbleibende Warteschlange: {count}";
+        readonly languagePromptTitle: "Wähle die Anzeigesprache für Melu:";
+        readonly menuHint: "Mit den Pfeiltasten navigieren, mit Enter bestätigen.";
+        readonly languagePromptInput: "Sprache auswählen:";
+        readonly languagePromptRetry: "Bitte eine gültige Option auswählen.";
+        readonly languageSet: "Anzeigesprache: {language}";
+        readonly mirrorPromptTitle: "Wähle die Quelle für das GGUF-Embedding-Modell:";
+        readonly mirrorPromptInput: "Modellquelle auswählen:";
+        readonly mirrorPromptRetry: "Bitte eine gültige Option auswählen.";
+        readonly mirrorHintHuggingFace: "Empfohlen für globale Netzwerke";
+        readonly mirrorHintModelScope: "Empfohlen für Netzwerke auf dem chinesischen Festland";
+        readonly mirrorSelectionRequired: "Vor der Modelleinrichtung muss eine Spiegelquelle gewählt werden. Führe `melu init --mirror huggingface` oder `melu init --mirror modelscope` aus.";
+        readonly embeddingDownload: "[Melu] Embedding-Modell wird heruntergeladen: {file}";
+        readonly labelSource: "[Melu] Quelle: {label}";
+        readonly labelSavedTo: "[Melu] Speichern nach: {path}";
+        readonly downloadProgressDownloadingTo: "Herunterladen nach";
+        readonly downloadProgressDownloadedTo: "Heruntergeladen nach";
+        readonly modelAlreadyAvailable: "[Melu] Embedding-Modell bereits gefunden: {path}";
+        readonly modelSkipDownload: "[Melu] Download wird übersprungen.";
+        readonly runtimeBinaryUnavailable: "Für diese Plattform ist keine vorgebaute llama.cpp-Laufzeit verfügbar. Melu kompiliert lokale native Abhängigkeiten nicht automatisch. Verwende Node 20+ unter macOS, Linux oder Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Erinnerung aktualisiert: '{summary}' ersetzte '{previous}'";
+        readonly memoryNew: "[Melu] Neue Erinnerung: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Embedding fehlgeschlagen:";
+        readonly claudePExtracting: "[Melu:DEBUG] Extrahiere Erinnerung über claude -p";
+        readonly claudePExitCode: "[Melu] claude -p wurde mit Code {code} beendet, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] Start von claude -p fehlgeschlagen: {message}";
+    };
+    readonly es: {
+        readonly programDescription: "Melu - proxy transparente de memoria de IA";
+        readonly cmdInitDescription: "Configuración inicial: crear directorios, configuración y archivo de memoria predeterminado";
+        readonly cmdRunDescription: "Ejecutar cualquier agent con memoria persistente";
+        readonly cmdStopDescription: "Detener el servicio proxy en segundo plano";
+        readonly cmdListDescription: "Listar las entradas de memoria actuales";
+        readonly cmdDeleteDescription: "Eliminar una memoria por prefijo de ID";
+        readonly cmdClearDescription: "Vaciar la memoria actual (con confirmación)";
+        readonly cmdExportDescription: "Exportar la memoria actual a un archivo .memory";
+        readonly cmdImportDescription: "Importar memorias desde un archivo .memory";
+        readonly cmdStatusDescription: "Mostrar estado del servicio, cantidad de memorias e información del modelo";
+        readonly optMirrorDescription: "Origen espejo del modelo (huggingface | modelscope)";
+        readonly optMemoryDescription: "Archivo de memoria";
+        readonly optMemoryNameOrPathDescription: "Nombre o ruta de la memoria";
+        readonly optAllDescription: "Incluir memorias inactivas";
+        readonly optYesDescription: "Omitir confirmación";
+        readonly optPortDescription: "Puerto del proxy";
+        readonly optOutputDescription: "Ruta del archivo de salida";
+        readonly argCommandDescription: "Comando a ejecutar";
+        readonly initTitle: "Configuración de Melu";
+        readonly labelDirectory: "Directorio";
+        readonly labelConfig: "Configuración";
+        readonly labelMemory: "Memoria";
+        readonly initComplete: "¡Configuración completada!";
+        readonly labelMirrorSource: "Origen espejo";
+        readonly embeddingModelReady: "El modelo de embedding está listo.";
+        readonly usageRunClaude: "Uso: melu run -- claude";
+        readonly runProxy: "Proxy";
+        readonly runMemory: "Memoria";
+        readonly memoryExtractionFailed: "[Melu] Falló la extracción de memoria:";
+        readonly proxyNotRunning: "El servicio proxy no está en ejecución";
+        readonly proxyStopped: "Servicio proxy detenido (PID: {pid})";
+        readonly proxyAlreadyGone: "El servicio proxy ya no existe";
+        readonly memoryFileNotFound: "Archivo de memoria no encontrado: {path}";
+        readonly noMemories: "Aún no hay memorias";
+        readonly memoriesTitle: "Memorias ({count})";
+        readonly tableType: "Tipo";
+        readonly tableSubject: "Tema";
+        readonly tableSummary: "Resumen";
+        readonly tableCreatedAt: "Creado el";
+        readonly tableStatus: "Estado";
+        readonly listShowHint: "Use \"melu show <prefijo-ID>\" para ver los detalles de una memoria.";
+        readonly memoryNotFoundByPrefix: "No se encontró ninguna memoria con el prefijo de ID '{id}'";
+        readonly multipleMemoryMatches: "Se encontraron varias memorias. Proporciona un ID más específico.";
+        readonly deletedMemory: "Eliminado: {summary}";
+        readonly memoryAlreadyEmpty: "La memoria ya está vacía";
+        readonly confirmClearMemories: "¿Eliminar {count} memorias? Esta acción no se puede deshacer (y/N): ";
+        readonly clearedMemories: "Se eliminaron {count} memorias";
+        readonly exportedTo: "Exportado a: {path}";
+        readonly sourceFileNotFound: "Archivo no encontrado: {path}";
+        readonly importedMemories: "Se importaron {count} memorias";
+        readonly statusRunning: "Estado del proxy: en ejecución (PID: {pid}, puerto: {port})";
+        readonly statusStopped: "Estado del proxy: detenido";
+        readonly statusMemoryFile: "Archivo de memoria: {path}";
+        readonly statusActiveMemories: "Memorias activas: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "Origen espejo: {label}";
+        readonly statusModelFile: "Archivo del modelo: {status}";
+        readonly statusDownloaded: "descargado";
+        readonly statusNotDownloaded: "no descargado";
+        readonly notSet: "No establecido";
+        readonly portInUse: "El puerto {port} ya está en uso. Detén el proceso en conflicto o elige otro puerto.";
+        readonly proxyStartupTimeout: "Tiempo de espera agotado al iniciar el servicio proxy";
+        readonly extractingConversationMemories: "[Melu] Extrayendo memorias de {count} conversaciones...";
+        readonly singleExtractionFailed: "[Melu] No se pudo extraer un elemento en cola:";
+        readonly extractedNewMemories: "[Melu] En esta ejecución se extrajeron {count} memorias nuevas";
+        readonly noNewMemories: "[Melu] No se extrajeron memorias nuevas en esta ejecución";
+        readonly runSummaryTitle: "[Melu] resumen de ejecución ({runId})";
+        readonly runSummaryProcessed: "[Melu] procesadas: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] nuevas memorias útiles: {count}";
+        readonly runSummaryFailed: "[Melu] fallos: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] cola restante: {count}";
+        readonly languagePromptTitle: "Selecciona el idioma de visualización de Melu:";
+        readonly menuHint: "Usa las flechas para moverte y Enter para confirmar.";
+        readonly languagePromptInput: "Selecciona un idioma:";
+        readonly languagePromptRetry: "Selecciona una opción válida.";
+        readonly languageSet: "Idioma de visualización: {language}";
+        readonly mirrorPromptTitle: "Selecciona el origen del modelo GGUF de embedding:";
+        readonly mirrorPromptInput: "Selecciona una fuente del modelo:";
+        readonly mirrorPromptRetry: "Selecciona una opción válida.";
+        readonly mirrorHintHuggingFace: "Recomendado para redes globales";
+        readonly mirrorHintModelScope: "Recomendado para redes de China continental";
+        readonly mirrorSelectionRequired: "Debes elegir un origen espejo antes de configurar el modelo. Ejecuta `melu init --mirror huggingface` o `melu init --mirror modelscope`.";
+        readonly embeddingDownload: "[Melu] Descargando modelo de embedding: {file}";
+        readonly labelSource: "[Melu] Origen: {label}";
+        readonly labelSavedTo: "[Melu] Guardando en: {path}";
+        readonly downloadProgressDownloadingTo: "Descargando en";
+        readonly downloadProgressDownloadedTo: "Descargado en";
+        readonly modelAlreadyAvailable: "[Melu] Modelo de embedding ya encontrado: {path}";
+        readonly modelSkipDownload: "[Melu] Omitiendo descarga.";
+        readonly runtimeBinaryUnavailable: "No hay un runtime precompilado de llama.cpp disponible para esta plataforma. Melu no compila automáticamente dependencias nativas locales. Usa Node 20+ en macOS, Linux o Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Memoria actualizada: '{summary}' reemplazó a '{previous}'";
+        readonly memoryNew: "[Melu] Nueva memoria: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Falló el embedding:";
+        readonly claudePExtracting: "[Melu:DEBUG] Extrayendo memoria mediante claude -p";
+        readonly claudePExitCode: "[Melu] claude -p salió con código {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] No se pudo iniciar claude -p: {message}";
+    };
+    readonly pt: {
+        readonly programDescription: "Melu - proxy transparente de memória de IA";
+        readonly cmdInitDescription: "Configuração inicial: criar diretórios, configuração e arquivo de memória padrão";
+        readonly cmdRunDescription: "Executar qualquer agent com memória persistente";
+        readonly cmdStopDescription: "Parar o serviço de proxy em segundo plano";
+        readonly cmdListDescription: "Listar as entradas de memória atuais";
+        readonly cmdDeleteDescription: "Excluir uma memória pelo prefixo do ID";
+        readonly cmdClearDescription: "Limpar a memória atual (com confirmação)";
+        readonly cmdExportDescription: "Exportar a memória atual para um arquivo .memory";
+        readonly cmdImportDescription: "Importar memórias de um arquivo .memory";
+        readonly cmdStatusDescription: "Mostrar status do serviço, quantidade de memórias e informações do modelo";
+        readonly optMirrorDescription: "Fonte espelho do modelo (huggingface | modelscope)";
+        readonly optMemoryDescription: "Arquivo de memória";
+        readonly optMemoryNameOrPathDescription: "Nome ou caminho da memória";
+        readonly optAllDescription: "Incluir memórias inativas";
+        readonly optYesDescription: "Pular confirmação";
+        readonly optPortDescription: "Porta do proxy";
+        readonly optOutputDescription: "Caminho do arquivo de saída";
+        readonly argCommandDescription: "Comando a executar";
+        readonly initTitle: "Configuração do Melu";
+        readonly labelDirectory: "Diretório";
+        readonly labelConfig: "Configuração";
+        readonly labelMemory: "Memória";
+        readonly initComplete: "Configuração concluída!";
+        readonly labelMirrorSource: "Fonte espelho";
+        readonly embeddingModelReady: "O modelo de embedding está pronto.";
+        readonly usageRunClaude: "Uso: melu run -- claude";
+        readonly runProxy: "Proxy";
+        readonly runMemory: "Memória";
+        readonly memoryExtractionFailed: "[Melu] Falha na extração de memória:";
+        readonly proxyNotRunning: "O serviço de proxy não está em execução";
+        readonly proxyStopped: "Serviço de proxy parado (PID: {pid})";
+        readonly proxyAlreadyGone: "O serviço de proxy não existe mais";
+        readonly memoryFileNotFound: "Arquivo de memória não encontrado: {path}";
+        readonly noMemories: "Ainda não há memórias";
+        readonly memoriesTitle: "Memórias ({count})";
+        readonly tableType: "Tipo";
+        readonly tableSubject: "Assunto";
+        readonly tableSummary: "Resumo";
+        readonly tableCreatedAt: "Criado em";
+        readonly tableStatus: "Status";
+        readonly listShowHint: "Use \"melu show <prefixo-ID>\" para ver os detalhes de uma memória.";
+        readonly memoryNotFoundByPrefix: "Nenhuma memória encontrada com o prefixo de ID '{id}'";
+        readonly multipleMemoryMatches: "Várias memórias corresponderam. Forneça um ID mais específico.";
+        readonly deletedMemory: "Excluído: {summary}";
+        readonly memoryAlreadyEmpty: "A memória já está vazia";
+        readonly confirmClearMemories: "Excluir {count} memórias? Esta ação não pode ser desfeita (y/N): ";
+        readonly clearedMemories: "{count} memórias excluídas";
+        readonly exportedTo: "Exportado para: {path}";
+        readonly sourceFileNotFound: "Arquivo não encontrado: {path}";
+        readonly importedMemories: "{count} memórias importadas";
+        readonly statusRunning: "Status do proxy: em execução (PID: {pid}, porta: {port})";
+        readonly statusStopped: "Status do proxy: parado";
+        readonly statusMemoryFile: "Arquivo de memória: {path}";
+        readonly statusActiveMemories: "Memórias ativas: {count}";
+        readonly statusEmbedding: "Embedding: {model}";
+        readonly statusMirrorSource: "Fonte espelho: {label}";
+        readonly statusModelFile: "Arquivo do modelo: {status}";
+        readonly statusDownloaded: "baixado";
+        readonly statusNotDownloaded: "não baixado";
+        readonly notSet: "Não definido";
+        readonly portInUse: "A porta {port} já está em uso. Encerre o processo em conflito ou escolha outra porta.";
+        readonly proxyStartupTimeout: "Tempo limite ao iniciar o serviço de proxy";
+        readonly extractingConversationMemories: "[Melu] Extraindo memórias de {count} conversas...";
+        readonly singleExtractionFailed: "[Melu] Falha ao extrair um item da fila:";
+        readonly extractedNewMemories: "[Melu] Nesta execução foram extraídas {count} novas memórias";
+        readonly noNewMemories: "[Melu] Nenhuma nova memória foi extraída nesta execução";
+        readonly runSummaryTitle: "[Melu] resumo da execução ({runId})";
+        readonly runSummaryProcessed: "[Melu] processadas: {count}";
+        readonly runSummaryEffectiveNewMemories: "[Melu] novas memórias úteis: {count}";
+        readonly runSummaryFailed: "[Melu] falhas: {count}";
+        readonly runSummaryRemainingQueue: "[Melu] fila restante: {count}";
+        readonly languagePromptTitle: "Selecione o idioma de exibição do Melu:";
+        readonly menuHint: "Use as setas para navegar e Enter para confirmar.";
+        readonly languagePromptInput: "Selecione um idioma:";
+        readonly languagePromptRetry: "Selecione uma opção válida.";
+        readonly languageSet: "Idioma de exibição: {language}";
+        readonly mirrorPromptTitle: "Selecione a fonte do modelo GGUF de embedding:";
+        readonly mirrorPromptInput: "Selecione a fonte do modelo:";
+        readonly mirrorPromptRetry: "Selecione uma opção válida.";
+        readonly mirrorHintHuggingFace: "Recomendado para redes globais";
+        readonly mirrorHintModelScope: "Recomendado para redes da China continental";
+        readonly mirrorSelectionRequired: "Você precisa escolher uma fonte espelho antes de configurar o modelo. Execute `melu init --mirror huggingface` ou `melu init --mirror modelscope`.";
+        readonly embeddingDownload: "[Melu] Baixando modelo de embedding: {file}";
+        readonly labelSource: "[Melu] Fonte: {label}";
+        readonly labelSavedTo: "[Melu] Salvando em: {path}";
+        readonly downloadProgressDownloadingTo: "Baixando para";
+        readonly downloadProgressDownloadedTo: "Baixado para";
+        readonly modelAlreadyAvailable: "[Melu] Modelo de embedding já encontrado: {path}";
+        readonly modelSkipDownload: "[Melu] Ignorando download.";
+        readonly runtimeBinaryUnavailable: "Não há um runtime pré-compilado do llama.cpp disponível para esta plataforma. O Melu não compila automaticamente dependências nativas locais. Use Node 20+ no macOS, Linux ou Windows arm64/x64.";
+        readonly memoryUpdated: "[Melu] Memória atualizada: '{summary}' substituiu '{previous}'";
+        readonly memoryNew: "[Melu] Nova memória: [{category}] {summary}";
+        readonly embeddingFailed: "[Melu] Falha no embedding:";
+        readonly claudePExtracting: "[Melu:DEBUG] Extraindo memória via claude -p";
+        readonly claudePExitCode: "[Melu] claude -p terminou com código {code}, stderr: {stderr}";
+        readonly claudePStartFailed: "[Melu] Falha ao iniciar claude -p: {message}";
+    };
+};
+export type TranslationKey = keyof typeof MESSAGES.en;
+export declare function resolveUiLanguage(language: UiLanguage | null | undefined): UiLanguage;
+export declare function getUiLanguageLabel(language: UiLanguage): string;
+export declare function t(language: UiLanguage | null | undefined, key: TranslationKey, params?: TranslationParams): string;
+export declare function createI18n(language: UiLanguage | null | undefined): {
+    language: "en" | "zh-CN" | "zh-TW" | "ja" | "ko" | "fr" | "ru" | "de" | "es" | "pt";
+    t(key: TranslationKey, params?: TranslationParams): string;
+};
+export declare function getLocalizedMirrorLabel(mirror: MirrorName, _language: UiLanguage | null | undefined): string;
+export {};
+//# sourceMappingURL=i18n.d.ts.map