@mesub/node 0.0.0-stage → 0.1.2

package/dist/situations.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunk43Q4PNF7cjs = require('./chunk-43Q4PNF7.cjs');
+
+
+
+
+
+
+exports.ACCESS_LINE = _chunk43Q4PNF7cjs.ACCESS_LINE; exports.CONFIRMATIONS = _chunk43Q4PNF7cjs.CONFIRMATIONS; exports.SITUATIONS = _chunk43Q4PNF7cjs.SITUATIONS; exports.explain = _chunk43Q4PNF7cjs.explain; exports.situationOf = _chunk43Q4PNF7cjs.situationOf;
+//# sourceMappingURL=situations.cjs.map

package/dist/situations.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/node-sdk/node-sdk/dist/situations.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACF,kQAAC","file":"/home/runner/work/node-sdk/node-sdk/dist/situations.cjs"}

package/dist/situations.d.cts

@@ -0,0 +1,607 @@
+import { A as AccessAnswer, j as ServerSubscription } from './subscriptions-B6Lin6i_.cjs';
+
+/**
+ * One sentence per subscription situation, for the subscriber and for the
+ * merchant, and what each of them can do about it: the canonical wording of
+ * 2026-10-05, agreed with the backend. Show these instead of writing your
+ * own: hand-written ones drift, and some are false ("add funds" on a removed
+ * approval, "nothing more is charged" on a stopped subscription).
+ *
+ * Browser-safe: this module imports types only, so `@mesub/node/situations`
+ * loads in a page, a widget or a docs site with nothing of Node.
+ *
+ * Templates carry `{placeholders}`. A `[segment]` holds a placeholder `/v1`
+ * does not always serve: it is shown when every placeholder in it has a
+ * value, and left out otherwise, so the sentence stays true without it.
+ */
+
+/** Who acts. */
+type SituationActor = 'subscriber' | 'merchant';
+/**
+ * What can be done. `add_funds` has no route (the wallet does it).
+ * `transaction` hands a pending checkout a fresh transaction to sign
+ * (`subscriptions.transaction`, Mesub-io/backend#427). `retry` is
+ * the subscriber's "Pay now" with the API key (`subscriptions.retry`,
+ * Mesub-io/backend#354), and the merchant's on the Mesub dashboard; `upgrade`
+ * exists on the dashboard only.
+ */
+type SituationActionId = 'subscribe' | 'transaction' | 'submit' | 'cancel' | 'resume' | 'close' | 'add_funds' | 'retry' | 'upgrade' | 'retrieve' | 'list';
+/** One action of a situation, as the table lists it. */
+interface SituationActionTemplate {
+    readonly by: SituationActor;
+    readonly action: SituationActionId;
+    /** The method of `@mesub/node`, when there is one: `subscriptions.cancel`, … */
+    readonly sdk?: string;
+    /** The API route behind it. */
+    readonly route?: string;
+    /** On the Mesub dashboard only: an API key cannot call it. */
+    readonly dashboard?: true;
+    /** The sentence to show before the subscriber signs it, a key of `CONFIRMATIONS`. */
+    readonly confirm?: ConfirmationKey;
+    /** Only while the date in this field of the subscription is ahead. */
+    readonly until?: 'access_until' | 'retry_deadline';
+    /**
+     * Only while the subscription is `closable` (Mesub-io/backend#402): left
+     * out where Mesub says `closable: false`, its `closable_from` in the
+     * sentence when a date is known.
+     */
+    readonly when?: 'closable';
+}
+/**
+ * A sentence, or one per tier where the canonical sentence names both:
+ * `retries` for Dev and Business (Mesub retries on its own), `free` for Free
+ * (hand retries until `retry_deadline`).
+ */
+type SituationText = string | {
+    readonly retries: string;
+    readonly free: string;
+};
+interface Situation {
+    readonly subscriber: SituationText;
+    readonly merchant: SituationText;
+    readonly actions: readonly SituationActionTemplate[];
+}
+/**
+ * The canonical table, by situation key. The renewal checks
+ * (`active_renewal_*`) are left out: Mesub serves them on its dashboard
+ * only, never on `/v1`.
+ */
+declare const SITUATIONS: {
+    readonly none: {
+        readonly subscriber: "You are not subscribed to {plan_name}.";
+        readonly merchant: "This customer has no subscription to {plan_name}.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }];
+    };
+    readonly active: {
+        readonly subscriber: "Active. Your next payment of {amount} is on {next_charge_at}.";
+        readonly merchant: "Active and paid up. Next payment of {amount} on {next_charge_at}.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_paid";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly active_last_period: {
+        readonly subscriber: "Active until {access_until}: {plan_name} is ending, and no further payment will be taken.";
+        readonly merchant: "Active and paid up, in its last period: the plan is ending, so no further payment is taken. Access ends on {access_until}.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_paid";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly active_unbilled: {
+        readonly subscriber: "Active until {access_until}. No further payment is scheduled.";
+        readonly merchant: "Not billed: this subscription's terms were never signed through Mesub, so Mesub never takes a payment for it. Access ends on {access_until}.";
+        readonly actions: readonly [];
+    };
+    readonly unpaid_last_period: {
+        readonly subscriber: "Your payment of {amount} is late, and Mesub will not try again on its own: {plan_name} is ending. You keep access until {access_until}.";
+        readonly merchant: "Payment late, with no retry ahead: the plan ends before the next one. Access continues until {access_until}, and the subscription ends with the plan.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "retry";
+            readonly sdk: "subscriptions.retry";
+            readonly route: "POST /v1/subscriptions/:id/retry";
+        }, {
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "merchant";
+            readonly action: "retry";
+            readonly route: "POST /merchant/subscriptions/:id/retry";
+            readonly dashboard: true;
+        }];
+    };
+    readonly unpaid_insufficient_balance_retries: {
+        readonly subscriber: "Your payment of {amount} is late because your wallet held too little, and nothing was taken. Add {amount} to your wallet, then pay it now, with nothing to sign; otherwise Mesub tries again on {next_retry_at}. Your subscription stops if no payment goes through by {access_until}.";
+        readonly merchant: "Payment late: the wallet was short. Retry[ {next_retry_number} of {retries_allowed}] on {next_retry_at}, or sooner by hand, yours or the subscriber's. Access continues until {access_until}; the subscription stops then if every retry fails.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "add_funds";
+        }, {
+            readonly by: "subscriber";
+            readonly action: "retry";
+            readonly sdk: "subscriptions.retry";
+            readonly route: "POST /v1/subscriptions/:id/retry";
+        }, {
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "merchant";
+            readonly action: "retry";
+            readonly route: "POST /merchant/subscriptions/:id/retry";
+            readonly dashboard: true;
+        }];
+    };
+    readonly unpaid_insufficient_balance_free: {
+        readonly subscriber: "Your payment of {amount} is late because your wallet held too little, so your access is off. Add {amount} to your wallet, then pay it now, with nothing to sign, before {retry_deadline}; if no payment goes through by then, the subscription stops.";
+        readonly merchant: "Payment late: the wallet was short. On Free, Mesub does not retry on its own: you or the subscriber can retry by hand, up to 3 times between you, 10 minutes apart, until {retry_deadline}. Access is off meanwhile, and it stops after that.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "add_funds";
+        }, {
+            readonly until: "retry_deadline";
+            readonly by: "subscriber";
+            readonly action: "retry";
+            readonly sdk: "subscriptions.retry";
+            readonly route: "POST /v1/subscriptions/:id/retry";
+        }, {
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly until: "retry_deadline";
+            readonly by: "merchant";
+            readonly action: "retry";
+            readonly route: "POST /merchant/subscriptions/:id/retry";
+            readonly dashboard: true;
+        }];
+    };
+    readonly unpaid_approval_revoked: {
+        readonly subscriber: "Mesub could not take your payment of {amount}: your wallet no longer approves it (the approval was removed, or replaced by another app's). Adding funds will not fix this, and removing the approval did not cancel the subscription: Cancel it if you want to stop.";
+        readonly merchant: {
+            readonly retries: "Payment late: the subscriber's wallet no longer approves Mesub (removed in the wallet, or replaced by another app's approval). Every retry fails until it is back, and no Mesub route restores it today. It stops on {access_until}.";
+            readonly free: "Payment late: the subscriber's wallet no longer approves Mesub (removed in the wallet, or replaced by another app's approval). Every retry fails until it is back, and no Mesub route restores it today. It stops at {retry_deadline}.";
+        };
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly unpaid_authority_closed: {
+        readonly subscriber: "Mesub can no longer take payments for this subscription: your wallet's approval for {token} was closed for good, so adding funds will not help. Cancel it, then close it once its period ends if you want to subscribe again.";
+        readonly merchant: {
+            readonly retries: "Payment late, for good: the subscriber's subscription authority for {token} was closed (or re-created), so no retry can succeed. It stops on {access_until}, unless the subscriber cancels first.";
+            readonly free: "Payment late, for good: the subscriber's subscription authority for {token} was closed (or re-created), so no retry can succeed. It stops at {retry_deadline}, unless the subscriber cancels first.";
+        };
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly unpaid_unknown: {
+        readonly subscriber: "Your wallet refused the payment of {amount}, so nothing was taken. Check that it still holds {amount} in {token} and can send it, then pay it now, or Cancel to stop.";
+        readonly merchant: "Payment late: the network refused the payment for a reason Mesub does not name (for example a frozen {token} account). See the last attempt's reason.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "retry";
+            readonly sdk: "subscriptions.retry";
+            readonly route: "POST /v1/subscriptions/:id/retry";
+        }, {
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "merchant";
+            readonly action: "retry";
+            readonly route: "POST /merchant/subscriptions/:id/retry";
+            readonly dashboard: true;
+        }];
+    };
+    readonly blocked_mesub: {
+        readonly subscriber: "Mesub cannot take your payments for {plan_name} for now, because of a problem on Mesub's side: there is nothing for you to do or sign, and Mesub keeps trying.[ You keep access until {access_until} if no payment goes through by then.] Access comes back on its own with the first payment that goes through.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by a problem on Mesub's side: nothing to fix on yours, and none of it is the subscriber's doing. Mesub keeps trying.[ Access ends on {access_until} if nothing is collected by then.] Access comes back with the first payment that goes through, with nothing for the subscriber to sign.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly blocked_puller_not_allowed: {
+        readonly subscriber: "Mesub cannot take your payments for {plan_name} for now, because of how the plan is set up, not because of anything you did: there is nothing for you to do or sign, and Mesub keeps trying.[ You keep access until {access_until} if no payment goes through by then.] Access comes back on its own with the first payment that goes through.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by your plan's setup: Mesub's puller was taken off the plan on chain, so Mesub can take no payment for it. Add Mesub back to the plan's pullers, with the wallet that owns the plan; Mesub keeps trying.[ Access ends on {access_until} if nothing is collected by then.] Access comes back with the first payment that goes through, with nothing for the subscriber to sign.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly blocked_receiver_not_allowed: {
+        readonly subscriber: "Mesub cannot take your payments for {plan_name} for now, because of how the plan is set up, not because of anything you did: there is nothing for you to do or sign, and Mesub keeps trying.[ You keep access until {access_until} if no payment goes through by then.] Access comes back on its own with the first payment that goes through.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by your plan's setup: the wallet that receives its payments is not among the plan's destinations on chain. Choose one that is; Mesub keeps trying.[ Access ends on {access_until} if nothing is collected by then.] Access comes back with the first payment that goes through, with nothing for the subscriber to sign.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly blocked_receiver_account_missing: {
+        readonly subscriber: "Mesub cannot take your payments for {plan_name} for now, because of how the plan is set up, not because of anything you did: there is nothing for you to do or sign, and Mesub keeps trying.[ You keep access until {access_until} if no payment goes through by then.] Access comes back on its own with the first payment that goes through.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by your plan's setup: the wallet that receives its payments has no token account for the plan's token, and nobody else on the plan can be paid. Open that account; Mesub keeps trying.[ Access ends on {access_until} if nothing is collected by then.] Access comes back with the first payment that goes through, with nothing for the subscriber to sign.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly blocked_receiver_account_frozen: {
+        readonly subscriber: "Mesub cannot take your payments for {plan_name} for now, because of how the plan is set up, not because of anything you did: there is nothing for you to do or sign, and Mesub keeps trying.[ You keep access until {access_until} if no payment goes through by then.] Access comes back on its own with the first payment that goes through.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by your plan's setup: the token account of the wallet that receives its payments is frozen, so it cannot take payments. Choose another receiving wallet, or ask the token's issuer to unfreeze that account; Mesub keeps trying.[ Access ends on {access_until} if nothing is collected by then.] Access comes back with the first payment that goes through, with nothing for the subscriber to sign.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly blocked_mint_gone: {
+        readonly subscriber: "Mesub can no longer take your payments for {plan_name}: the token it is paid in no longer exists. This is not because of anything you did, and there is nothing for you to do or sign.[ You keep access until {access_until}.] No payment can go through on this plan again, so once access ends it does not come back.";
+        readonly merchant: "Payments blocked[ since {blocked_since}] by your plan's setup: the plan's token no longer exists on chain, so nothing can be collected on it. Create a new plan with another token.[ Access ends on {access_until}.] No payment can go through on this plan again, so once access ends it does not come back.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }];
+    };
+    readonly cancelled_with_access: {
+        readonly subscriber: "Cancelled: nothing more will be taken, and you keep access until {access_until}. Resume before then to keep it going.";
+        readonly merchant: "Cancelled[ on {cancelled_at}]: access runs until {access_until}, and nothing more will be taken.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_resume";
+            readonly by: "subscriber";
+            readonly action: "resume";
+            readonly sdk: "subscriptions.resume";
+            readonly route: "POST /v1/subscriptions/:id/resume";
+            readonly until: "access_until";
+        }];
+    };
+    readonly cancelled_no_access: {
+        readonly subscriber: "Cancelled. Your last payment was missed, so you have no access, and Mesub will not collect it; you can close the subscription[ from {closable_from}] to get your deposit back.";
+        readonly merchant: "Cancelled while behind[ on {cancelled_at}]: no access, and Mesub will not collect the missed payment. The subscriber can close it[ from {closable_from}], and must do so before subscribing again.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly confirm: "confirm_close";
+            readonly when: "closable";
+        }];
+    };
+    readonly cancelled_ended: {
+        readonly subscriber: "This subscription has ended. Close it to get your deposit back; you need to close it before subscribing to {plan_name} again.";
+        readonly merchant: "Ended by the subscriber's cancellation. Its subscription account stays open until the subscriber closes it, which they must do before subscribing again.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly confirm: "confirm_close";
+            readonly when: "closable";
+        }];
+    };
+    readonly stopped: {
+        readonly subscriber: "Your subscription stopped after missed payments, and your access has ended; Mesub will not take payments for it again. Its subscription account stays open on your wallet, so the plan's owner could still charge it: Cancel if you are not coming back.";
+        readonly merchant: "Stopped[: {stop_cause}]. Mesub takes nothing more and access is off. The subscription account stays open on chain, and you, as the plan's owner, could still pull from it, until the subscriber cancels and closes it. The subscriber can come back over it.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_behind";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }, {
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly confirm: "confirm_close";
+            readonly when: "closable";
+        }];
+    };
+    readonly stopped_authority_closed: {
+        readonly subscriber: "Your wallet's approval for {token} was closed for good, so no payment can go through for this subscription any more: it has stopped, your access is over, and it cannot be restarted. Close it to get your deposit back; you can then subscribe to {plan_name} again.";
+        readonly merchant: "Stopped for good: the subscriber's wallet approval for {token} was closed, so nobody can take payments from this subscription any more, you as the plan's owner included, and the subscriber cannot come back over it. They can close it at once to get their deposit back.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly confirm: "confirm_close";
+            readonly when: "closable";
+        }];
+    };
+    readonly paused: {
+        readonly subscriber: "Paused by {merchant_name}: nothing will be taken, and you keep access until {access_until}.";
+        readonly merchant: "Paused: your project is over its tier's subscriber limit, so Mesub takes nothing from this subscriber. Access runs to the end of the paid period ({access_until}). Move back up a tier to restart payments.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_cancel_paid";
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "merchant";
+            readonly action: "upgrade";
+            readonly route: "POST /projects/:id/upgrade";
+            readonly dashboard: true;
+        }];
+    };
+    readonly paused_access_over: {
+        readonly subscriber: "Paused by {merchant_name}: nothing is taken, and your access has ended. If {merchant_name} unpauses it, a payment is due at once; Cancel to stop for good.";
+        readonly merchant: "Paused over your tier limit, and its paid period is over, so access is off. Moving back up a tier makes a payment due at once.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "cancel";
+            readonly sdk: "subscriptions.cancel";
+            readonly route: "POST /v1/subscriptions/:id/cancel";
+        }, {
+            readonly by: "merchant";
+            readonly action: "upgrade";
+            readonly route: "POST /projects/:id/upgrade";
+            readonly dashboard: true;
+        }];
+    };
+    readonly paused_cancelled: {
+        readonly subscriber: "Cancelled: nothing more will be taken, and you keep access until {access_until}. You can resume before then, but it stays paused, with no payment, until {merchant_name} unpauses it.";
+        readonly merchant: "Cancelled while paused over your tier limit; access until {access_until}.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_resume_paused";
+            readonly by: "subscriber";
+            readonly action: "resume";
+            readonly sdk: "subscriptions.resume";
+            readonly route: "POST /v1/subscriptions/:id/resume";
+            readonly until: "access_until";
+        }];
+    };
+    readonly ended_closed: {
+        readonly subscriber: "You closed this subscription, and its deposit is back in your wallet. You can subscribe to {plan_name} again at any time.";
+        readonly merchant: "Ended: the subscriber closed it and got the deposit back. They can subscribe again.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }];
+    };
+    readonly ended_authority_closed: {
+        readonly subscriber: "This subscription's account was closed outside Mesub, so it has ended and nothing more can be taken. You can subscribe to {plan_name} again.";
+        readonly merchant: "Ended: its subscription account was found closed on chain, without Mesub. The subscriber can subscribe again.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }];
+    };
+    readonly ended_plan_removed: {
+        readonly subscriber: "{merchant_name} removed {plan_name}, so your subscription has ended and nothing more will be taken.";
+        readonly merchant: "Ended: the plan account was deleted. The subscriber's subscription account may still hold their deposit, which they get back by closing it.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_close_over";
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly when: "closable";
+        }];
+    };
+    readonly ended_plan_replaced: {
+        readonly subscriber: "{merchant_name} replaced {plan_name} with another plan, so this subscription has ended and nothing more will be taken.";
+        readonly merchant: "Ended: another plan now stands at this plan's address, and this subscription was never signed for it.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_close_over";
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly when: "closable";
+        }];
+    };
+    readonly ended_plan_ended: {
+        readonly subscriber: "{plan_name} reached its end date[ ({plan_ends_at})], so your subscription has ended and nothing more will be taken.";
+        readonly merchant: "Ended: the plan passed its end date.";
+        readonly actions: readonly [{
+            readonly confirm: "confirm_close_over";
+            readonly by: "subscriber";
+            readonly action: "close";
+            readonly sdk: "subscriptions.close";
+            readonly route: "POST /v1/subscriptions/:id/close";
+            readonly when: "closable";
+        }];
+    };
+    readonly ended_unknown: {
+        readonly subscriber: "This subscription has ended, and nothing more will be taken.";
+        readonly merchant: "Ended (before Mesub recorded reasons).";
+        readonly actions: readonly [];
+    };
+    readonly pending: {
+        readonly subscriber: "Not signed yet. Approve it in your wallet to pay the first {amount} and start the subscription.";
+        readonly merchant: "Checkout started, not signed yet: nothing is on chain and nothing was charged.";
+        readonly actions: readonly [{
+            readonly by: "merchant";
+            readonly action: "transaction";
+            readonly sdk: "subscriptions.transaction";
+            readonly route: "POST /v1/subscriptions/:id/transaction";
+        }, {
+            readonly by: "merchant";
+            readonly action: "submit";
+            readonly sdk: "subscriptions.submit";
+            readonly route: "POST /v1/subscriptions/:id/submit";
+        }];
+    };
+    readonly expired: {
+        readonly subscriber: "This checkout was never signed, so nothing was charged. Subscribe again to start.";
+        readonly merchant: "Checkout expired unsigned. Nothing on chain.";
+        readonly actions: readonly [{
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }];
+    };
+    readonly failed: {
+        readonly subscriber: "This subscription did not start: what reached the network was not the transaction prepared for it. If money left your wallet for it, contact {merchant_name}.";
+        readonly merchant: "Failed: what landed on chain is not what Mesub built (see the submit reason). Check the wallet's transactions before creating a new one.";
+        readonly actions: readonly [{
+            readonly by: "merchant";
+            readonly action: "retrieve";
+            readonly sdk: "subscriptions.retrieve";
+            readonly route: "GET /v1/subscriptions/:id";
+        }, {
+            readonly by: "subscriber";
+            readonly action: "subscribe";
+            readonly sdk: "subscriptions.create";
+            readonly route: "POST /v1/subscriptions";
+        }];
+    };
+    readonly superseded: {
+        readonly subscriber: "Replaced by your newer subscription to {plan_name}.";
+        readonly merchant: "An earlier subscription of this wallet, replaced when it subscribed again[ on {replaced_at}]. Read the current one.";
+        readonly actions: readonly [{
+            readonly by: "merchant";
+            readonly action: "list";
+            readonly sdk: "subscriptions.list";
+            readonly route: "GET /v1/subscriptions";
+        }];
+    };
+};
+/** The sentences to show before the subscriber signs an action. */
+declare const CONFIRMATIONS: {
+    readonly confirm_cancel_paid: "Cancel {plan_name}? Nothing more will be taken, and you keep access until {access_until}.";
+    readonly confirm_cancel_behind: "Cancel {plan_name}? Your access ends now and Mesub will not collect the missed payment; you can close it once the current period ends.";
+    readonly confirm_resume: "Resume {plan_name}? Nothing is taken now; your next payment of {amount} is on {access_until}.";
+    readonly confirm_resume_paused: "Resume {plan_name}? Nothing is taken now, and nothing will be until {merchant_name} unpauses it.";
+    readonly confirm_close: "Close {plan_name}? This deletes its subscription account and returns its deposit to your wallet; you can then subscribe again.";
+    readonly confirm_close_over: "Close {plan_name}? This deletes its subscription account and returns its deposit to your wallet.";
+};
+/** Shown beside every sentence, which therefore need not repeat it. */
+declare const ACCESS_LINE: {
+    readonly granted: "Access until {access_until}";
+    readonly denied: "No access";
+};
+type ConfirmationKey = keyof typeof CONFIRMATIONS;
+/**
+ * A situation of the table, or `unknown`: a status or a reason newer than
+ * this release, whose sentences are the access line, true of any situation.
+ */
+type SituationKey = keyof typeof SITUATIONS | 'unknown';
+interface ExplainOptions {
+    /** What "now" is, for actions open until a date. Defaults to the clock. */
+    now?: Date;
+    /** What neither `/v1/access` nor a subscription carries, as you show it. */
+    names?: {
+        /** `{plan_name}`. Defaults to the plan's slug. */
+        plan?: string;
+        /** `{merchant_name}`: your name, as subscribers know it. */
+        merchant?: string;
+        /** `{amount}`: the plan's amount with its symbol, such as `9.99 USDC`. */
+        amount?: string;
+        /** `{token}`: the plan's token symbol, such as `USDC`. */
+        token?: string;
+    };
+    /**
+     * How a date is written. Defaults to the ISO 8601 string as Mesub serves
+     * it, the same in every locale: pass your own to show local time.
+     */
+    formatDate?: (iso: string) => string;
+}
+interface ExplainedAction {
+    by: SituationActor;
+    action: SituationActionId;
+    sdk?: string;
+    route?: string;
+    dashboard?: true;
+    /** Until when it can be done, as served (ISO 8601). */
+    until?: string;
+    /** The sentence to show before the subscriber signs it, filled. */
+    confirm?: string;
+}
+interface Explanation {
+    key: SituationKey;
+    /** For the subscriber, filled. */
+    subscriber: string;
+    /** For the merchant, filled. */
+    merchant: string;
+    /** "Access until …" or "No access", to show beside either sentence. */
+    access: string;
+    /** What can be done now, by whom. */
+    actions: ExplainedAction[];
+    /**
+     * Placeholders left as `{name}` in a sentence, since nothing gave them a
+     * value: pass them in `options.names`, or check the answer's fields.
+     */
+    missing: string[];
+}
+/** What `explain` reads: an answer of `/v1/access` or a subscription. */
+type Explainable = AccessAnswer | ServerSubscription;
+/**
+ * Which situation an answer is in, in the canonical order: status first,
+ * then paused, then blocked, then the end or late reason. Never throws: a
+ * status or a reason this release does not know is `unknown`.
+ *
+ * A plan's end is read from what it leaves on the answer, which carries no
+ * `ends_at`: access with no charge or retry ahead is the last period, and a
+ * running status without access is the minutes between the end and the job
+ * that ends the row. That one reads as ended already.
+ */
+declare function situationOf(input: Explainable): SituationKey;
+/**
+ * The situation of a subscription, in words: one sentence for the
+ * subscriber, one for the merchant, the access line, and what each can do
+ * now. Takes an answer of `/v1/access` or a subscription as `@mesub/node`
+ * returns them. Never throws.
+ *
+ * ```ts
+ * const { subscriber, access, actions } = explain(answer, {
+ *     names: { plan: 'Pro', merchant: 'Acme', amount: '9.99 USDC', token: 'USDC' },
+ * });
+ * ```
+ */
+declare function explain(input: Explainable, options?: ExplainOptions): Explanation;
+
+export { ACCESS_LINE, CONFIRMATIONS, type ConfirmationKey, type ExplainOptions, type Explainable, type ExplainedAction, type Explanation, SITUATIONS, type Situation, type SituationActionId, type SituationActionTemplate, type SituationActor, type SituationKey, type SituationText, explain, situationOf };