dsh-blackjack 0.1.4 → 0.2.0

package/dist/commands.js

@@ -1,16 +1,12 @@
 import { ApiError } from './api.js';
-import { CONSENT_TEXT, renderMe, renderRound } from './render.js';
-const AGREE_HINT = '请先阅读须知并执行 /blackjack agree 后再使用。';
-const NO_ROUND_HINT = '当前没有进行中的牌局，先用 /blackjack deal 开一局。';
-const USAGE = 'agree | deal [注额] | exchange [数量] | reset';
-const n = (v) => v.toLocaleString('en-US');
+import { renderMe, renderRound } from './render.js';
 const ACTIONS = [
-    { name: 'bj-hit', action: 'hit', description: '21 点：向牌桌要一张牌' },
-    { name: 'bj-stand', action: 'stand', description: '21 点：停牌，进入结算' },
-    { name: 'bj-double', action: 'double', description: '21 点：加倍注额并再要一张牌' },
-    { name: 'bj-split', action: 'split', description: '21 点：把一对相同点数的牌分成两手' },
-    { name: 'bj-insure', action: 'insure', description: '21 点：庄家明牌为 A 时购买保险' },
-    { name: 'bj-decline', action: 'decline', description: '21 点：不购买保险' },
+    { name: 'bj-hit', action: 'hit' },
+    { name: 'bj-stand', action: 'stand' },
+    { name: 'bj-double', action: 'double' },
+    { name: 'bj-split', action: 'split' },
+    { name: 'bj-insure', action: 'insure' },
+    { name: 'bj-decline', action: 'decline' },
 ];
 function ok(text) {
     return { kind: 'success', text };
@@ -26,10 +22,11 @@ function fail(text) {
  *
  * Handlers must never throw: an uncaught throw settles as `command/done`
  * with `kind:'error'` and writes internal detail into the session log, so
- * every branch below is wrapped to translate failures into plain Chinese.
+ * every branch below is wrapped to translate failures into `m`'s
+ * plain-language copy (never internal status codes, URLs, or stack traces).
  */
 export function registerCommands(ctx, deps) {
-    const { api, identity } = deps;
+    const { api, identity, m } = deps;
     // Cheap in-memory hint for "which round is active" so most actions skip a
     // round-trip; always falls back to the server (api.activeRound) when this
     // is empty, e.g. right after a process restart.
@@ -37,33 +34,41 @@ export function registerCommands(ctx, deps) {
     function noteRound(round) {
         activeRoundId = round.phase === 'settled' ? undefined : round.id;
     }
-    /** Translate a caught failure into player-safe Chinese. Never leaks status codes, URLs, or stack traces. */
+    /**
+     * Pull a numeric structured-detail field out of an `ApiError`, or
+     * `undefined` if it's missing or the wrong type.
+     *
+     * Missing/malformed is not the normal case — every code that ships with a
+     * detail field always sends it (see the site table in
+     * `packages/server/src/http.ts`'s `playerError` call sites) — but a
+     * cross-version mismatch (an older server that has the code but not yet the
+     * field) must be handled without inventing a number. **Do not default this
+     * to 0**: review caught an earlier version of this file doing exactly that,
+     * which renders a false statement ("needs 0 CHIP" / "the most you can raise
+     * is 0 CHIP") — a refusal quoting a threshold of zero is worse than a
+     * generic refusal, because it's actively wrong, not just vague. Every call
+     * site below falls back to `m.genericFailure()` when this returns
+     * `undefined`, rather than passing a fabricated number to a `Messages`
+     * method that promises a real one.
+     */
+    function numberDetail(e, key) {
+        const v = e.details[key];
+        return typeof v === 'number' ? v : undefined;
+    }
+    /** Translate a caught failure into player-safe copy in the resolved locale. Never leaks status codes, URLs, stack traces, or the server's raw code/message. */
     async function mapError(e, token) {
         if (!(e instanceof ApiError))
-            return fail('操作没有成功，请稍后再试。');
-        if (e.status === 0 || e.status >= 500)
-            return fail('暂时连不上牌桌服务，请稍后再试。');
-        if (e.status === 403 && e.code === 'no free hands left')
-            return fail('今天的免费手用完了，明天再来。');
-        if (e.status === 403 && e.code === 'below threshold')
-            return fail('余额还没到兑换门槛。');
-        if (e.status === 402)
-            return fail('余额不足以完成这个动作。');
-        // 404 = 这局在服务端已经不存在了（最常见的来路：玩家刚在图形牌桌上把它打
-        // 完，而这里的 activeRoundId 还停在旧 id 上）。缓存必须清掉，否则下一条动作
-        // 命令会拿着同一个死 id 再撞一次；提示也要说清楚该怎么办，而不是给一句通用
-        // 的"操作没有成功"。
-        if (e.status === 404) {
-            activeRoundId = undefined;
-            return fail(NO_ROUND_HINT);
-        }
-        if (e.status === 409) {
+            return fail(m.genericFailure());
+        // 409：已经有一局在进行中——把那一局连同牌面一起找回来展示，而不是只丢
+        // 一句"已经有一局在进行中"。找不到（网络失败，或局已经在这之间结束）就
+        // 退化成那句纯文本，绝不让这里的失败盖住原始的 409。
+        const activeRoundExists = async () => {
             if (token) {
                 try {
                     const round = await api.activeRound(token);
                     if (round) {
                         noteRound(round);
-                        return fail(['已经有一局在进行中。', renderRound(round)].join('\n'));
+                        return fail([m.roundAlreadyInProgress(), renderRound(round, m)].join('\n'));
                     }
                 }
                 catch {
@@ -71,15 +76,93 @@ export function registerCommands(ctx, deps) {
                     // failure here mask the original 409.
                 }
             }
-            return fail('已经有一局在进行中。');
+            return fail(m.roundAlreadyInProgress());
+        };
+        // 这局在服务端已经不存在了（最常见的来路：玩家刚在图形牌桌上把它打完，
+        // 而这里的 activeRoundId 还停在旧 id 上）。缓存必须清掉，否则下一条动作
+        // 命令会拿着同一个死 id 再撞一次；提示也要说清楚该怎么办，而不是给一句
+        // 通用的"操作没有成功"。
+        const roundNotFound = () => {
+            activeRoundId = undefined;
+            return fail(m.noRoundHint());
+        };
+        // 按 code 匹配是 Task 7 的核心：改之前这里比对的其实是服务端的英文散文
+        // （`ApiError.code` 曾经被塞进了 message），一旦服务端改一个字，这些分支
+        // 就悄悄失效却不报错。现在 code 是服务端 `playerError()` 发的稳定
+        // kebab-case 标识，是两边的 API 契约。
+        //
+        // **这个 switch 必须先于 status>=500 短路运行**（review 抓到的一个真实
+        // bug）：`exchange-unavailable` 就是走 503 的，之前的版本在 switch 前面
+        // 挡了一句"status===0 || status>=500 就返回 serviceUnreachable()"，
+        // 那句"暂时连不上牌桌服务"的通用兜底会先接管，`exchange-unavailable`
+        // 这个 case 因此永远执行不到——牌局本身明明是好的，玩家却被告知"整个
+        // 服务连不上"，误导他去重启插件。5xx 的兜底现在挪到了 `default` 分支里，
+        // 只在 code 不在下面这张已知表里时才生效。
+        switch (e.code) {
+            case 'no-free-hands-left': return fail(m.dailyFreeHandsExhausted());
+            case 'below-exchange-threshold': {
+                const thresholdChips = numberDetail(e, 'thresholdChips');
+                return thresholdChips === undefined ? fail(m.genericFailure()) : fail(m.belowExchangeThreshold(thresholdChips));
+            }
+            case 'would-exceed-season-cap': {
+                const capChips = numberDetail(e, 'capChips');
+                const exchangedThisSeasonChips = numberDetail(e, 'exchangedThisSeasonChips');
+                return capChips === undefined || exchangedThisSeasonChips === undefined
+                    ? fail(m.genericFailure())
+                    : fail(m.seasonCapReached(capChips, exchangedThisSeasonChips));
+            }
+            case 'github-binding-required': return fail(m.githubBindingRequired());
+            case 'exchange-unavailable': return fail(m.exchangeUnavailable());
+            case 'insufficient-balance': return fail(m.insufficientBalance());
+            case 'bet-amount-too-high': {
+                const maxChips = numberDetail(e, 'maxChips');
+                return maxChips === undefined ? fail(m.genericFailure()) : fail(m.betAmountAboveLimit(maxChips));
+            }
+            case 'illegal-action': return fail(m.illegalAction());
+            case 'register-rate-limited': return fail(m.registerRateLimited());
+            // 401：服务端不认识本机这枚令牌。这条以前是裸 `{ error: 'unauthorized' }`，
+            // 没有 code，于是落进 default → `genericFailure()`，玩家看到"请稍后再试"
+            // ——而这个场景里稍后再试永远不会好（令牌不会自己变回被认识的样子）。
+            // 现在服务端发 `unknown-player-token`，这里给出真的能走出去的两步。
+            case 'unknown-player-token': return fail(m.unknownPlayerToken());
+            case 'round-not-found': return roundNotFound();
+            case 'active-round-exists': return activeRoundExists();
+            // 这四个 code 存在是为了 API 契约的完整性（服务端所有玩家可见错误都
+            // 带稳定 code），但插件自己从不会产出触发它们的请求：`mode` 是硬编码
+            // 常量，注额/兑换数量在发出前已经做过整数校验（`invalid-bet-amount`
+            // 现在专指"不是正整数"这个格式问题，`doDeal` 早在发出请求前就挡掉了；
+            // 真正现实可达的"超过上限"已经拆成了上面的 `bet-amount-too-high`），
+            // `bet-not-insurable` 只在运营者把汇率配成奇数时出现。真撞上说明协议
+            // 之外出了什么问题，通用兜底文案已经足够，不值得为一句玩家永远看不到
+            // 的话专门写文案。
+            case 'invalid-mode':
+            case 'invalid-chip-amount':
+            case 'invalid-bet-amount':
+            case 'bet-not-insurable':
+                return fail(m.genericFailure());
+            default:
+                // 未知 code：可能来自比这版插件更新的服务端（加了新 code 没同步），
+                // 也可能是插件这边漏映射了。**这正是"兜底必须存在"这条要求所在**：
+                // 按 HTTP 状态语义能猜的就猜一个更具体的措辞，猜不动就落到通用兜底
+                // ——永远不把服务端的英文诊断散文或裸 code 甩给玩家，也不能让玩家
+                // 看到一个空字符串。网络层失败（status 0）和任何未识别的 5xx 都落在
+                // 这里，不在已知 code 表里的每一条也是。
+                if (e.status === 0 || e.status >= 500)
+                    return fail(m.serviceUnreachable());
+                if (e.status === 402)
+                    return fail(m.insufficientBalance());
+                if (e.status === 404)
+                    return roundNotFound();
+                if (e.status === 409)
+                    return activeRoundExists();
+                return fail(m.genericFailure());
         }
-        return fail('操作没有成功，请稍后再试。');
     }
     /** Resolve the bearer token, guiding to consent when absent, then run `body` catching every failure. */
     async function withToken(body) {
         const token = await identity.current();
         if (!token)
-            return fail(AGREE_HINT);
+            return fail(m.agreeHint());
         try {
             return await body(token);
         }
@@ -100,28 +183,36 @@ export function registerCommands(ctx, deps) {
     async function showStatus() {
         const token = await identity.current();
         if (!token)
-            return ok(CONSENT_TEXT);
+            return ok(m.consentText());
         try {
             const round = await api.activeRound(token);
             if (round) {
                 noteRound(round);
-                return ok(renderRound(round));
+                return ok(renderRound(round, m));
             }
             activeRoundId = undefined;
             const me = await api.me(token);
-            return ok(renderMe(me));
+            return ok(renderMe(me, m));
         }
         catch (e) {
             return mapError(e, token);
         }
     }
-    async function doAgree() {
+    /**
+     * 同意须知。**必须先把须知显示出来，再由玩家显式确认。**
+     *
+     * 原先一步就同意，须知全文只在不带参数的 /blackjack 里显示，没有任何东西
+     * 强制这个顺序——直接打 `/blackjack agree` 就在没见过条款的情况下同意了。
+     * 这份须知（第三方声明、不可提现、不可转让、赛季有效期）是整个合规定位的
+     * 载体，未读即同意等于让它失去意义。改成两步，与 `reset confirm` 同一个模式。
+     */
+    async function doAgree(confirmArg) {
+        if (confirmArg !== 'confirm') {
+            return ok(m.consentText());
+        }
         try {
             await identity.accept();
-            return ok([
-                '已确认须知，欢迎上桌。',
-                '/blackjack deal 开始今天的免费手，或 /blackjack deal <注额> 用余额加注。',
-            ].join('\n'));
+            return ok(m.agreeWelcome());
         }
         catch (e) {
             return mapError(e);
@@ -137,10 +228,10 @@ export function registerCommands(ctx, deps) {
                 return { mode: 'raise', betChips: bet };
             })();
         if (!body)
-            return fail('注额必须是正整数。');
+            return fail(m.invalidBetAmount());
         const round = await api.startRound(token, body);
         noteRound(round);
-        return ok(renderRound(round));
+        return ok(renderRound(round, m));
     }
     /**
      * Exchange has TWO paths, and which one applies is a property of the player,
@@ -165,45 +256,39 @@ export function registerCommands(ctx, deps) {
             const minutes = Math.max(1, Math.round(pairing.expiresInSeconds / 60));
             // 只给链接，不单独列配对码：链接里已经含它了，而单独列出会让人以为要
             // 手动填到某处（运营者第一次用就这么理解了，连开了三次都没敢往下走）。
-            return ok([
-                '首次兑换要先绑定 GitHub，只需做这一次。',
-                '',
-                '请在浏览器里打开这个链接：',
-                pairing.url,
-                '',
-                '打开后点「用 GitHub 继续」授权，然后在同一个页面填写要兑换的数量并提交。',
-                `链接约 ${minutes} 分钟内有效；过期了就再执行一次 /blackjack exchange 拿一个新的。`,
-                '绑定完成后，以后直接用 /blackjack exchange <数量> 兑换，不用再开浏览器。',
-            ].join('\n'));
+            return ok(m.pairingInstructions(pairing.url, minutes));
         }
         if (amountArg === undefined) {
-            return fail([
-                `已绑定 GitHub 账号：${me.githubLogin}`,
-                `当前余额：${n(me.chips)} CHIP　兑换门槛：${n(me.exchangeThresholdChips)} CHIP`,
-                '请用 /blackjack exchange <数量> 指定要兑换的 CHIP 数量。',
-            ].join('\n'));
+            return fail(m.exchangeAmountPrompt(me.githubLogin, me.chips, me.exchangeThresholdChips));
         }
         const chips = Number(amountArg);
         if (!Number.isInteger(chips) || chips <= 0)
-            return fail('兑换数量必须是正整数。');
+            return fail(m.invalidExchangeAmount());
         const result = await api.exchange(token, chips);
         // 必须讲清楚这份额度什么时候会被用上：运营者兑换完就问"我该怎么用"——
-        // 因为兑换成功的提示从没说过触发条件，玩家以为兑换完就能直接花。
-        return ok([
-            `已兑换 ${n(result.chips)} CHIP。`,
-            `累计已兑换额度：${n(result.exchangedChips)} CHIP`,
-            '这份额度会在你自己的模型额度耗尽时，自动接管那一次失败的请求；平时不会动用，你不需要做任何事。',
-            result.note,
-        ].join('\n'));
+        // 因为兑换成功的提示从没说过触发条件，玩家以为兑换完就能直接花。这句话现在
+        // 由插件自己按 result.quota 里的结构化事实拼词（m.exchangedQuotaNote），
+        // 不再是服务端返回的现成散文（Task 6）。result.quota 是可选的：插件发到
+        // npm 后可能连到一个比这个字段更早的服务端（还在吐老的 note 字段），这种
+        // 情况下跳过这一行，而不是在 result.quota.inactiveRecycleDays 上崩溃。
+        const lines = [m.exchangeSuccess(result.chips, result.exchangedChips)];
+        // quota 的两个字段都要真的用上。`expiresAtSeasonEnd` 以前是"发了但没人读"
+        // ——服务端一路把它传到这里，插件却无条件说「它不会因赛季结束而清零」。
+        // 服务端哪天真改成赛季末回收、老实发 true，这句话就成了又一次假承诺
+        // （和当年的「有效期至本赛季末」同一个形状，方向反过来）。交给 Messages
+        // 按事实挑措辞，插件这边不做措辞判断。
+        if (result.quota)
+            lines.push(m.exchangedQuotaNote(result.quota.inactiveRecycleDays, result.quota.expiresAtSeasonEnd));
+        return ok(lines.join('\n'));
     }
     async function doReset(confirmArg) {
         if (confirmArg !== 'confirm') {
-            return ok('这会清除本机保存的牌桌凭证（不影响服务端记录，重新配对即可找回）。确认请执行 /blackjack reset confirm');
+            return ok(m.resetConfirmPrompt());
         }
         try {
             await identity.clear();
             activeRoundId = undefined;
-            return ok('已清除本机凭证，可用 /blackjack agree 重新开始。');
+            return ok(m.resetDone());
         }
         catch (e) {
             return mapError(e);
@@ -222,13 +307,13 @@ export function registerCommands(ctx, deps) {
         try {
             token = await identity.current();
             if (!token)
-                return fail(AGREE_HINT);
+                return fail(m.agreeHint());
             const id = await currentRoundId(token);
             if (!id)
-                return fail(NO_ROUND_HINT);
+                return fail(m.noRoundHint());
             const result = await api.act(token, id, action);
             noteRound(result);
-            return ok(renderRound(result));
+            return ok(renderRound(result, m));
         }
         catch (e) {
             return mapError(e, token);
@@ -240,11 +325,11 @@ export function registerCommands(ctx, deps) {
             const sub = parts[0] ?? '';
             switch (sub) {
                 case '': return await showStatus();
-                case 'agree': return await doAgree();
+                case 'agree': return await doAgree(parts[1]);
                 case 'deal': return await withToken((token) => doDeal(token, parts[1]));
                 case 'exchange': return await withToken((token) => doExchange(token, parts[1]));
                 case 'reset': return await doReset(parts[1]);
-                default: return fail(`未知子命令「${sub}」。可用：${USAGE}`);
+                default: return fail(m.unknownSubcommand(sub, m.commandUsage()));
             }
         }
         catch (e) {
@@ -256,14 +341,14 @@ export function registerCommands(ctx, deps) {
     }
     ctx.commands.register({
         name: 'blackjack',
-        description: '打开 21 点牌桌：查看状态、开局、兑换额度、重置本机凭证',
-        input: { hint: USAGE },
+        description: m.blackjackCommandDescription(),
+        input: { hint: m.commandUsage() },
         handler: blackjackHandler,
     });
-    for (const { name, action, description } of ACTIONS) {
+    for (const { name, action } of ACTIONS) {
         ctx.commands.register({
             name,
-            description,
+            description: m.actionDescriptions[action],
             handler: () => doAction(action),
         });
     }

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import Schema from '@deepseek-ai/schemastery';
+import type { LocaleId } from './i18n/index.js';
 /** Cordis plugin name, also used in loader diagnostics and log lines. */
 export declare const PLUGIN_NAME = "dsh-blackjack";
 /**
@@ -9,5 +10,6 @@ export declare const TOKEN_REF = "DSH_BLACKJACK_TOKEN";
 export interface ConfigType {
     serverUrl: string;
     enabled: boolean;
+    locale: LocaleId;
 }
 export declare const Config: Schema<Partial<ConfigType>, ConfigType>;

package/dist/config.js

@@ -13,4 +13,9 @@ export const Config = Schema.object({
         .default('https://server-production-493c.up.railway.app')
         .description('牌局服务端地址；自建奖池时改成你自己的部署地址'),
     enabled: Schema.boolean().default(true).description('停用后不注册命令也不挂路由'),
+    // 命令回复的语言。**图形牌桌不看这一项**——它自动跟随 dsh 的语言设置。
+    // Node 侧读不到宿主的 locale（实测确认，见 spec），所以纯终端 profile 需要
+    // 在这里设一次。
+    locale: Schema.union(['en', 'zh']).default('en')
+        .description('命令回复的语言；图形牌桌自动跟随 dsh 的设置'),
 });

package/dist/copy.d.ts

@@ -1,8 +1,22 @@
 import type { RoundView } from './api.js';
+import type { Messages } from './i18n/index.js';
+/**
+ * 牌局文案的单一来源。命令面（render.ts）与图形牌桌（client/Table.tsx）共用
+ * 这里的逻辑，否则两边会各说各话——而运营者第一次自己上手时，正是因为
+ * 界面没讲清楚"免费手"和"加注"的区别而看不懂在玩什么。
+ *
+ * 措辞本身来自 `m: Messages`（见 src/i18n），这里只负责"该说哪句"的判断逻辑：
+ * 免费/加注两种模式分支、平局要先于赢判断（加注局平局也会退回本金，
+ * payoutChips > 0）。
+ *
+ * 红线（见 render.ts 的 BANNED，及 i18n/messages.ts 的 BANNED_EN）：单位一律
+ * CHIP，不用「筹码」；不出现赌博词汇。
+ * @module dsh-blackjack/copy
+ */
 /** 这一局的性质与代价。进行中时显示，让玩家随时知道自己在打哪种局。 */
-export declare function stakeLine(round: RoundView): string;
+export declare function stakeLine(round: RoundView, m: Messages): string;
 /**
  * 结算结果。分模式措辞——原先两种局共用一句「本手没有收获，明天再来」，
  * 而加注局只要有余额马上就能再来，那句话是错的。
  */
-export declare function outcomeLine(round: RoundView): string;
+export declare function outcomeLine(round: RoundView, m: Messages): string;

package/dist/copy.js

@@ -1,37 +1,32 @@
 /**
  * 牌局文案的单一来源。命令面（render.ts）与图形牌桌（client/Table.tsx）共用
- * 这里的字符串，否则两边会各说各话——而运营者第一次自己上手时，正是因为
+ * 这里的逻辑，否则两边会各说各话——而运营者第一次自己上手时，正是因为
  * 界面没讲清楚"免费手"和"加注"的区别而看不懂在玩什么。
  *
- * 红线（见 render.ts 的 BANNED）：单位一律 CHIP，不用「筹码」；不出现赌博词汇。
+ * 措辞本身来自 `m: Messages`（见 src/i18n），这里只负责"该说哪句"的判断逻辑：
+ * 免费/加注两种模式分支、平局要先于赢判断（加注局平局也会退回本金，
+ * payoutChips > 0）。
+ *
+ * 红线（见 render.ts 的 BANNED，及 i18n/messages.ts 的 BANNED_EN）：单位一律
+ * CHIP，不用「筹码」；不出现赌博词汇。
  * @module dsh-blackjack/copy
  */
-const n = (v) => v.toLocaleString('en-US');
 /** 这一局的性质与代价。进行中时显示，让玩家随时知道自己在打哪种局。 */
-export function stakeLine(round) {
-    return round.mode === 'free'
-        ? `这是免费的一局：赢了拿 ${n(round.betChips)} CHIP，输了不损失任何东西。`
-        : `本局已加注 ${n(round.betChips)} CHIP，从你的余额里出。`;
+export function stakeLine(round, m) {
+    return round.mode === 'free' ? m.freeStakeLine(round.betChips) : m.raiseStakeLine(round.betChips);
 }
 /**
  * 结算结果。分模式措辞——原先两种局共用一句「本手没有收获，明天再来」，
  * 而加注局只要有余额马上就能再来，那句话是错的。
  */
-export function outcomeLine(round) {
+export function outcomeLine(round, m) {
     const payout = round.payoutChips ?? 0;
     const bet = round.betChips;
     // 加注局平局会原样退回本金，payout > 0 —— 先判平局，否则会被说成赢了。
     if (round.hands.length > 0 && round.hands.every((h) => h.outcome === 'push')) {
-        return round.mode === 'free'
-            ? '平局。这手不损失也不获得。'
-            : `平局。加注的 ${n(bet)} CHIP 原样退回。`;
-    }
-    if (payout > 0) {
-        return round.mode === 'free'
-            ? `赢了，拿到 ${n(payout)} CHIP。`
-            : `赢了，拿回 ${n(payout)} CHIP（加注 ${n(bet)}）。`;
+        return round.mode === 'free' ? m.freePush() : m.raisePush(bet);
     }
-    return round.mode === 'free'
-        ? '这手输了。免费手不损失任何东西。'
-        : `这手输了，加注的 ${n(bet)} CHIP 收不回。`;
+    if (payout > 0)
+        return round.mode === 'free' ? m.freeWin(payout) : m.raiseWin(payout, bet);
+    return round.mode === 'free' ? m.freeLose() : m.raiseLose(bet);
 }

package/dist/i18n/en.d.ts

@@ -0,0 +1,110 @@
+export declare const en: {
+    freeStakeLine: (bet: number) => string;
+    raiseStakeLine: (bet: number) => string;
+    freeWin: (payout: number) => string;
+    freeLose: () => string;
+    freePush: () => string;
+    raiseWin: (payout: number, bet: number) => string;
+    raiseLose: (bet: number) => string;
+    raisePush: (bet: number) => string;
+    handLabel: () => string;
+    splitHandLabel: (handIndex: number) => string;
+    dealerLabel: () => string;
+    totalInParens: (total: number, isSoft: boolean) => string;
+    doubled: () => string;
+    actionsPrefix: () => string;
+    actionLabels: {
+        hit: string;
+        stand: string;
+        double: string;
+        split: string;
+        insure: string;
+        decline: string;
+    };
+    actionsSeparator: () => string;
+    balanceLine: (chips: number, exchangedChips: number) => string;
+    freeHandsLine: (freeHandsRemaining: number, seasonId: string) => string;
+    thresholdLine: (exchangeThresholdChips: number) => string;
+    pointsLine: (points: number) => string;
+    poolEmptyNotice: () => string;
+    pointsGrantedNotice: (points: number) => string;
+    chipValidityNotice: () => string;
+    consentText: () => string;
+    agreeHint: () => string;
+    noRoundHint: () => string;
+    commandUsage: () => string;
+    actionDescriptions: {
+        hit: string;
+        stand: string;
+        double: string;
+        split: string;
+        insure: string;
+        decline: string;
+    };
+    blackjackCommandDescription: () => string;
+    genericFailure: () => string;
+    serviceUnreachable: () => string;
+    dailyFreeHandsExhausted: () => string;
+    belowExchangeThreshold: (thresholdChips: number) => string;
+    insufficientBalance: () => string;
+    roundAlreadyInProgress: () => string;
+    githubBindingRequired: () => string;
+    seasonCapReached: (capChips: number, exchangedThisSeasonChips: number) => string;
+    exchangeUnavailable: () => string;
+    betAmountAboveLimit: (maxChips: number) => string;
+    illegalAction: () => string;
+    registerRateLimited: () => string;
+    unknownPlayerToken: () => string;
+    agreeWelcome: () => string;
+    invalidBetAmount: () => string;
+    pairingInstructions: (url: string, minutes: number) => string;
+    exchangeAmountPrompt: (githubLogin: string, chips: number, exchangeThresholdChips: number) => string;
+    invalidExchangeAmount: () => string;
+    exchangeSuccess: (chips: number, exchangedChips: number) => string;
+    exchangedQuotaNote: (inactiveRecycleDays: number, expiresAtSeasonEnd: boolean) => string;
+    resetConfirmPrompt: () => string;
+    resetDone: () => string;
+    unknownSubcommand: (sub: string, usage: string) => string;
+    poolSwitchNotice: () => string;
+    noCredentialHint: () => string;
+    hiddenCardLabel: () => string;
+    tableHandLabel: () => string;
+    tableSplitHandLabel: (handIndex: number) => string;
+    tableDealerLabel: () => string;
+    tableActionLabels: {
+        hit: string;
+        stand: string;
+        double: string;
+        split: string;
+        insure: string;
+        decline: string;
+    };
+    tableBalanceHeader: (chips: number, freeHandsRemaining: number) => string;
+    tablePointsSuffix: (points: number) => string;
+    tableExchangedSuffix: (exchangedChips: number) => string;
+    tableExchangeThresholdReached: (exchangeThresholdChips: number) => string;
+    tableExchangeThresholdShort: (shortChips: number, exchangeThresholdChips: number) => string;
+    tableExchangedQuotaNote: (exchangedChips: number) => string;
+    tablePoolEmptyNotice: () => string;
+    actionShortfallHint: (costChips: number) => string;
+    tableCostSuffix: (costChips: number) => string;
+    betAmountMissing: () => string;
+    betAmountExceedsCap: (maxChips: number) => string;
+    betAmountExceedsBalance: () => string;
+    customBetToggle: () => string;
+    customBetSubmit: () => string;
+    customBetRange: (maxChips: number) => string;
+    noActiveRoundNotice: () => string;
+    freeHandsGroupTitle: () => string;
+    freeHandsRemainingToday: (freeHandsRemaining: number) => string;
+    freeHandsExhaustedToday: () => string;
+    freeHandExplainer: (baseChips: number, naturalBlackjackPayoutChips: number) => string;
+    startFreeHandButton: () => string;
+    raiseGroupTitle: () => string;
+    insufficientBalanceSuffix: () => string;
+    raiseExplainer: () => string;
+    rematchFreeLabel: () => string;
+    dealButtonFreeHandsSuffix: (freeHandsRemaining: number) => string;
+    dismissButton: () => string;
+    actionFailedNotice: () => string;
+};