@adminiumjs/i18n 0.3.31 → 0.3.33

package/dist/resources/en-us/studio.d.ts

@@ -109,6 +109,8 @@ declare const _default: {
             readonly on: "on";
             readonly title: "Installed";
             readonly uninstall: "Uninstall";
+            readonly setUpInPayments: "Set up in Payments";
+            readonly paymentsWho: "Someone with the “Set up payments” permission sets this up in Payments.";
         };
         readonly job: {
             readonly body: "Fetching and verifying. Nothing is installed until you say so.";
@@ -2593,6 +2595,11 @@ declare const _default: {
             readonly body: "Whether maps are shown, which servers are asked, and what each of them learns.";
             readonly cta: "Open maps";
         };
+        readonly paymentsCard: {
+            readonly heading: "Payments";
+            readonly body: "Let customers pay what they owe: pay links, a pay page, Stripe and PayPal, and ways to pay by hand.";
+            readonly cta: "Open payments";
+        };
     };
     readonly source: {
         readonly dsn: {
@@ -3570,6 +3577,664 @@ declare const _default: {
             readonly whyEnvOff: "Whoever runs this server switched the routing server off (ADMINIUM_ROUTING_SERVER=off, or all outside calls with ADMINIUM_NETWORK_FEATURES=off), so this switch does nothing.";
         };
     };
+    readonly payments: {
+        readonly service: {
+            readonly connectsStripe: "Connects to Stripe";
+            readonly connectsPaypal: "Connects to PayPal";
+            readonly notLoaded: "This add-on did not load, so its keys cannot be checked.";
+            readonly notLoadedBody: "A payment service loads only from a package Adminium can vouch for: one this build bundles, or one downloaded from the catalogue.";
+            readonly paypalOnce: "PayPal shows once: through this card, not on the Stripe page.";
+            readonly fixAddressFirst: "Fix the address above first: online payments stay off until then.";
+        };
+        readonly reach: {
+            readonly badge: {
+                readonly networkOff: "Works offline";
+                readonly thisComputer: "This computer only";
+                readonly notSet: "Not set";
+                readonly private: "Private network";
+                readonly https: "Needs https";
+                readonly proxy: "Proxy setting";
+                readonly reachable: "Reachable";
+            };
+            readonly problem: {
+                readonly networkOff: "This server is set to work without the internet, so it cannot take online payments.";
+                readonly thisComputer: "This server runs on this computer only. Customers cannot reach it.";
+                readonly notSet: "This server has no public address yet.";
+                readonly private: "Only people on your own network can reach this address.";
+                readonly https: "Pay pages need https. Put this server behind HTTPS first.";
+                readonly proxy: "This server is behind a proxy that hides your customers' addresses. Turn on ADMINIUM_TRUST_PROXY.";
+            };
+            readonly fix: {
+                readonly networkOff: "Set ADMINIUM_NETWORK_FEATURES=on on the server, restart it, then check again.";
+                readonly thisComputer: "Run Adminium on a server with a public https address, then set up payments there.";
+                readonly notSet: "Add the address people use to open this server. It is “Address in email links” in the Senders card.";
+                readonly private: "Give this server a public https address, and set it as “Address in email links” in Senders.";
+                readonly https: "When HTTPS works, change the address in Senders to the https one.";
+                readonly proxy: "Set ADMINIUM_TRUST_PROXY=on on the server, restart it, then check again.";
+            };
+            readonly heading: "Can customers reach this server?";
+            readonly ok: "Customers can reach this server.";
+            readonly address: "This server's public address:";
+            readonly change: "Change";
+            readonly current: "Current value";
+            readonly notSetValue: "not set";
+            readonly still: "Still works here: ways to pay by hand, recording payments, the card-terminal record.";
+            readonly setAddress: "Set the address";
+            readonly checkAgain: "Check again";
+            readonly portTitle: "The address has a port";
+            readonly portBody: "PayPal only sends webhooks to port 443. Use an address without a port.";
+            readonly fixLabel: "Fix:";
+        };
+        readonly step: {
+            readonly paypal: {
+                readonly testKey: "Sandbox app";
+                readonly testWebhook: "Sandbox webhook";
+                readonly liveKey: "Live app";
+            };
+            readonly path: "Choose how to make your Stripe key";
+            readonly testKey: "Test key";
+            readonly testWebhook: "Test webhook";
+            readonly testPayment: "Send a test payment";
+            readonly liveKey: "Live key";
+            readonly liveWebhook: "Live webhook";
+            readonly livePayment: "First live payment arrived";
+        };
+        readonly field: {
+            readonly testKey: "Test key";
+            readonly liveKey: "Live key";
+            readonly signingSecret: "Signing secret";
+            readonly clientId: "Client id";
+            readonly secret: "Secret";
+            readonly webhookId: "Webhook ID";
+            readonly testKeyPrompt: "Paste the key that starts with rk_test_";
+            readonly liveKeyPrompt: "Paste the key that starts with rk_live_";
+            readonly signingSecretPrompt: "Paste the signing secret from the endpoint's page in Stripe. It starts with whsec_.";
+            readonly webhookIdPrompt: "PayPal shows it on the webhook’s page. Adminium needs it to check that a message really came from PayPal.";
+            readonly savedWhen: "Saved {when}";
+            readonly replace: "Replace";
+            readonly save: "Save";
+            readonly checkAndSave: "Check and save";
+            readonly cancel: "Cancel";
+            readonly notSet: "Not set";
+            readonly saving: "Saving…";
+            readonly checking: "Checking with {provider}…";
+        };
+        readonly refused: {
+            readonly secretKey: "This is a secret key (sk_). Stripe asks plugins not to use them. Make a restricted key instead.";
+            readonly publishableKey: "This is a publishable key (pk_). Paste the restricted key (rk_) instead.";
+            readonly webhookSecretInKey: "This is a webhook secret (whsec_). It goes in the webhook card below.";
+            readonly keyInSecret: "This is a key, not a signing secret. Paste the secret that starts with whsec_ from the endpoint’s page.";
+            readonly liveInTest: "This is a live key. This field is for the test key.";
+            readonly testInLive: "This is a test key. This field is for the live key.";
+            readonly notRestricted: "This is not a restricted key. It starts with rk_test_ or rk_live_.";
+            readonly notSigningSecret: "This is not a signing secret. It starts with whsec_.";
+            readonly hasSpaces: "There is a space or a line break inside what you pasted. Paste one value only.";
+            readonly empty: "Paste a value first.";
+            readonly networkOff: "This server is set to work without the internet, so no payment service can be connected.";
+            readonly desktop: "The desktop app takes payments by hand only: customers cannot reach this computer.";
+        };
+        readonly error: {
+            readonly unknown: "That did not work. Try again.";
+        };
+        readonly copied: "Copied";
+        readonly copy: "Copy";
+        readonly check: {
+            readonly missing: "{provider} says this key is missing: {list}. Edit the key in {provider} and paste it again.";
+            readonly ok: "{provider} accepted this key. Checked {when}.";
+            readonly failed: "{provider} could not check this key.";
+            readonly again: "Check";
+            readonly liveInTest: "This key is for live payments, and this field is for the test key.";
+            readonly testInLive: "This key is for test payments, and this field is for the live key.";
+        };
+        readonly webhook: {
+            readonly noAddress: "This server needs a public address first.";
+            readonly copyAddress: "Copy the webhook address";
+            readonly events: "Tick these events in {provider}";
+            readonly copyEvent: "Copy {event}";
+            readonly snapshot: "Choose the Snapshot payload.";
+            readonly stripeListen: "The secret that stripe listen prints is a different one.";
+            readonly arrived: "The first event arrived {when}, checked.";
+            readonly noLiveEvent: "No live event has arrived yet.";
+            readonly nothing: "Nothing has reached this address yet. If you made the endpoint, check that your proxy lets it through.";
+            readonly last: "Last event {when}, checked.";
+            readonly badLive: "{count, plural, one {# event} other {# events}} arrived in the last hour but the signature did not match. Is this the secret from the endpoint page, for live mode?";
+            readonly badTest: "{count, plural, one {# event} other {# events}} arrived in the last hour but the signature did not match. Is this the secret from the endpoint page, for test mode?";
+            readonly caught: "Adminium found a payment {when} that no webhook had announced. The webhook is not reaching this server.";
+            readonly slowed: "Adminium checks {provider} less often this month: it has used half of the reads {provider} allows.";
+            readonly moved: "The webhook address changed. Update it at {provider}:";
+            readonly headingTestStripe: "Test webhook (Stripe calls it a webhook endpoint)";
+            readonly headingLiveStripe: "Live webhook (Stripe calls it a webhook endpoint)";
+            readonly headingTest: "Test webhook";
+            readonly headingLive: "Live webhook";
+            readonly headingSandbox: "Sandbox webhook";
+            readonly addressTest: "Test webhook address";
+            readonly addressLive: "Live webhook address";
+            readonly addressSandbox: "Sandbox webhook address";
+        };
+        readonly mode: {
+            readonly test: "Test";
+            readonly live: "Live";
+        };
+        readonly access: {
+            readonly sessionsWrite: "Start a payment and end one that is no longer needed";
+            readonly sessionsRead: "See how a payment ended";
+            readonly intentsRead: "See the amount taken";
+            readonly refundsWrite: "Give refunds (in Stripe this access also allows changing charges)";
+            readonly eventsRead: "Catch a payment whose webhook went missing";
+            readonly disputesRead: "Show disputes";
+            readonly methodsRead: "See which ways to pay you switched on";
+            readonly accountRead: "Show which Stripe account the key belongs to";
+            readonly webhooksRead: "Check your live webhook";
+            readonly heading: "The access the key needs";
+            readonly note: "Both ways give the key exactly this. Leave everything else at None.";
+            readonly access: "Access";
+            readonly why: "Why";
+            readonly where: "Where in Stripe";
+            readonly optional: "(optional)";
+        };
+        readonly path: {
+            readonly app: {
+                readonly step1: "Install Node.js 22 or later";
+                readonly step2: "Install the Stripe CLI";
+                readonly title: "With your own Stripe App (the way Stripe recommends)";
+                readonly desc: "You upload a small app to your own Stripe account once, using the Stripe command-line tool. It makes a key with exactly the access below.";
+                readonly download: "Download the app template";
+                readonly note: "Upload once in your test account and once in your live account.";
+                readonly create: "Run {command} and answer its questions with anything";
+                readonly copy: "Copy {file} from the template you downloaded into the {folder} folder, replacing the one there";
+                readonly upload: "Run {first}, then {second}";
+                readonly install: "Install the app in the Stripe dashboard, open View API keys and copy the key that starts with {prefix}";
+            };
+            readonly hand: {
+                readonly step1: "In the Stripe dashboard, open Developers → API keys";
+                readonly step2: "Choose “Create restricted key”";
+                readonly step3: "Name it Adminium";
+                readonly step4: "Set the access in the list below. Leave everything else at None.";
+                readonly step5: "Create the key and copy it";
+                readonly title: "By hand in the Stripe dashboard (no terminal)";
+                readonly desc: "Make a restricted key yourself with the access below. Stripe prefers the app, but this works too.";
+            };
+        };
+        readonly alarm: {
+            readonly refused: "{provider} refused the key. It may have been revoked, or the app uninstalled.";
+            readonly permission: "{provider} refused the key: it is missing a permission.";
+            readonly paused: "Payments are paused until a working key is saved.";
+            readonly account: "The {provider} account changed from {from} to {to} {when}, by {by}.";
+            readonly bank: "The bank details for bank transfers changed {when}, by {by}.";
+            readonly address: "Your pay address changed from {from} to {to} {when}, by {by}. Update the webhook address at Stripe and PayPal.";
+            readonly heading: "Where the money goes changed";
+            readonly emailed: "Everyone who manages payments was emailed.";
+            readonly gotIt: "Got it";
+        };
+        readonly stop: {
+            readonly label: "Stop new payments";
+            readonly desc: "No new payments start. Adminium keeps the key to finish waiting payments and to give refunds.";
+            readonly confirmTitle: "Stop new payments?";
+            readonly confirmBody: "Customers cannot start a payment with {service} until you turn this off again. Payments already on their way still finish, and refunds still work.";
+            readonly cancel: "Keep taking payments";
+            readonly confirm: "Stop new payments";
+            readonly badge: "New payments stopped";
+        };
+        readonly close: "Close";
+        readonly checklist: {
+            readonly heading: "Setup checklist";
+            readonly progress: "{done} of {total} done · your progress is kept";
+            readonly done: "done";
+        };
+        readonly title: "Payments";
+        readonly subtitle: "Take payments for invoices and other records. The money goes straight to your own Stripe or PayPal account; Adminium never holds it.";
+        readonly tab: {
+            readonly setup: "Setup";
+            readonly ways: "Ways to pay";
+            readonly payables: "What can be paid";
+            readonly page: "Pay page";
+            readonly activity: "Activity";
+        };
+        readonly loadFailed: "Payments could not be loaded";
+        readonly forbidden: "Seeing payments needs the “Set up payments” or the “See payment activity” permission.";
+        readonly viewOnly: "You can see how payments are set up, but not change it.";
+        readonly noServices: "No payment service is installed. Install Card payments or Wallet payments from Add-ons, then set it up here.";
+        readonly ways: {
+            readonly anyCountry: "Any country";
+            readonly anyCurrency: "any currency";
+            readonly between: "{min} to {max}";
+            readonly fromMin: "from {min}";
+            readonly upToMax: "up to {max}";
+            readonly onlyForLine: "only for {list}";
+            readonly previewTitle: "What a customer sees";
+            readonly previewHelp: "Pick a customer to check your rules.";
+            readonly country: "Country";
+            readonly currency: "Currency";
+            readonly amount: "Amount";
+            readonly amountInvalid: "Write an amount such as 120.00.";
+            readonly previewChecking: "Checking…";
+            readonly previewNone: "A customer in {country} paying {amount} for an invoice sees: no way to pay.";
+            readonly previewSees: "A customer in {country} paying {amount} for an invoice sees: {list}.";
+            readonly rulesKickerHand: "Rules · By hand";
+            readonly rulesKicker: "Rules";
+            readonly countries: "Countries";
+            readonly countriesHelp: "Two-letter codes, such as DE. None means any country.";
+            readonly removeChip: "Remove {item}";
+            readonly addCountry: "Add a country";
+            readonly currencies: "Currencies";
+            readonly currenciesHelp: "Three-letter codes, such as EUR. None means any currency.";
+            readonly addCurrency: "Add a currency";
+            readonly smallest: "Smallest amount";
+            readonly none: "None";
+            readonly largest: "Largest amount";
+            readonly onlyFor: "Only for";
+            readonly onlyForHelp: "Leave every box empty to offer it for every record that can be paid.";
+            readonly countrySource: "Where the country comes from";
+            readonly countrySourceNoShop: "The customer's country column. Set the shop's country on the Pay page tab for customers without one.";
+            readonly countrySourceShop: "The customer's country column, or the shop's country ({country}) when it is empty.";
+            readonly cancel: "Cancel";
+            readonly saveRules: "Save rules";
+            readonly bankTitle: "Bank transfer";
+            readonly bankKicker: "Settings · By hand";
+            readonly bankEach: "Each currency has its own account.";
+            readonly removeAccount: "Remove the {currency} account";
+            readonly holder: "Account holder";
+            readonly iban: "IBAN";
+            readonly accountNumber: "Account number";
+            readonly accountNumberHelp: "Only where there is no IBAN.";
+            readonly bic: "BIC";
+            readonly sortCode: "Sort code";
+            readonly bank: "Bank";
+            readonly bankShown: "Customers paying in {currency} see these details on the pay page.";
+            readonly addAccount: "Add the account";
+            readonly note: "What the customer is told";
+            readonly noteHelp: "For example: Quote the invoice number as the reference.";
+            readonly bankIncomplete: "Each account needs a holder and an IBAN or an account number.";
+            readonly saveBank: "Save bank details";
+            readonly on: "On";
+            readonly off: "Off";
+            readonly tagHand: "By hand";
+            readonly followsCards: "It follows cards: it cannot be left out of one payment on its own. Switch it off in the Stripe dashboard.";
+            readonly noAccounts: "No bank account yet: customers are shown nothing to pay into.";
+            readonly accounts: "Accounts in {list}";
+            readonly editDetails: "Edit details";
+            readonly editRulesOf: "Edit the rules of {way}";
+            readonly editRules: "Edit rules";
+            readonly moveUp: "Move {way} up";
+            readonly moveDown: "Move {way} down";
+            readonly remove: "Remove {way}";
+            readonly from: "From {provider}";
+            readonly providerNote: "These are switched on in your {provider} dashboard. {provider} makes the final choice for each customer.";
+            readonly addFromProvider: "Add the ways {provider} has switched on";
+            readonly noneFromProvider: "No way to pay from {provider} is listed yet.";
+            readonly onlyShape: "Invoices built on the invoice format";
+            readonly onlyDocument: "Invoices made on the Invoices page";
+            readonly emptyTitle: "No ways to pay yet.";
+            readonly emptyBody: "Connect Stripe or PayPal on Setup, or add a way to pay by hand.";
+            readonly byHand: "By hand";
+            readonly byHandNote: "Ways the customer pays outside Adminium. Staff record the payment when it arrives.";
+            readonly noManual: "No way to pay by hand yet.";
+            readonly addHand: "Add a way to pay by hand";
+            readonly choose: "Choose…";
+            readonly add: "Add";
+        };
+        readonly loading: "Loading…";
+        readonly payables: {
+            readonly issue: {
+                readonly table: "This table cannot be made payable: it is private, left out of the schema, or not there any more.";
+                readonly noColumn: "The column {column} is not in the table any more. Choose another.";
+                readonly notMoney: "{column} does not hold an amount Adminium can count exactly. Choose a whole-number or decimal column.";
+                readonly unit: "Say whether {column} holds whole amounts or cents.";
+                readonly decimals: "{column} keeps fewer decimal places than the currency needs. Choose another column.";
+                readonly currency: "The connection has no currency set. Choose a currency column or one fixed currency, or set the connection's currency in its regional settings.";
+                readonly unique: "Choose the column that is unique for each payment.";
+                readonly methodValues: "Say what each way to pay is written as in {column}.";
+                readonly statusChoice: "{column} has no list of values. Choose a status column with its own list.";
+                readonly statusWritable: "Adminium may not set {column}: it is a key, a link, worked out by Adminium, or personal.";
+                readonly statusValue: "{column} has no such value. Choose one from its list.";
+                readonly personal: "{column} is personal and is never shown on the pay page.";
+                readonly methodValueUnknown: "{column} has no such value. Choose one from its list for each way to pay.";
+            };
+            readonly may: {
+                readonly read: "You need permission to read {table} to set it up.";
+                readonly update: "You need permission to edit {table} to set it up.";
+                readonly rowLimit: "You see only some rows of {table}, so you cannot make every row of it payable.";
+                readonly create: "You need permission to add rows to the payments table to set it up.";
+                readonly columnLimit: "You may read or change only some columns of {table}, so you cannot set it up.";
+            };
+            readonly method: {
+                readonly card: "Cards and wallets";
+                readonly bank: "Bank debits and transfers";
+                readonly other: "Any other online way";
+            };
+            readonly chooseColumn: "Choose a column";
+            readonly step1: "How much is owed";
+            readonly step2: "How payments land";
+            readonly step3: "What the pay page shows";
+            readonly setUpTable: "Set up a table";
+            readonly chooseTableTitle: "Choose a table";
+            readonly connection: "Connection";
+            readonly chooseConnection: "Choose a connection";
+            readonly table: "Table";
+            readonly chooseTable: "Choose a table";
+            readonly amount: "Amount";
+            readonly unitQuestion: "Is 12000 “twelve thousand” or “120.00”?";
+            readonly wholeAmounts: "Whole amounts";
+            readonly wholeHelp: "12000 is twelve thousand.";
+            readonly cents: "Cents";
+            readonly centsHelp: "12000 is one hundred and twenty.";
+            readonly currency: "Currency";
+            readonly currencyConnection: "The connection's currency";
+            readonly currencyColumn: "From a column";
+            readonly currencyFixed: "Always one currency";
+            readonly currencyColumnLabel: "Currency column";
+            readonly currencyCode: "Currency code";
+            readonly label: "The number the customer knows it by";
+            readonly kept: "Adminium keeps the payments";
+            readonly keptHelp: "Adminium records each payment against its row. Your tables stay as they are.";
+            readonly own: "This table has its own payments table";
+            readonly ownHelp: "Each payment is written as a row in a table you choose.";
+            readonly paymentsTable: "Payments table";
+            readonly link: "The column naming the record";
+            readonly date: "Date";
+            readonly wayToPay: "Way to pay";
+            readonly methodValues: "What each way to pay is written as";
+            readonly note: "Note";
+            readonly voided: "Voided flag";
+            readonly unique: "Unique for each payment";
+            readonly uniqueHelp: "Adminium uses it so a payment is never written twice.";
+            readonly ownUnit: "The payments table counts";
+            readonly balance: "Balance column of {table}";
+            readonly balanceNeeded: "A table that keeps its own payments names its balance, or a paid record would read as still owed.";
+            readonly optional: "Optional";
+            readonly statusPaid: "When it is paid in full, set Status to";
+            readonly statusColumn: "Status column";
+            readonly statusPaidValue: "Value when paid in full";
+            readonly statusRefunded: "When it is refunded in full, set Status to";
+            readonly statusNoValues: "Give this column a list of values (in the table's schema) to use it as a status.";
+            readonly leaveAsIs: "Leave it as it is";
+            readonly pageFields: "Columns allowed on the pay page";
+            readonly personal: "Personal: never shown";
+            readonly amountShown: "The amount and currency are always shown.";
+            readonly email: "Customer email (for sending the pay link)";
+            readonly country: "Customer country";
+            readonly countryHelp: "Used by the rules on Ways to pay.";
+            readonly preview: "Preview";
+            readonly previewOf: "Three rows from {table}";
+            readonly previewSummary: "{count, plural, one {# problem} other {# problems}}";
+            readonly previewWaiting: "Choose the amount to see three rows.";
+            readonly previewIncomplete: "Finish the choices above to see three rows.";
+            readonly becomes: "when paid, {column} becomes {value}";
+            readonly back: "Back";
+            readonly stepOf: "Step {step} of 3";
+            readonly next: "Next";
+            readonly turnOn: "Turn on payments";
+            readonly needsSaving: "Needs setting up again";
+            readonly on: "Can be paid";
+            readonly paused: "Paused";
+            readonly intoOwn: "Into its own payments table";
+            readonly keptShort: "Adminium keeps the payments";
+            readonly pauseLabel: "Payments for {table}";
+            readonly stop: "Stop";
+            readonly stopTitle: "Stop payments for {table}?";
+            readonly stopBody: "Its rows can no longer be paid, and pay links already sent for them stop working. Payments already made stay recorded.";
+            readonly keep: "Keep it payable";
+            readonly title: "What can be paid";
+            readonly intro: "Customers can pay a row from these tables with a pay link.";
+            readonly setUp: "Set up a table";
+            readonly done: "{table} can be paid now.";
+            readonly empty: "No table can be paid yet. Set one up, or install an app built on the invoice format.";
+            readonly canBePaid: "Can be paid";
+            readonly actions: "Actions";
+            readonly ready: "Ready";
+            readonly builtOn: "Built on the invoice format";
+            readonly needsUpdate: "Built on the invoice format. Online payments need the app’s update; payments by hand work.";
+            readonly previewHidden: "Rows are shown only to someone who may set this table up.";
+        };
+        readonly page: {
+            readonly logoType: "The logo must be a PNG, JPEG or WebP image.";
+            readonly saved: "Pay page saved";
+            readonly title: "What customers see";
+            readonly intro: "The name, logo and contact on every pay page.";
+            readonly shopName: "Shop name";
+            readonly shopNameNeeded: "The pay page needs a name.";
+            readonly logo: "Logo";
+            readonly noLogo: "No logo yet";
+            readonly logoUploaded: "Logo uploaded";
+            readonly upload: "Upload a logo";
+            readonly removeLogo: "Remove the logo";
+            readonly logoHelp: "PNG, JPEG or WebP. Square works best.";
+            readonly email: "Contact email";
+            readonly emailInvalid: "Write an address such as hello@example.com.";
+            readonly phone: "Contact phone";
+            readonly country: "The shop's country";
+            readonly countryHelp: "A two-letter code, such as DE. The rules on Ways to pay use it when a customer’s country is not known.";
+            readonly countryInvalid: "Write a two-letter code, such as DE.";
+            readonly lines: "Show the invoice's lines on the pay page";
+            readonly providerBranding: "Customers also see the name and logo set in your Stripe dashboard on the Stripe page.";
+            readonly logoPending: "Logo uploaded. Save to use it on the pay page.";
+            readonly where: "Where customers pay";
+            readonly whereStaff: "(your staff address)";
+            readonly whereCustomer: "(your customer address)";
+            readonly whereNote: "Pay links always use the address you choose here.";
+            readonly whereNone: "Set this server's public address first: pay links need an address customers can reach.";
+            readonly previewTitle: "Preview · invoice";
+            readonly previewFrame: "Pay page preview";
+            readonly openPreview: "Open a full preview";
+            readonly previewNote: "Staff only. It uses a pretend payment service and moves no money.";
+            readonly previewFailed: "The full preview could not be opened. Try again.";
+        };
+        readonly way: {
+            readonly card: "Cards";
+            readonly sepa: "SEPA Direct Debit";
+            readonly bankTransfer: "Bank transfer";
+            readonly cashOnDelivery: "Cash on delivery";
+            readonly other: "Another way to pay by hand";
+            readonly acssDebit: "Pre-authorized debit (Canada)";
+            readonly stripeTransfer: "Bank transfer (Stripe)";
+            readonly krCard: "Korean cards";
+            readonly crypto: "Crypto";
+        };
+        readonly test: {
+            readonly title: "Send a test payment";
+            readonly intro: "Opens the pay page for a pretend {amount} invoice in a new tab.";
+            readonly send: "Send a test payment";
+            readonly waitingStripe: "Waiting for the payment on the pay page. Use the Stripe test card {card}.";
+            readonly waitingPaypal: "Waiting for the payment on the pay page. A test payment needs a sandbox buyer login: Testing tools → Sandbox accounts on the PayPal developer site.";
+            readonly again: "Open the pay page again";
+            readonly took: "{service} took {amount} (Test)";
+            readonly webhook: "the webhook arrived";
+            readonly noWebhook: "no webhook arrived: the payment was found by asking";
+            readonly wouldRecord: "this is what would be recorded: one payment of {amount}.";
+            readonly wouldRecordWith: "this is what would be recorded: one payment of {amount}, {paidWith}.";
+            readonly nothingWritten: "Nothing was written to your tables.";
+            readonly noWay: "Customers see this service only once a way is switched on in Ways to pay.";
+            readonly openWays: "Open Ways to pay";
+        };
+        readonly activity: {
+            readonly state: {
+                readonly started: "Started";
+                readonly paid: "Paid";
+                readonly waiting: "Waiting for the bank";
+                readonly failed: "Did not go through";
+                readonly expired: "Expired";
+                readonly refunded: "Refunded";
+                readonly refundFailed: "Refund failed";
+                readonly disputed: "Disputed";
+            };
+            readonly service: {
+                readonly demo: "Demo service";
+            };
+            readonly way: {
+                readonly card: "Card";
+                readonly sepa: "SEPA Direct Debit";
+            };
+            readonly noRecord: "a record no longer there";
+            readonly flag: {
+                readonly notRecorded: "Paid at {service}, not recorded: {record} · {amount}.";
+                readonly moreThanDue: "Paid, but more than is now due: {service} took {taken} on {record}.";
+                readonly otherCurrency: "Paid, but in another currency: {service} took {taken}, the invoice was for {asked}.";
+                readonly otherCurrencyRecord: "Paid, but in another currency: {service} took {taken}, {record} asked for {asked}.";
+                readonly amountDiffers: "Paid, but the amount differs: {service} took {taken}, the invoice was for {asked}.";
+                readonly amountDiffersRecord: "Paid, but the amount differs: {service} took {taken}, {record} asked for {asked}.";
+                readonly refundedThereNoRecord: "Refunded in the {service} dashboard: {amount}. Recorded.";
+                readonly refundedThere: "Refunded in the {service} dashboard: {amount} on {record}. Recorded.";
+                readonly refundNotWritten: "Refunded {amount}, but it could not be written to {record} yet. It is tried again by itself.";
+                readonly refundRecordGone: "Refunded {amount}, but the payment it refunds is no longer in {record}. Nothing was written.";
+                readonly refundPastPaid: "Refunds on {record} now stand above what was paid. The record shows what was paid as refunded, and no more.";
+                readonly refundOtherCurrency: "Refunded {amount} at {service}, in another currency than {record} was paid in. Nothing was written to the record.";
+                readonly voided: "Paid after the invoice was voided: {record} · {amount}.";
+                readonly voidedRecord: "Paid after the record was removed or voided: {record} · {amount}.";
+                readonly modeMismatch: "Not believed: {service} answered in the other mode (test or live) for {record} · {amount}. Nothing was recorded.";
+                readonly paidTwice: "Paid twice: a payment for {record} · {amount} arrived while another was on its way. Both are recorded.";
+                readonly waitingLong: "Waiting for the bank for {days} days: {record} · {amount}.";
+                readonly waitingLongWay: "Waiting for the bank for {days} days: {record} · {amount} ({way}).";
+                readonly recordChanged: "A recorded payment changed: {record} · {amount} is no longer written down as it was.";
+                readonly disputed: "Disputed: {record} · {amount}. Answer it in the {service} dashboard.";
+                readonly disputeLost: "Dispute lost: {amount} went back to the customer on {record}. Recorded as a refund.";
+            };
+            readonly why: {
+                readonly alreadyPaid: "The invoice was already paid in full.";
+                readonly alreadyPaidRecord: "The record was already paid in full.";
+                readonly notTaken: "{service} did not say what it took.";
+                readonly notSent: "The invoice was not sent yet.";
+                readonly refused: "Its table did not take the payment.";
+            };
+            readonly story: {
+                readonly refundThere: "Refunded in the {service} dashboard: {amount}";
+                readonly refundDispute: "Dispute lost — {amount} returned to the customer";
+                readonly refundStarted: "Refund of {amount} started";
+                readonly refunded: "{service} says refunded";
+                readonly refundFailed: "{service} says the refund failed";
+                readonly refundApplied: "The record’s balance follows it";
+                readonly startedFor: "Started for {amount}";
+                readonly started: "Started";
+                readonly onPayPage: "Waiting for the customer to finish on the {service} page";
+                readonly waiting: "{service} says it is waiting for the bank";
+                readonly failed: "{service} says it did not go through";
+                readonly nothingTaken: "Nothing was taken";
+                readonly expired: "The {service} checkout expired before it was paid";
+                readonly left: "The customer left the {service} page";
+                readonly abandoned: "The checkout was never opened";
+                readonly paidAmount: "{service} says paid {amount}";
+                readonly paid: "{service} says paid";
+                readonly recorded: "Recorded";
+                readonly notRecorded: "Not recorded: it needs a look";
+                readonly disputed: "Dispute opened by the card holder";
+                readonly disputeAnswer: "Answer it in the {service} dashboard";
+                readonly disputeClosed: "The dispute was closed. Its outcome is in the {service} dashboard.";
+                readonly disputeWon: "The dispute was won.";
+                readonly disputeLost: "The dispute was lost: the money went back to the customer.";
+                readonly refundDisputeWon: "Dispute won — {amount} came back";
+            };
+            readonly checkedBy: "Checked by {name}";
+            readonly someone: "someone";
+            readonly checkedByNote: "Checked by {name} · {note}";
+            readonly checkedByYou: "Checked by you";
+            readonly checkedByYouNote: "Checked by you · {note}";
+            readonly markChecked: "Mark as checked";
+            readonly toast: {
+                readonly checked: "Marked as checked";
+                readonly copied: "Copied";
+                readonly copyFailed: "Could not copy. Select the text and copy it.";
+                readonly downloaded: "Downloaded {file}";
+                readonly exportFailed: "Could not export. Try again.";
+                readonly refundRequested: "Refund of {amount} requested.";
+                readonly refundFailed: "The refund of {amount} failed: {reason}";
+            };
+            readonly cancel: "Cancel";
+            readonly noteRequired: "Note (required)";
+            readonly note: "Note";
+            readonly noteHelp: "The note stays on this row for everyone who can see Activity.";
+            readonly notePlaceholder: "What did you check?";
+            readonly noteNeeded: "Say what you checked.";
+            readonly needsLook: "Needs a look";
+            readonly nothingNeedsLook: "Nothing needs a look.";
+            readonly silentNever: "No webhook from {service} has arrived yet. Adminium found a payment by checking {service}.";
+            readonly silent: "No webhook from {service} for {hours, plural, one {# hour} other {# hours}}. Adminium found a payment by checking {service}.";
+            readonly openSetup: "Open setup";
+            readonly loadFailed: "Could not load payments";
+            readonly tryAgain: "Try again";
+            readonly refundOf: "Refund";
+            readonly id: {
+                readonly attempt: "Attempt id";
+                readonly checkout: "{service} checkout id";
+                readonly payment: "{service} payment id";
+                readonly refund: "{service} refund id";
+            };
+            readonly payment: "Payment";
+            readonly close: "Close";
+            readonly col: {
+                readonly way: "Way to pay";
+                readonly service: "Service";
+                readonly record: "Record";
+                readonly when: "When";
+                readonly what: "What";
+                readonly amount: "Amount";
+                readonly state: "State";
+                readonly mode: "Test or live";
+            };
+            readonly whatHappened: "What happened";
+            readonly ids: "Ids";
+            readonly copyId: "Copy {label}";
+            readonly all: "All activity";
+            readonly allSub: "Payment attempts, payments and refunds";
+            readonly filter: {
+                readonly state: "State";
+                readonly allStates: "All states";
+                readonly service: "Service";
+                readonly allServices: "All services";
+                readonly way: "Way to pay";
+                readonly allWays: "All ways";
+                readonly mode: "Test / Live";
+                readonly allModes: "Test and live";
+                readonly from: "From";
+                readonly to: "To";
+            };
+            readonly export: "Export CSV";
+            readonly loading: "Loading payments";
+            readonly noMatch: "No payments match these filters.";
+            readonly clearFilters: "Clear filters";
+            readonly emptyTitle: "No payments yet.";
+            readonly emptyBody: "When customers pay, they appear here.";
+            readonly older: "Load older payments";
+            readonly viewOnly: "You can view payments. Ask someone who manages payments to act.";
+            readonly countLabel: "{count, plural, one {# needs a look} other {# need a look}}";
+            readonly refundAmount: "Refund {amount}";
+            readonly refund: "Refund";
+        };
+        readonly live: {
+            readonly ready: "The live key works";
+            readonly readyBody: "Turning on live payments sends customers to real payments. Every test link stops working then.";
+            readonly on: "Live is on";
+            readonly firstPayment: "First live payment arrived {when}";
+            readonly unproven: "Live is on, but the webhook is not proven yet.";
+            readonly unprovenBody: "Adminium checks {provider} more often until the first live event arrives.";
+            readonly turnOff: "Turn off live payments";
+            readonly turnOn: "Turn on live payments";
+            readonly confirmTitle: "Turn on live payments?";
+            readonly confirmBody: "Customers will pay real money with {provider}. Every test link stops working, and test payment pages still open are ended.";
+        };
+        readonly disconnect: {
+            readonly title: "Disconnect {provider}?";
+            readonly waiting: "{count, plural, one {# payment is} other {# payments are}} still waiting for the bank";
+            readonly refundable: "{count, plural, one {# payment} other {# payments}} can still be refunded";
+            readonly choice: "What to do";
+            readonly stop: "Stop new payments";
+            readonly stopBody: "No new payments start. Adminium keeps the key to finish the waiting payments and to give refunds.";
+            readonly remove: "Remove keys";
+            readonly removeBody: "Deletes the {provider} keys from this server. Adminium can no longer finish payments or give refunds.";
+            readonly removeWaiting: "{count, plural, one {# payment is} other {# payments are}} still waiting for the bank. Remove the keys anyway? They will need settling by hand.";
+            readonly settle: "Yes, remove the keys and settle {count, plural, one {the # payment} other {the # payments}} by hand";
+            readonly roll: "Removing the key here does not cancel it at {provider}. To be safe, roll the key in your {provider} dashboard.";
+            readonly cancel: "Cancel";
+            readonly typeName: "Type {provider} to confirm";
+        };
+        readonly menu: {
+            readonly check: "Check keys again";
+            readonly disconnect: "Disconnect…";
+        };
+        readonly clock: {
+            readonly title: "This server's clock is {seconds} seconds off the {provider} clock.";
+            readonly body: "Set the server time automatically (NTP). Past five minutes, payment messages from {provider} are refused.";
+        };
+        readonly menuLabel: "More for {service}";
+    };
 };
 export default _default;
 //# sourceMappingURL=studio.d.ts.map