taler-docs

wallet-core.md (154622B)

---

 # Wallet-Core API Documentation
 This file is auto-generated from the [taler-typescript-core](https://git.taler.net/taler-typescript-core.git/tree/packages/taler-wallet-core/src/wallet-api-types.ts) repository.
 ## Overview
 ###  Initialization
 * [InitWalletOp](#initwalletop)
 * [ShutdownOp](#shutdownop)
 * [HintApplicationResumedOp](#hintapplicationresumedop)
 * [SetWalletRunConfigOp](#setwalletrunconfigop)
 * [GetVersionOp](#getversionop)
 * [HintNetworkAvailabilityOp](#hintnetworkavailabilityop)
 ###  Generic request handling
 * [RetryProgressTokenNowOp](#retryprogresstokennowop)
 * [CancelProgressTokenOp](#cancelprogresstokenop)
 ###  Donau
 * [SetDonauOp](#setdonauop)
 * [GetDonauOp](#getdonauop)
 * [GetDonauStatementsOp](#getdonaustatementsop)
 ###  Contacts
 * [AddContactOp](#addcontactop)
 * [DeleteContactOp](#deletecontactop)
 * [GetContactsOp](#getcontactsop)
 ###  Taldir
 * [RegisterAliasOp](#registeraliasop)
 * [CompleteRegisterAliasOp](#completeregisteraliasop)
 * [LookupAliasOp](#lookupaliasop)
 ###  Mailbox
 * [RefreshMailboxOp](#refreshmailboxop)
 * [InitializeMailboxOp](#initializemailboxop)
 * [GetMailboxOp](#getmailboxop)
 * [GetMailboxMessagesOp](#getmailboxmessagesop)
 * [DeleteMailboxMessageOp](#deletemailboxmessageop)
 * [AddMailboxMessageOp](#addmailboxmessageop)
 * [SendTalerUriMailboxMessageOp](#sendtalerurimailboxmessageop)
 ###  Basic Wallet Information
 * [GetBalancesOp](#getbalancesop)
 * [GetBalancesDetailOp](#getbalancesdetailop)
 * [ConvertDepositAmountOp](#convertdepositamountop)
 * [GetMaxDepositAmountOp](#getmaxdepositamountop)
 * [GetMaxPeerPushDebitAmountOp](#getmaxpeerpushdebitamountop)
 ###  Managing Transactions
 * [GetTransactionsOp](#gettransactionsop)
 * [GetTransactionsV2Op](#gettransactionsv2op)
 * [ListAssociatedRefreshesOp](#listassociatedrefreshesop)
 * [TestingGetSampleTransactionsOp](#testinggetsampletransactionsop)
 * [GetTransactionByIdOp](#gettransactionbyidop)
 * [DeleteTransactionOp](#deletetransactionop)
 * [RetryTransactionOp](#retrytransactionop)
 * [AbortTransactionOp](#aborttransactionop)
 * [FailTransactionOp](#failtransactionop)
 * [SuspendTransactionOp](#suspendtransactionop)
 * [ResumeTransactionOp](#resumetransactionop)
 ###  Withdrawals
 * [GetWithdrawalDetailsForAmountOp](#getwithdrawaldetailsforamountop)
 * [GetWithdrawalDetailsForUriOp](#getwithdrawaldetailsforuriop)
 * [PrepareBankIntegratedWithdrawalOp](#preparebankintegratedwithdrawalop)
 * [ConfirmWithdrawalOp](#confirmwithdrawalop)
 * [AcceptBankIntegratedWithdrawalOp](#acceptbankintegratedwithdrawalop)
 * [AcceptManualWithdrawalOp](#acceptmanualwithdrawalop)
 ###  Merchant Payments
 * [PreparePayForUriOp](#preparepayforuriop)
 * [PreparePayForTemplateOp](#preparepayfortemplateop)
 * [PreparePayForUriV2Op](#preparepayforuriv2op)
 * [PreparePayForTemplateV2Op](#preparepayfortemplatev2op)
 * [GetChoicesForPaymentOp](#getchoicesforpaymentop)
 * [SharePaymentOp](#sharepaymentop)
 * [CheckPayForTemplateOp](#checkpayfortemplateop)
 * [ConfirmPayOp](#confirmpayop)
 * [StartRefundQueryForUriOp](#startrefundqueryforuriop)
 * [StartRefundQueryOp](#startrefundqueryop)
 ###  Token family management
 * [ListDiscountsOp](#listdiscountsop)
 * [DeleteDiscountOp](#deletediscountop)
 * [ListSubscriptionsOp](#listsubscriptionsop)
 * [DeleteSubscriptionOp](#deletesubscriptionop)
 ###  Global Currency management
 * [ListGlobalCurrencyAuditorsOp](#listglobalcurrencyauditorsop)
 * [ListGlobalCurrencyExchangesOp](#listglobalcurrencyexchangesop)
 * [AddGlobalCurrencyExchangeOp](#addglobalcurrencyexchangeop)
 * [AddGlobalCurrencyAuditorOp](#addglobalcurrencyauditorop)
 * [RemoveGlobalCurrencyExchangeOp](#removeglobalcurrencyexchangeop)
 * [RemoveGlobalCurrencyAuditorOp](#removeglobalcurrencyauditorop)
 ###  Exchange Management
 * [CompleteExchangeBaseUrlOp](#completeexchangebaseurlop)
 * [ListExchangesOp](#listexchangesop)
 * [StartExchangeWalletKycOp](#startexchangewalletkycop)
 * [TestingWaitExchangeWalletKycOp](#testingwaitexchangewalletkycop)
 * [TestingPlanMigrateExchangeBaseUrlOp](#testingplanmigrateexchangebaseurlop)
 * [PrepareWithdrawExchangeOp](#preparewithdrawexchangeop)
 * [AddExchangeOp](#addexchangeop)
 * [UpdateExchangeEntryOp](#updateexchangeentryop)
 * [ListBankAccountsOp](#listbankaccountsop)
 * [GetBankAccountByIdOp](#getbankaccountbyidop)
 * [AddBankAccountsOp](#addbankaccountsop)
 * [ForgetBankAccountsOp](#forgetbankaccountsop)
 * [SetExchangeTosAcceptedOp](#setexchangetosacceptedop)
 * [SetExchangeTosForgottenOp](#setexchangetosforgottenop)
 * [GetExchangeTosOp](#getexchangetosop)
 * [GetDepositWireTypesOp](#getdepositwiretypesop)
 * [GetDepositWireTypesForCurrencyOp](#getdepositwiretypesforcurrencyop)
 * [GetExchangeDetailedInfoOp](#getexchangedetailedinfoop)
 * [GetDefaultExchangesOp](#getdefaultexchangesop)
 * [GetExchangeEntryByUrlOp](#getexchangeentrybyurlop)
 * [GetExchangeResourcesOp](#getexchangeresourcesop)
 * [DeleteExchangeOp](#deleteexchangeop)
 * [GetCurrencySpecificationOp](#getcurrencyspecificationop)
 ###  Deposits
 * [CreateDepositGroupOp](#createdepositgroupop)
 * [CheckDepositOp](#checkdepositop)
 ###  Backups
 * [ExportDbToFileOp](#exportdbtofileop)
 * [ImportDbFromFileOp](#importdbfromfileop)
 * [ListStoredBackupsOp](#liststoredbackupsop)
 * [CreateStoredBackupsOp](#createstoredbackupsop)
 * [RecoverStoredBackupsOp](#recoverstoredbackupsop)
 * [DeleteStoredBackupOp](#deletestoredbackupop)
 ###  Peer Payments
 * [CheckPeerPushDebitOp](#checkpeerpushdebitop)
 * [CheckPeerPushDebitV2Op](#checkpeerpushdebitv2op)
 * [InitiatePeerPushDebitOp](#initiatepeerpushdebitop)
 * [PreparePeerPushCreditOp](#preparepeerpushcreditop)
 * [ConfirmPeerPushCreditOp](#confirmpeerpushcreditop)
 * [CheckPeerPullCreditOp](#checkpeerpullcreditop)
 * [InitiatePeerPullCreditOp](#initiatepeerpullcreditop)
 * [PreparePeerPullDebitOp](#preparepeerpulldebitop)
 * [ConfirmPeerPullDebitOp](#confirmpeerpulldebitop)
 ###  Data Validation and Conversion
 * [ValidateIbanOp](#validateibanop)
 * [CanonicalizeBaseUrlOp](#canonicalizebaseurlop)
 * [GetQrCodesForPaytoOp](#getqrcodesforpaytoop)
 * [ConvertIbanAccountFieldToPaytoOp](#convertibanaccountfieldtopaytoop)
 * [ConvertIbanPaytoToAccountFieldOp](#convertibanpaytotoaccountfieldop)
 * [GetBankingChoicesForPaytoOp](#getbankingchoicesforpaytoop)
 ###  Database Management
 * [ExportDbOp](#exportdbop)
 * [ImportDbOp](#importdbop)
 * [ClearDbOp](#cleardbop)
 * [RecycleOp](#recycleop)
 ###  Testing and Debugging
 * [ApplyDevExperimentOp](#applydevexperimentop)
 * [RunIntegrationTestOp](#runintegrationtestop)
 * [RunIntegrationTestV2Op](#runintegrationtestv2op)
 * [TestCryptoOp](#testcryptoop)
 * [WithdrawTestBalanceOp](#withdrawtestbalanceop)
 * [WithdrawTestkudosOp](#withdrawtestkudosop)
 * [TestPayOp](#testpayop)
 * [GetActiveTasksOp](#getactivetasksop)
 * [GetPerformanceStatsOp](#getperformancestatsop)
 * [DumpCoinsOp](#dumpcoinsop)
 * [TestingSetTimetravelOp](#testingsettimetravelop)
 * [TestingWaitTransactionsFinalOp](#testingwaittransactionsfinalop)
 * [TestingWaitTasksDoneOp](#testingwaittasksdoneop)
 * [TestingWaitRefreshesFinalOp](#testingwaitrefreshesfinalop)
 * [TestingWaitBalanceOp](#testingwaitbalanceop)
 * [TestingWaitTransactionStateOp](#testingwaittransactionstateop)
 * [TestingWaitExchangeStateOp](#testingwaitexchangestateop)
 * [TestingWaitExchangeReadyOp](#testingwaitexchangereadyop)
 * [TestingPingOp](#testingpingop)
 * [TestingGetReserveHistoryOp](#testinggetreservehistoryop)
 * [TestingResetAllRetriesOp](#testingresetallretriesop)
 * [TestingGetDenomStatsOp](#testinggetdenomstatsop)
 * [TestingRunFixupOp](#testingrunfixupop)
 * [TestingGetDiagnosticsOp](#testinggetdiagnosticsop)
 * [TestingGetFlightRecordsOp](#testinggetflightrecordsop)
 * [TestingCorruptWithdrawalCoinSelOp](#testingcorruptwithdrawalcoinselop)
 * [SetCoinSuspendedOp](#setcoinsuspendedop)
 * [ForceRefreshOp](#forcerefreshop)
 ## Operation Reference
 ### InitWalletOp
 ```typescript
 /**
  * Initialize wallet-core.
  *
  * Must be the first request made to wallet-core.
  */
 export type InitWalletOp = {
   op: WalletApiOperation.InitWallet;
   request: InitRequest;
   response: InitResponse;
 };
 // InitWallet = "initWallet"
 
 ```
 
 ### ShutdownOp
 ```typescript
 export type ShutdownOp = {
   op: WalletApiOperation.Shutdown;
   request: EmptyObject;
   response: EmptyObject;
 };
 // Shutdown = "shutdown"
 
 ```
 
 ### HintApplicationResumedOp
 ```typescript
 /**
  * Give wallet-core a kick and restart all pending tasks.
  * Useful when the host application gets suspended and resumed,
  * and active network requests might have stalled.
  */
 export type HintApplicationResumedOp = {
   op: WalletApiOperation.HintApplicationResumed;
   request: EmptyObject;
   response: EmptyObject;
 };
 // HintApplicationResumed = "hintApplicationResumed"
 
 ```
 
 ### SetWalletRunConfigOp
 ```typescript
 /**
  * Change the configuration of wallet-core.
  *
  * Currently an alias for the initWallet request.
  */
 export type SetWalletRunConfigOp = {
   op: WalletApiOperation.SetWalletRunConfig;
   request: InitRequest;
   response: InitResponse;
 };
 // SetWalletRunConfig = "setWalletRunConfig"
 
 ```
 
 ### GetVersionOp
 ```typescript
 export type GetVersionOp = {
   op: WalletApiOperation.GetVersion;
   request: EmptyObject;
   response: WalletCoreVersion;
 };
 // GetVersion = "getVersion"
 
 ```
 
 ### HintNetworkAvailabilityOp
 ```typescript
 export type HintNetworkAvailabilityOp = {
   op: WalletApiOperation.HintNetworkAvailability;
   request: HintNetworkAvailabilityRequest;
   response: EmptyObject;
 };
 // HintNetworkAvailability = "hintNetworkAvailability"
 
 ```
 ```typescript
 export interface HintNetworkAvailabilityRequest {
   isNetworkAvailable: boolean;
 }
 
 ```
 
 ### RetryProgressTokenNowOp
 ```typescript
 export type RetryProgressTokenNowOp = {
   op: WalletApiOperation.RetryProgressTokenNow;
   request: RetryProgressTokenNowRequest;
   response: EmptyObject;
 };
 // RetryProgressTokenNow = "retryProgressTokenNow"
 
 ```
 ```typescript
 export interface RetryProgressTokenNowRequest {
   operation: string;
   progressToken: string;
 }
 
 ```
 
 ### CancelProgressTokenOp
 ```typescript
 export type CancelProgressTokenOp = {
   op: WalletApiOperation.CancelProgressToken;
   request: CancelProgressTokenRequest;
   response: EmptyObject;
 };
 // CancelProgressToken = "cancelProgressToken"
 
 ```
 ```typescript
 export interface CancelProgressTokenRequest {
   operation: string;
   progressToken: string;
 }
 
 ```
 
 ### SetDonauOp
 ```typescript
 /**
  * Set the donation authority for this wallet.
  */
 export type SetDonauOp = {
   op: WalletApiOperation.SetDonau;
   request: SetDonauRequest;
   response: EmptyObject;
 };
 // SetDonau = "setDonau"
 
 ```
 ```typescript
 export interface SetDonauRequest {
   donauBaseUrl: string;
   taxPayerId: string;
 }
 
 ```
 
 ### GetDonauOp
 ```typescript
 /**
  * Get the currently configured donation authority for this
  * wallet.
  */
 export type GetDonauOp = {
   op: WalletApiOperation.GetDonau;
   request: EmptyObject;
   response: GetDonauResponse;
 };
 // GetDonau = "getDonau"
 
 ```
 ```typescript
 export interface GetDonauResponse {
   currentDonauInfo:
     | {
         donauBaseUrl: string;
         taxPayerId: string;
       }
     | undefined;
 }
 
 ```
 
 ### GetDonauStatementsOp
 ```typescript
 /**
  * Get a list of donation statements
  * for this wallet.
  * Both donation statements for the currently configured
  * donation authority as well as past configurations (if they exist)
  * are returned.
  */
 export type GetDonauStatementsOp = {
   op: WalletApiOperation.GetDonauStatements;
   request: GetDonauStatementsRequest;
   response: GetDonauStatementsResponse;
 };
 // GetDonauStatements = "getDonauStatements"
 
 ```
 ```typescript
 export interface GetDonauStatementsRequest {
   donauBaseUrl?: string;
 }
 
 ```
 ```typescript
 export interface GetDonauStatementsResponse {
   statements: DonauStatementItem[];
 }
 
 ```
 ```typescript
 export interface DonauStatementItem {
   total: AmountString;
   year: number;
   legalDomain: string;
   uri: string;
   donationStatementSig: EddsaSignatureString;
   donauPub: EddsaPublicKeyString;
 }
 
 ```
 
 ### AddContactOp
 ```typescript
 /**
  * add contact.
  */
 export type AddContactOp = {
   op: WalletApiOperation.AddContact;
   request: AddContactRequest;
   response: EmptyObject;
 };
 // AddContact = "addContact"
 
 ```
 ```typescript
 export interface AddContactRequest {
   contact: ContactEntry;
 }
 
 ```
 
 ### DeleteContactOp
 ```typescript
 /**
  * delete contact.
  */
 export type DeleteContactOp = {
   op: WalletApiOperation.DeleteContact;
   request: DeleteContactRequest;
   response: EmptyObject;
 };
 // DeleteContact = "deleteContact"
 
 ```
 ```typescript
 export interface DeleteContactRequest {
   contact: ContactEntry;
 }
 
 ```
 
 ### GetContactsOp
 ```typescript
 /**
  * Get contacts.
  */
 export type GetContactsOp = {
   op: WalletApiOperation.GetContacts;
   request: EmptyObject;
   response: ContactListResponse;
 };
 // GetContacts = "getContacts"
 
 ```
 ```typescript
 export interface ContactListResponse {
   contacts: ContactEntry[];
 }
 
 ```
 
 ### RegisterAliasOp
 ```typescript
 /**
  * Register alias
  */
 export type RegisterAliasOp = {
   op: WalletApiOperation.RegisterAlias;
   request: TaldirRegistrationRequest;
   response: TaldirRegistrationResponse;
 };
 // RegisterAlias = "registerAlias"
 
 ```
 ```typescript
 export interface TaldirRegistrationRequest {
   alias: string;
   aliasType: string;
   targetUri: string;
   taldirBaseUrl: string;
   duration: RelativeTime;
 }
 
 ```
 ```typescript
 export type TaldirRegistrationResponse =
   | TaldirAlreadyPaidResponse
   | EmptyObject;
 
 ```
 ```typescript
 export interface TaldirAlreadyPaidResponse {
   valid_for: RelativeTime;
 }
 
 ```
 
 ### CompleteRegisterAliasOp
 ```typescript
 /**
  * Complete alias registration
  */
 export type CompleteRegisterAliasOp = {
   op: WalletApiOperation.CompleteRegisterAlias;
   request: TaldirRegistrationCompletionRequest;
   response: EmptyObject;
 };
 // CompleteRegisterAlias = "completeRegisterAlias"
 
 ```
 ```typescript
 export interface TaldirRegistrationCompletionRequest {
   alias: string;
   aliasType: string;
   challenge: string;
   taldirBaseUrl: string;
   targetUri: string;
 }
 
 ```
 
 ### LookupAliasOp
 ```typescript
 /**
  * Lookup alias
  */
 export type LookupAliasOp = {
   op: WalletApiOperation.LookupAlias;
   request: TaldirLookupRequest;
   response: TaldirLookupResponse;
 };
 // LookupAlias = "lookupAlias"
 
 ```
 ```typescript
 export interface TaldirLookupRequest {
   alias: string;
   aliasType: string;
   taldirBaseUrl: string;
 }
 
 ```
 ```typescript
 export interface TaldirLookupResponse {
   targetUri?: string;
 }
 
 ```
 
 ### RefreshMailboxOp
 ```typescript
 /**
  * Refresh mailbox Op.
  */
 export type RefreshMailboxOp = {
   op: WalletApiOperation.RefreshMailbox;
   request: MailboxConfiguration;
   response: MailboxMessageRecordsResponse;
 };
 // RefreshMailbox = "refreshMailbox"
 
 ```
 ```typescript
 export interface MailboxMessageRecordsResponse {
   messages: MailboxMessageRecord[];
 }
 
 ```
 
 ### InitializeMailboxOp
 ```typescript
 /**
  * Initialize messages mailbox Op.
  */
 export type InitializeMailboxOp = {
   op: WalletApiOperation.InitializeMailbox;
   request: MailboxBaseUrl;
   response: MailboxConfiguration;
 };
 // InitializeMailbox = "initializeMailbox"
 
 ```
 
 ### GetMailboxOp
 ```typescript
 /**
  * Get messages mailbox Op.
  */
 export type GetMailboxOp = {
   op: WalletApiOperation.GetMailbox;
   request: MailboxBaseUrl;
   response: GetMailboxResponse;
 };
 // GetMailbox = "getMailbox"
 
 ```
 ```typescript
 export interface GetMailboxResponse {
   mailboxConfiguration?: MailboxConfiguration;
 }
 
 ```
 
 ### GetMailboxMessagesOp
 ```typescript
 /**
  * Get Messages Op.
  */
 export type GetMailboxMessagesOp = {
   op: WalletApiOperation.GetMailboxMessages;
   request: EmptyObject;
   response: MailboxMessagesResponse;
 };
 // GetMailboxMessages = "getMailboxMessage"
 
 ```
 ```typescript
 export interface MailboxMessagesResponse {
   messages: MailboxMessageRecord[];
 }
 
 ```
 
 ### DeleteMailboxMessageOp
 ```typescript
 /**
  * delete message.
  */
 export type DeleteMailboxMessageOp = {
   op: WalletApiOperation.DeleteMailboxMessage;
   request: DeleteMailboxMessageRequest;
   response: EmptyObject;
 };
 // DeleteMailboxMessage = "deleteMailboxMessage"
 
 ```
 ```typescript
 export interface DeleteMailboxMessageRequest {
   message: MailboxMessageRecord;
 }
 
 ```
 
 ### AddMailboxMessageOp
 ```typescript
 /**
  * add message.
  */
 export type AddMailboxMessageOp = {
   op: WalletApiOperation.AddMailboxMessage;
   request: AddMailboxMessageRequest;
   response: EmptyObject;
 };
 // AddMailboxMessage = "addMailboxMessage"
 
 ```
 ```typescript
 export interface AddMailboxMessageRequest {
   message: MailboxMessageRecord;
 }
 
 ```
 
 ### SendTalerUriMailboxMessageOp
 ```typescript
 /**
  * send message.
  */
 export type SendTalerUriMailboxMessageOp = {
   op: WalletApiOperation.SendTalerUriMailboxMessage;
   request: SendTalerUriMailboxMessageRequest;
   response: EmptyObject;
 };
 // SendTalerUriMailboxMessage = "sendTalerUriMailboxMessage"
 
 ```
 ```typescript
 export interface SendTalerUriMailboxMessageRequest {
   contact: ContactEntry;
   talerUri: string;
 }
 
 ```
 
 ### GetBalancesOp
 ```typescript
 /**
  * Get current wallet balance.
  */
 export type GetBalancesOp = {
   op: WalletApiOperation.GetBalances;
   request: EmptyObject;
   response: BalancesResponse;
 };
 // GetBalances = "getBalances"
 
 ```
 ```typescript
 /**
  * Response to a getBalances request.
  */
 export interface BalancesResponse {
   /** Electronic cash balances, per currency scope. */
   balances: WalletBalance[];
   /** Does the user have non-demo money? */
   haveProdBalance: boolean;
   donauSummary?: DonauSummaryItem[];
 }
 
 ```
 ```typescript
 export interface WalletBalance {
   scopeInfo: ScopeInfo;
   available: AmountString;
   pendingIncoming: AmountString;
   pendingOutgoing: AmountString;
   flags: BalanceFlag[];
   /**
    * Available URLs for pages that list
    * where money in this scope can be spent.
    */
   shoppingUrls?: string[];
   /**
    * Are p2p payments disabled for this scope?
    */
   disablePeerPayments?: boolean;
   /**
    * Are wallet deposits enabled for this scope?
    */
   disableDirectDeposits?: boolean;
 }
 
 ```
 ```typescript
 export declare enum BalanceFlag {
   IncomingKyc = "incoming-kyc",
   IncomingAml = "incoming-aml",
   IncomingConfirmation = "incoming-confirmation",
   OutgoingKyc = "outgoing-kyc",
 }
 
 ```
 ```typescript
 export interface DonauSummaryItem {
   /** Base URL of the donau service. */
   donauBaseUrl: string;
   /** Legal domain of the donau service (if available). */
   legalDomain?: string;
   /** Year of the donation(s). */
   year: number;
   /**
    * Sum of donation receipts we received from merchants in the
    * applicable year.
    */
   amountReceiptsAvailable: AmountString;
   /**
    * Sum of donation receipts that were already submitted
    * to the donau in the applicable year.
    */
   amountReceiptsSubmitted: AmountString;
   /**
    * Amount of the latest available statement. Missing if no statement
    * was requested yet.
    */
   amountStatement?: AmountString;
 }
 
 ```
 
 ### GetBalancesDetailOp
 ```typescript
 export type GetBalancesDetailOp = {
   op: WalletApiOperation.GetBalanceDetail;
   request: GetBalanceDetailRequest;
   response: PaymentBalanceDetails;
 };
 // GetBalanceDetail = "getBalanceDetail"
 
 ```
 ```typescript
 export interface GetBalanceDetailRequest {
   currency: string;
 }
 
 ```
 ```typescript
 export interface PaymentBalanceDetails {
   /**
    * Balance of type "available" (see balance.ts for definition).
    */
   balanceAvailable: AmountJson;
   /**
    * Balance of type "material" (see balance.ts for definition).
    */
   balanceMaterial: AmountJson;
   /**
    * Balance of type "age-acceptable" (see balance.ts for definition).
    */
   balanceAgeAcceptable: AmountJson;
   /**
    * Balance of type "receiver-acceptable" (see balance.ts for definition).
    *
    * @deprecated (2025-12-05) use balanceReceiver[...]Acceptable instead.
    */
   balanceReceiverAcceptable: AmountJson;
   /**
    * Balance of type "receiver-exchange-url-acceptable" (see balance.ts for definition).
    */
   balanceReceiverExchangeUrlAcceptable: AmountJson;
   /**
    * Balance of type "receiver-exchange-pub-acceptable" (see balance.ts for definition).
    */
   balanceReceiverExchangePubAcceptable: AmountJson;
   /**
    * Balance of type "receiver-auditor-url-acceptable" (see balance.ts for definition).
    */
   balanceReceiverAuditorUrlAcceptable: AmountJson;
   /**
    * Balance of type "receiver-depositable" (see balance.ts for definition).
    */
   balanceReceiverDepositable: AmountJson;
   /**
    * Balance that's depositable with the exchange.
    * This balance is reduced by the exchange's debit restrictions
    * and wire fee configuration.
    */
   balanceExchangeDepositable: AmountJson;
   /**
    * Estimated maximum amount that the wallet could pay for, under the assumption
    * that the merchant pays absolutely no fees.
    */
   maxMerchantEffectiveDepositAmount: AmountJson;
 }
 
 ```
 ```typescript
 /**
  * Non-negative financial amount.  Fractional values are expressed as multiples
  * of 1e-8.
  */
 export interface AmountJson {
   /**
    * Value, must be an integer.
    */
   readonly value: number;
   /**
    * Fraction, must be an integer.  Represent 1/1e8 of a unit.
    */
   readonly fraction: number;
   /**
    * Currency of the amount.
    */
   readonly currency: string;
 }
 
 ```
 
 ### ConvertDepositAmountOp
 ```typescript
 export type ConvertDepositAmountOp = {
   op: WalletApiOperation.ConvertDepositAmount;
   request: ConvertAmountRequest;
   response: AmountResponse;
 };
 // ConvertDepositAmount = "convertDepositAmount"
 
 ```
 ```typescript
 export interface ConvertAmountRequest {
   amount: AmountString;
   type: TransactionAmountMode;
   depositPaytoUri: PaytoString;
 }
 
 ```
 ```typescript
 /**
  * How the amount should be interpreted in a transaction
  * Effective = how the balance is change
  * Raw = effective amount without fee
  *
  * Depending on the transaction, raw can be higher than effective
  */
 export declare enum TransactionAmountMode {
   Effective = "effective",
   Raw = "raw",
 }
 
 ```
 ```typescript
 export interface AmountResponse {
   effectiveAmount: AmountString;
   rawAmount: AmountString;
 }
 
 ```
 
 ### GetMaxDepositAmountOp
 ```typescript
 export type GetMaxDepositAmountOp = {
   op: WalletApiOperation.GetMaxDepositAmount;
   request: GetMaxDepositAmountRequest;
   response: GetMaxDepositAmountResponse;
 };
 // GetMaxDepositAmount = "getMaxDepositAmount"
 
 ```
 ```typescript
 export interface GetMaxDepositAmountRequest {
   /**
    * Currency to deposit.
    */
   currency: string;
   /**
    * Target bank account to deposit into.
    */
   depositPaytoUri?: string;
   /**
    * Restrict the deposit to a certain scope.
    */
   restrictScope?: ScopeInfo;
 }
 
 ```
 ```typescript
 export interface GetMaxDepositAmountResponse {
   effectiveAmount: AmountString;
   rawAmount: AmountString;
   /**
    * Account restrictions that affect the max deposit amount.
    */
   depositRestrictions?: {
     [exchangeBaseUrl: string]: {
       [paytoUri: string]: AccountRestriction[];
     };
   };
 }
 
 ```
 
 ### GetMaxPeerPushDebitAmountOp
 ```typescript
 export type GetMaxPeerPushDebitAmountOp = {
   op: WalletApiOperation.GetMaxPeerPushDebitAmount;
   request: GetMaxPeerPushDebitAmountRequest;
   response: GetMaxPeerPushDebitAmountResponse;
 };
 // GetMaxPeerPushDebitAmount = "getMaxPeerPushDebitAmount"
 
 ```
 ```typescript
 export interface GetMaxPeerPushDebitAmountRequest {
   currency: string;
   /**
    * Preferred exchange to use for the p2p payment.
    */
   exchangeBaseUrl?: string;
   restrictScope?: ScopeInfo;
 }
 
 ```
 ```typescript
 export interface GetMaxPeerPushDebitAmountResponse {
   effectiveAmount: AmountString;
   rawAmount: AmountString;
   exchangeBaseUrl?: string;
 }
 
 ```
 
 ### GetTransactionsOp
 ```typescript
 /**
  * Get transactions.
  */
 export type GetTransactionsOp = {
   op: WalletApiOperation.GetTransactions;
   request: TransactionsRequest;
   response: TransactionsResponse;
 };
 // GetTransactions = "getTransactions"
 
 ```
 ```typescript
 export interface TransactionsRequest {
   /**
    * return only transactions in the given currency
    *
    * it will be removed in next release
    *
    * @deprecated use scopeInfo
    */
   currency?: string;
   /**
    * return only transactions in the given scopeInfo
    */
   scopeInfo?: ScopeInfo;
   /**
    * if present, results will be limited to transactions related to the given search string
    */
   search?: string;
   /**
    * Sort order of the transaction items.
    * By default, items are sorted ascending by their
    * main timestamp.
    *
    * ascending: ascending by timestamp, but pending transactions first
    * descending: ascending by timestamp, but pending transactions first
    * stable-ascending: ascending by timestamp, with pending transactions amidst other transactions
    *    (stable in the sense of: pending transactions don't jump around)
    */
   sort?: "ascending" | "descending" | "stable-ascending";
   /**
    * If true, include all refreshes in the transactions list.
    */
   includeRefreshes?: boolean;
   filterByState?: TransactionStateFilter;
 }
 
 ```
 
 ### GetTransactionsV2Op
 ```typescript
 export type GetTransactionsV2Op = {
   op: WalletApiOperation.GetTransactionsV2;
   request: GetTransactionsV2Request;
   response: TransactionsResponse;
 };
 // GetTransactionsV2 = "getTransactionsV2"
 
 ```
 ```typescript
 export interface GetTransactionsV2Request {
   /**
    * Return only transactions in the given currency.
    */
   currency?: string;
   /**
    * Return only transactions in the given scopeInfo
    */
   scopeInfo?: ScopeInfo;
   /**
    * If true, include all refreshes in the transactions list.
    */
   includeRefreshes?: boolean;
   /**
    * If true, include transactions that would usually be filtered out.
    * Implies includeRefreshes.
    */
   includeAll?: boolean;
   /**
    * Only return transactions before/after this offset.
    */
   offsetTransactionId?: TransactionIdStr;
   /**
    * Only return transactions before/after the transaction with this
    * timestamp.
    *
    * Used as a fallback if the offsetTransactionId was deleted.
    */
   offsetTimestamp?: TalerPreciseTimestamp;
   /**
    * Number of transactions to return.
    *
    * When the limit is positive, results are returned
    * in ascending order of their timestamp.  If no offset is specified,
    * the result list begins with the first transaction.
    * If an offset is specified, transactions after the offset are returned.
    *
    * When the limit is negative, results are returned
    * in descending order of their timestamp.  If no offset is specified,
    * the result list begins with with the last transaction.
    * If an offset is specified, transactions before the offset are returned.
    */
   limit?: number;
   /**
    * Filter transactions by their state / state category.
    *
    * If not specified, all transactions are returned.
    *
    * final: Transactions in any final state
    * nonfinal: Transactions in any state but the final states
    * nonfinal-dialog: nonfinal transactions that require confirmation / some
    *   choice by the user
    * nonfinal-approved: nonfinal transactions that need no further user approval
    * done: Transactions in the "done" major state
    */
   filterByState?:
     | "final"
     | "nonfinal"
     | "done"
     | "nonfinal-approved"
     | "nonfinal-dialog";
 }
 
 ```
 
 ### ListAssociatedRefreshesOp
 ```typescript
 /**
  * List refresh transactions associated with another transaction.
  */
 export type ListAssociatedRefreshesOp = {
   op: WalletApiOperation.ListAssociatedRefreshes;
   request: ListAssociatedRefreshesRequest;
   response: ListAssociatedRefreshesResponse;
 };
 // ListAssociatedRefreshes = "listAssociatedRefreshes"
 
 ```
 ```typescript
 export interface ListAssociatedRefreshesRequest {
   transactionId: string;
 }
 
 ```
 ```typescript
 export interface ListAssociatedRefreshesResponse {
   transactionIds: string[];
 }
 
 ```
 
 ### TestingGetSampleTransactionsOp
 ```typescript
 /**
  * Get sample transactions.
  */
 export type TestingGetSampleTransactionsOp = {
   op: WalletApiOperation.TestingGetSampleTransactions;
   request: EmptyObject;
   response: TransactionsResponse;
 };
 // TestingGetSampleTransactions = "testingGetSampleTransactions"
 
 ```
 
 ### GetTransactionByIdOp
 ```typescript
 export type GetTransactionByIdOp = {
   op: WalletApiOperation.GetTransactionById;
   request: TransactionByIdRequest;
   response: Transaction;
 };
 // GetTransactionById = "getTransactionById"
 
 ```
 ```typescript
 export interface TransactionByIdRequest {
   transactionId: string;
   /**
    * If set to true, report the full contract terms in the response
    * if the transaction has them.
    */
   includeContractTerms?: boolean;
 }
 
 ```
 
 ### DeleteTransactionOp
 ```typescript
 /**
  * Delete a transaction locally in the wallet.
  */
 export type DeleteTransactionOp = {
   op: WalletApiOperation.DeleteTransaction;
   request: DeleteTransactionRequest;
   response: EmptyObject;
 };
 // DeleteTransaction = "deleteTransaction"
 
 ```
 ```typescript
 export interface DeleteTransactionRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### RetryTransactionOp
 ```typescript
 /**
  * Immediately retry a transaction.
  */
 export type RetryTransactionOp = {
   op: WalletApiOperation.RetryTransaction;
   request: RetryTransactionRequest;
   response: EmptyObject;
 };
 // RetryTransaction = "retryTransaction"
 
 ```
 ```typescript
 export interface RetryTransactionRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### AbortTransactionOp
 ```typescript
 /**
  * Abort a transaction
  *
  * For payment transactions, it puts the payment into an "aborting" state.
  */
 export type AbortTransactionOp = {
   op: WalletApiOperation.AbortTransaction;
   request: AbortTransactionRequest;
   response: EmptyObject;
 };
 // AbortTransaction = "abortTransaction"
 
 ```
 
 ### FailTransactionOp
 ```typescript
 /**
  * Cancel aborting a transaction
  *
  * For payment transactions, it puts the payment into an "aborting" state.
  */
 export type FailTransactionOp = {
   op: WalletApiOperation.FailTransaction;
   request: FailTransactionRequest;
   response: EmptyObject;
 };
 // FailTransaction = "failTransaction"
 
 ```
 ```typescript
 export interface FailTransactionRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### SuspendTransactionOp
 ```typescript
 /**
  * Suspend a transaction
  */
 export type SuspendTransactionOp = {
   op: WalletApiOperation.SuspendTransaction;
   request: AbortTransactionRequest;
   response: EmptyObject;
 };
 // SuspendTransaction = "suspendTransaction"
 
 ```
 
 ### ResumeTransactionOp
 ```typescript
 /**
  * Resume a transaction
  */
 export type ResumeTransactionOp = {
   op: WalletApiOperation.ResumeTransaction;
   request: AbortTransactionRequest;
   response: EmptyObject;
 };
 // ResumeTransaction = "resumeTransaction"
 
 ```
 
 ### GetWithdrawalDetailsForAmountOp
 ```typescript
 /**
  * Get details for withdrawing a particular amount (manual withdrawal).
  */
 export type GetWithdrawalDetailsForAmountOp = {
   op: WalletApiOperation.GetWithdrawalDetailsForAmount;
   request: GetWithdrawalDetailsForAmountRequest;
   response: WithdrawalDetailsForAmount;
 };
 // GetWithdrawalDetailsForAmount = "getWithdrawalDetailsForAmount"
 
 ```
 ```typescript
 export interface GetWithdrawalDetailsForAmountRequest {
   exchangeBaseUrl?: string;
   /**
    * Specify currency scope for the withdrawal.
    *
    * May only be used when exchangeBaseUrl is not specified.
    */
   restrictScope?: ScopeInfo;
   amount: AmountString;
   restrictAge?: number;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface WithdrawalDetailsForAmount {
   /**
    * Exchange base URL for the withdrawal.
    */
   exchangeBaseUrl: string;
   /**
    * Amount that the user will transfer to the exchange.
    */
   amountRaw: AmountString;
   /**
    * Amount that will be added to the user's wallet balance.
    */
   amountEffective: AmountString;
   /**
    * Number of coins that would be used for withdrawal.
    *
    * The UIs should warn if this number is too high (roughly at >100).
    */
   numCoins: number;
   /**
    * Ways to pay the exchange, including accounts that require currency conversion.
    */
   withdrawalAccountsList: WithdrawalExchangeAccountDetails[];
   /**
    * If the exchange supports age-restricted coins it will return
    * the array of ages.
    */
   ageRestrictionOptions?: number[];
   /**
    * Scope info of the currency withdrawn.
    */
   scopeInfo: ScopeInfo;
   /**
    * KYC soft limit.
    *
    * Withdrawals over that amount will require KYC.
    */
   kycSoftLimit?: AmountString;
   /**
    * KYC soft limits.
    *
    * Withdrawals over that amount will be denied.
    */
   kycHardLimit?: AmountString;
   /**
    * Ways to pay the exchange.
    *
    * @deprecated in favor of withdrawalAccountsList
    */
   paytoUris: string[];
 }
 
 ```
 
 ### GetWithdrawalDetailsForUriOp
 ```typescript
 /**
  * Get details for withdrawing via a particular taler:// URI.
  *
  * @deprecated Use {@link PrepareBankIntegratedWithdrawalOp} instead
  */
 export type GetWithdrawalDetailsForUriOp = {
   op: WalletApiOperation.GetWithdrawalDetailsForUri;
   request: GetWithdrawalDetailsForUriRequest;
   response: WithdrawUriInfoResponse;
 };
 // GetWithdrawalDetailsForUri = "getWithdrawalDetailsForUri"
 
 ```
 ```typescript
 export interface GetWithdrawalDetailsForUriRequest {
   talerWithdrawUri: string;
   /**
    * @deprecated not used
    */
   restrictAge?: number;
   progressToken?: string;
 }
 
 ```
 
 ### PrepareBankIntegratedWithdrawalOp
 ```typescript
 /**
  * Prepare a bank-integrated withdrawal operation.
  */
 export type PrepareBankIntegratedWithdrawalOp = {
   op: WalletApiOperation.PrepareBankIntegratedWithdrawal;
   request: PrepareBankIntegratedWithdrawalRequest;
   response: PrepareBankIntegratedWithdrawalResponse;
 };
 // PrepareBankIntegratedWithdrawal = "prepareBankIntegratedWithdrawal"
 
 ```
 ```typescript
 export interface PrepareBankIntegratedWithdrawalRequest {
   talerWithdrawUri: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface PrepareBankIntegratedWithdrawalResponse {
   transactionId: TransactionIdStr;
   info: WithdrawUriInfoResponse;
 }
 
 ```
 
 ### ConfirmWithdrawalOp
 ```typescript
 /**
  * Confirm a withdrawal transaction.
  */
 export type ConfirmWithdrawalOp = {
   op: WalletApiOperation.ConfirmWithdrawal;
   request: ConfirmWithdrawalRequest;
   response: EmptyObject;
 };
 // ConfirmWithdrawal = "confirmWithdrawal"
 
 ```
 ```typescript
 export interface ConfirmWithdrawalRequest {
   transactionId: string;
   exchangeBaseUrl: string;
   amount?: AmountString | undefined;
   forcedDenomSel?: ForcedDenomSel;
   restrictAge?: number;
   progressToken?: string;
 }
 
 ```
 
 ### AcceptBankIntegratedWithdrawalOp
 ```typescript
 /**
  * Accept a bank-integrated withdrawal.
  *
  * @deprecated in favor of prepare/confirm withdrawal.
  */
 export type AcceptBankIntegratedWithdrawalOp = {
   op: WalletApiOperation.AcceptBankIntegratedWithdrawal;
   request: AcceptBankIntegratedWithdrawalRequest;
   response: AcceptWithdrawalResponse;
 };
 // AcceptBankIntegratedWithdrawal = "acceptBankIntegratedWithdrawal"
 
 ```
 ```typescript
 export interface AcceptBankIntegratedWithdrawalRequest {
   talerWithdrawUri: string;
   exchangeBaseUrl: string;
   forcedDenomSel?: ForcedDenomSel;
   /**
    * Amount to withdraw.
    * If the bank's withdrawal operation uses a fixed amount,
    * this field must either be left undefined or its value must match
    * the amount from the withdrawal operation.
    */
   amount?: AmountString;
   restrictAge?: number;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface AcceptWithdrawalResponse {
   confirmTransferUrl?: string;
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### AcceptManualWithdrawalOp
 ```typescript
 /**
  * Create a manual withdrawal.
  */
 export type AcceptManualWithdrawalOp = {
   op: WalletApiOperation.AcceptManualWithdrawal;
   request: AcceptManualWithdrawalRequest;
   response: AcceptManualWithdrawalResult;
 };
 // AcceptManualWithdrawal = "acceptManualWithdrawal"
 
 ```
 ```typescript
 export interface AcceptManualWithdrawalRequest {
   exchangeBaseUrl: string;
   amount: AmountString;
   restrictAge?: number;
   /**
    * Instead of generating a fresh, random reserve key pair,
    * use the provided reserve private key.
    *
    * Use with caution.  Usage of this field may be restricted
    * to developer mode.
    */
   forceReservePriv?: EddsaPrivateKeyString;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface AcceptManualWithdrawalResult {
   /**
    * Transaction ID of the newly created withdrawal transaction.
    */
   transactionId: TransactionIdStr;
   /**
    * Public key of the newly created reserve.
    */
   reservePub: string;
   /**
    * Bank accounts of the exchange that can be used
    * to fund the withdrawal.
    */
   withdrawalAccountsList: WithdrawalExchangeAccountDetails[];
 }
 
 ```
 
 ### PreparePayForUriOp
 ```typescript
 /**
  * Prepare to make a payment based on a taler://pay/ URI.
  */
 export type PreparePayForUriOp = {
   op: WalletApiOperation.PreparePayForUri;
   request: PreparePayRequest;
   response: PreparePayResult;
 };
 // PreparePayForUri = "preparePayForUri"
 
 ```
 
 ### PreparePayForTemplateOp
 ```typescript
 /**
  * Prepare to make a payment based on a taler://pay-template/ URI.
  */
 export type PreparePayForTemplateOp = {
   op: WalletApiOperation.PreparePayForTemplate;
   request: PreparePayTemplateRequest;
   response: PreparePayResult;
 };
 // PreparePayForTemplate = "preparePayForTemplate"
 
 ```
 
 ### PreparePayForUriV2Op
 ```typescript
 /**
  * Prepare to make a payment based on a taler://pay/ URI.
  */
 export type PreparePayForUriV2Op = {
   op: WalletApiOperation.PreparePayForUriV2;
   request: PreparePayRequest;
   response: PreparePayV2Result;
 };
 // PreparePayForUriV2 = "preparePayForUriV2"
 
 ```
 
 ### PreparePayForTemplateV2Op
 ```typescript
 /**
  * Prepare to make a payment based on a taler://pay-template/ URI.
  */
 export type PreparePayForTemplateV2Op = {
   op: WalletApiOperation.PreparePayForTemplateV2;
   request: PreparePayTemplateRequest;
   response: PreparePayV2Result;
 };
 // PreparePayForTemplateV2 = "preparePayForTemplateV2"
 
 ```
 
 ### GetChoicesForPaymentOp
 ```typescript
 /**
  * Get a list of contract v1 choices for a given payment tx
  * in dialog(confirm) state, as well as additional information
  * on whether they can be used to pay the order or not, depending
  * on the funds available on the wallet, or whether a specific
  * choice should be paid automatically without user confirmation,
  * based on user configuration or the type of payment requested.
  *
  * This request will fail if contract choices are not yet
  * available, in which case the `choicesAvailable' field of the tx
  * will be undefined or set to false.
  */
 export type GetChoicesForPaymentOp = {
   op: WalletApiOperation.GetChoicesForPayment;
   request: GetChoicesForPaymentRequest;
   response: GetChoicesForPaymentResult;
 };
 // GetChoicesForPayment = "getChoicesForPayment"
 
 ```
 ```typescript
 export interface GetChoicesForPaymentRequest {
   transactionId: string;
   forcedCoinSel?: ForcedCoinSel;
 }
 
 ```
 ```typescript
 export type GetChoicesForPaymentResult = {
   /**
    * Details for all choices in the contract.
    *
    * The index in this array corresponds to the choice
    * index in the original contract v1. For contract v0
    * orders, it will only contain a single choice with no
    * inputs/outputs.
    */
   choices: ChoiceSelectionDetail[];
   /**
    * Index of the choice in @e choices array to present
    * to the user as default.
    *
    * Won´t be set if no default selection is configured
    * or no choice is payable, otherwise, it will always
    * be 0 for v0 orders.
    */
   defaultChoiceIndex?: number;
   /**
    * Whether the choice referenced by @e automaticExecutableIndex
    * should be confirmed automatically without
    * user interaction.
    *
    * If true, the wallet should call `confirmPay'
    * immediately afterwards, if false, the user
    * should be first prompted to select and
    * confirm a choice. Undefined when no choices
    * are payable.
    */
   automaticExecution?: boolean;
   /**
    * Index of the choice that would be set to automatically
    * execute if the choice was payable. When @e automaticExecution
    * is set to true, the payment should be confirmed with this
    * choice index without user interaction.
    */
   automaticExecutableIndex?: number;
   /**
    * Data extracted from the contract terms that
    * is relevant for payment processing in the wallet.
    */
   contractTerms: MerchantContractTerms;
 };
 
 ```
 ```typescript
 export type ChoiceSelectionDetail =
   | ChoiceSelectionDetailPaymentPossible
   | ChoiceSelectionDetailInsufficientBalance;
 
 ```
 ```typescript
 export interface ChoiceSelectionDetailPaymentPossible {
   status: ChoiceSelectionDetailType.PaymentPossible;
   amountRaw: AmountString;
   amountEffective: AmountString;
   scopeInfo: ScopeInfo | undefined;
   tokenDetails?: PaymentTokenAvailabilityDetails;
 }
 
 ```
 ```typescript
 export interface PaymentTokenAvailabilityDetails {
   /**
    * Number of tokens requested by the merchant.
    */
   tokensRequested: number;
   /**
    * Number of tokens available to use.
    */
   tokensAvailable: number;
   /**
    * Number of tokens for which the merchant is unexpected.
    *
    * Can be used to pay (i.e. with forced selection),
    * but a warning should be displayed to the user.
    */
   tokensUnexpected: number;
   /**
    * Number of tokens for which the merchant is untrusted.
    *
    * Cannot be used to pay, so an error should be displayed.
    */
   tokensUntrusted: number;
   perTokenFamily: {
     [slug: string]: {
       causeHint?: TokenAvailabilityHint;
       requested: number;
       available: number;
       unexpected: number;
       untrusted: number;
     };
   };
 }
 
 ```
 ```typescript
 export declare enum TokenAvailabilityHint {
   WalletTokensAvailableInsufficient = "wallet-tokens-available-insufficient",
   MerchantUnexpected = "merchant-unexpected",
   MerchantUntrusted = "merchant-untrusted",
 }
 
 ```
 ```typescript
 export interface ChoiceSelectionDetailInsufficientBalance {
   status: ChoiceSelectionDetailType.InsufficientBalance;
   amountRaw: AmountString;
   balanceDetails?: PaymentInsufficientBalanceDetails;
   tokenDetails?: PaymentTokenAvailabilityDetails;
 }
 
 ```
 
 ### SharePaymentOp
 ```typescript
 export type SharePaymentOp = {
   op: WalletApiOperation.SharePayment;
   request: SharePaymentRequest;
   response: SharePaymentResult;
 };
 // SharePayment = "sharePayment"
 
 ```
 ```typescript
 export interface SharePaymentRequest {
   merchantBaseUrl: string;
   orderId: string;
 }
 
 ```
 ```typescript
 export interface SharePaymentResult {
   privatePayUri: string;
 }
 
 ```
 
 ### CheckPayForTemplateOp
 ```typescript
 export type CheckPayForTemplateOp = {
   op: WalletApiOperation.CheckPayForTemplate;
   request: CheckPayTemplateRequest;
   response: CheckPayTemplateReponse;
 };
 // CheckPayForTemplate = "checkPayForTemplate"
 
 ```
 ```typescript
 export interface CheckPayTemplateRequest {
   talerPayTemplateUri: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export type CheckPayTemplateReponse = {
   templateDetails: WalletTemplateDetailsResponse;
   supportedCurrencies: string[];
 };
 
 ```
 ```typescript
 export interface WalletTemplateDetailsResponse {
   template_contract: TemplateContractDetails;
   editable_defaults?: TemplateContractDetailsDefaults;
   required_currency?: string;
 }
 
 ```
 ```typescript
 export type TemplateContractDetails =
   | TemplateContractFixedOrder
   | TemplateContractInventoryCart
   | TemplateContractPaivana;
 
 ```
 ```typescript
 export interface TemplateContractFixedOrder extends TemplateContractCommon {
   template_type: TemplateType.FIXED_ORDER;
   amount?: AmountString;
 }
 
 ```
 ```typescript
 export interface TemplateContractCommon {
   summary?: string;
   currency?: string;
   pay_duration?: RelativeTime;
   max_pickup_duration?: RelativeTime;
   minimum_age?: Integer;
   request_tip?: boolean;
 }
 
 ```
 ```typescript
 export interface TemplateContractInventoryCart extends TemplateContractCommon {
   template_type: TemplateType.INVENTORY_CART;
   selected_all?: boolean;
   selected_categories?: Integer[];
   selected_products?: string[];
   choose_one?: boolean;
   inventory_payload?: InventoryPayload;
 }
 
 ```
 ```typescript
 export interface InventoryPayload {
   products: InventoryPayloadProduct[];
   categories: InventoryPayloadCategory[];
   units: InventoryPayloadUnit[];
 }
 
 ```
 ```typescript
 export interface InventoryPayloadProduct {
   product_id: string;
   product_name: string;
   description: string;
   description_i18n?: {
     [lang_tag: string]: string;
   };
   unit: string;
   unit_prices: AmountString[];
   unit_allow_fraction: boolean;
   unit_precision_level: Integer;
   remaining_stock: DecimalQuantity;
   categories: Integer[];
   taxes?: Tax[];
   image_hash?: string;
 }
 
 ```
 ```typescript
 export interface InventoryPayloadCategory {
   category_id: Integer;
   category_name: string;
   category_name_i18n?: {
     [lang_tag: string]: string;
   };
 }
 
 ```
 ```typescript
 export interface InventoryPayloadUnit {
   unit: string;
   unit_name_long: string;
   unit_name_long_i18n?: {
     [lang_tag: string]: string;
   };
   unit_name_short: string;
   unit_name_short_i18n?: {
     [lang_tag: string]: string;
   };
   unit_allow_fraction: boolean;
   unit_precision_level: Integer;
 }
 
 ```
 ```typescript
 export interface TemplateContractPaivana extends TemplateContractCommon {
   template_type: TemplateType.PAIVANA;
   website_regex?: string;
   choices: OrderChoice[];
 }
 
 ```
 ```typescript
 export interface OrderChoice {
   amount: AmountString;
   description?: string;
   description_i18n?: InternationalizedString;
   inputs?: OrderInput[];
   outputs?: OrderOutput[];
   max_fee?: AmountString;
 }
 
 ```
 ```typescript
 export interface OrderInputToken {
   type: OrderInputType.Token;
   token_family_slug: string;
   count?: Integer;
 }
 
 ```
 ```typescript
 export type OrderOutput = OrderOutputToken | OrderOutputTaxReceipt;
 
 ```
 ```typescript
 export interface OrderOutputToken {
   type: OrderOutputType.Token;
   token_family_slug: string;
   count?: Integer;
   valid_at?: TalerProtocolTimestamp;
 }
 
 ```
 ```typescript
 export interface OrderOutputTaxReceipt {
   type: OrderOutputType.TaxReceipt;
   amount?: AmountString;
   donau_urls: string[];
 }
 
 ```
 ```typescript
 /**
  * Key-value pairs matching a subset of the
  * fields from template_contract that are
  * user-editable defaults for this template.
  * Since protocol **v13**.
  */
 export interface TemplateContractDetailsDefaults {
   summary?: string;
   currency?: string;
   /**
    * Amount *or* a plain currency string.
    */
   amount?: string;
 }
 
 ```
 
 ### ConfirmPayOp
 ```typescript
 /**
  * Confirm a payment that was previously prepared with
  * {@link PreparePayForUriOp}
  */
 export type ConfirmPayOp = {
   op: WalletApiOperation.ConfirmPay;
   request: ConfirmPayRequest;
   response: ConfirmPayResult;
 };
 // ConfirmPay = "confirmPay"
 
 ```
 ```typescript
 export interface ConfirmPayRequest {
   transactionId: TransactionIdStr;
   useDonau?: boolean;
   sessionId?: string;
   forcedCoinSel?: ForcedCoinSel;
   /**
    * Whether token selection should be forced
    * e.g. use tokens with non-matching `expected_domains'
    *
    * Only applies to v1 orders.
    */
   forcedTokenSel?: boolean;
   /**
    * Only applies to v1 orders.
    */
   choiceIndex?: number;
   /**
    * Do not wait for the first payment success or error
    * before returning a response. Instead, status will
    * be communicated via notifications.
    *
    * Will become the default in future versions.
    */
   noWait?: boolean;
 }
 
 ```
 ```typescript
 export type ConfirmPayResult = ConfirmPayResultDone | ConfirmPayResultPending;
 
 ```
 ```typescript
 /**
  * Result for confirmPay
  */
 export interface ConfirmPayResultDone {
   type: ConfirmPayResultType.Done;
   contractTerms: MerchantContractTermsV0;
   transactionId: TransactionIdStr;
 }
 
 ```
 ```typescript
 export interface ConfirmPayResultPending {
   type: ConfirmPayResultType.Pending;
   transactionId: TransactionIdStr;
   lastError?: TalerErrorDetail | undefined;
 }
 
 ```
 
 ### StartRefundQueryForUriOp
 ```typescript
 /**
  * Check for a refund based on a taler://refund URI.
  */
 export type StartRefundQueryForUriOp = {
   op: WalletApiOperation.StartRefundQueryForUri;
   request: PrepareRefundRequest;
   response: StartRefundQueryForUriResponse;
 };
 // StartRefundQueryForUri = "startRefundQueryForUri"
 
 ```
 ```typescript
 export interface PrepareRefundRequest {
   talerRefundUri: string;
 }
 
 ```
 ```typescript
 export interface StartRefundQueryForUriResponse {
   /**
    * Transaction id of the *payment* where the refund query was started.
    */
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### StartRefundQueryOp
 ```typescript
 export type StartRefundQueryOp = {
   op: WalletApiOperation.StartRefundQuery;
   request: StartRefundQueryRequest;
   response: EmptyObject;
 };
 // StartRefundQuery = "startRefundQuery"
 
 ```
 ```typescript
 export interface StartRefundQueryRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### ListDiscountsOp
 ```typescript
 /**
  * List discount tokens stored in the wallet. Listed tokens
  * will be grouped based on token family details.
  */
 export type ListDiscountsOp = {
   op: WalletApiOperation.ListDiscounts;
   request: ListDiscountsRequest;
   response: ListDiscountsResponse;
 };
 // ListDiscounts = "listDiscounts"
 
 ```
 ```typescript
 export interface ListDiscountsResponse {
   discounts: DiscountListDetail[];
 }
 
 ```
 
 ### DeleteDiscountOp
 ```typescript
 export type DeleteDiscountOp = {
   op: WalletApiOperation.DeleteDiscount;
   request: DeleteDiscountRequest;
   response: EmptyObject;
 };
 // DeleteDiscount = "deleteDiscount"
 
 ```
 ```typescript
 export interface DeleteDiscountRequest {
   /**
    * Hash of token family info.
    */
   tokenFamilyHash: string;
 }
 
 ```
 
 ### ListSubscriptionsOp
 ```typescript
 /**
  * List subscription tokens stored in the wallet. Listed tokens
  * will be grouped based on token family details.
  */
 export type ListSubscriptionsOp = {
   op: WalletApiOperation.ListSubscriptions;
   request: ListSubscriptionsRequest;
   response: ListSubscriptionsResponse;
 };
 // ListSubscriptions = "listSubscriptions"
 
 ```
 ```typescript
 export interface ListSubscriptionsResponse {
   subscriptions: SubscriptionListDetail[];
 }
 
 ```
 ```typescript
 export type SubscriptionListDetail = Omit<
   DiscountListDetail,
   "tokensAvailable"
 >;
 
 ```
 
 ### DeleteSubscriptionOp
 ```typescript
 export type DeleteSubscriptionOp = {
   op: WalletApiOperation.DeleteSubscription;
   request: DeleteSubscriptionRequest;
   response: EmptyObject;
 };
 // DeleteSubscription = "deleteSubscription"
 
 ```
 ```typescript
 export interface DeleteSubscriptionRequest {
   /**
    * Hash of token family info.
    */
   tokenFamilyHash: string;
 }
 
 ```
 
 ### ListGlobalCurrencyAuditorsOp
 ```typescript
 export type ListGlobalCurrencyAuditorsOp = {
   op: WalletApiOperation.ListGlobalCurrencyAuditors;
   request: EmptyObject;
   response: ListGlobalCurrencyAuditorsResponse;
 };
 // ListGlobalCurrencyAuditors = "listGlobalCurrencyAuditors"
 
 ```
 ```typescript
 export interface ListGlobalCurrencyAuditorsResponse {
   auditors: {
     currency: string;
     auditorBaseUrl: string;
     auditorPub: string;
   }[];
 }
 
 ```
 
 ### ListGlobalCurrencyExchangesOp
 ```typescript
 export type ListGlobalCurrencyExchangesOp = {
   op: WalletApiOperation.ListGlobalCurrencyExchanges;
   request: EmptyObject;
   response: ListGlobalCurrencyExchangesResponse;
 };
 // ListGlobalCurrencyExchanges = "listGlobalCurrencyExchanges"
 
 ```
 ```typescript
 export interface ListGlobalCurrencyExchangesResponse {
   exchanges: {
     currency: string;
     exchangeBaseUrl: string;
     exchangeMasterPub: string;
   }[];
 }
 
 ```
 
 ### AddGlobalCurrencyExchangeOp
 ```typescript
 export type AddGlobalCurrencyExchangeOp = {
   op: WalletApiOperation.AddGlobalCurrencyExchange;
   request: AddGlobalCurrencyExchangeRequest;
   response: EmptyObject;
 };
 // AddGlobalCurrencyExchange = "addGlobalCurrencyExchange"
 
 ```
 ```typescript
 export interface AddGlobalCurrencyExchangeRequest {
   currency: string;
   exchangeBaseUrl: string;
   exchangeMasterPub: string;
 }
 
 ```
 
 ### AddGlobalCurrencyAuditorOp
 ```typescript
 export type AddGlobalCurrencyAuditorOp = {
   op: WalletApiOperation.AddGlobalCurrencyAuditor;
   request: AddGlobalCurrencyAuditorRequest;
   response: EmptyObject;
 };
 // AddGlobalCurrencyAuditor = "addGlobalCurrencyAuditor"
 
 ```
 ```typescript
 export interface AddGlobalCurrencyAuditorRequest {
   currency: string;
   auditorBaseUrl: string;
   auditorPub: string;
 }
 
 ```
 
 ### RemoveGlobalCurrencyExchangeOp
 ```typescript
 export type RemoveGlobalCurrencyExchangeOp = {
   op: WalletApiOperation.RemoveGlobalCurrencyExchange;
   request: RemoveGlobalCurrencyExchangeRequest;
   response: EmptyObject;
 };
 // RemoveGlobalCurrencyExchange = "removeGlobalCurrencyExchange"
 
 ```
 ```typescript
 export interface RemoveGlobalCurrencyExchangeRequest {
   currency: string;
   exchangeBaseUrl: string;
   exchangeMasterPub: string;
 }
 
 ```
 
 ### RemoveGlobalCurrencyAuditorOp
 ```typescript
 export type RemoveGlobalCurrencyAuditorOp = {
   op: WalletApiOperation.RemoveGlobalCurrencyAuditor;
   request: RemoveGlobalCurrencyAuditorRequest;
   response: EmptyObject;
 };
 // RemoveGlobalCurrencyAuditor = "removeGlobalCurrencyAuditor"
 
 ```
 ```typescript
 export interface RemoveGlobalCurrencyAuditorRequest {
   currency: string;
   auditorBaseUrl: string;
   auditorPub: string;
 }
 
 ```
 
 ### CompleteExchangeBaseUrlOp
 ```typescript
 /**
  * Force a refresh on coins where it would not
  * be necessary.
  */
 export type CompleteExchangeBaseUrlOp = {
   op: WalletApiOperation.CompleteExchangeBaseUrl;
   request: CompleteBaseUrlRequest;
   response: CompleteBaseUrlResult;
 };
 // CompleteExchangeBaseUrl = "completeExchangeBaseUrl"
 
 ```
 ```typescript
 export interface CompleteBaseUrlRequest {
   url: string;
 }
 
 ```
 ```typescript
 export type CompleteBaseUrlResult =
   | {
       /**
        * ok: completion is a proper exchange
        */
       status: "ok";
       /** Completed exchange base URL, if completion was possible */
       completion: string;
     }
   | {
       /**
        * bad-syntax: url is so badly malformed, it can't be completed
        * bad-network: syntax okay, but exchange can't be reached
        * bad-exchange: syntax and network okay, but not talking to an exchange
        */
       status: "bad-syntax" | "bad-network" | "bad-exchange";
       /** Error details in case status is not "ok" */
       error: TalerErrorDetail;
     };
 
 ```
 
 ### ListExchangesOp
 ```typescript
 /**
  * List exchanges known to the wallet.
  */
 export type ListExchangesOp = {
   op: WalletApiOperation.ListExchanges;
   request: ListExchangesRequest;
   response: ExchangesListResponse;
 };
 // ListExchanges = "listExchanges"
 
 ```
 ```typescript
 export interface ListExchangesRequest {
   /**
    * Filter results to only include exchanges in the given scope.
    */
   filterByScope?: ScopeInfo;
   /**
    * Filter results to only include exchanges
    * with the given status.
    */
   filterByExchangeEntryStatus?: ExchangeEntryStatus;
   /**
    * Filter results to only include exchanges with the
    * given type.
    */
   filterByType?: ExchangeType;
 }
 
 ```
 ```typescript
 export type ExchangeType = "demo" | "prod";
 
 ```
 ```typescript
 export interface ExchangesListResponse {
   exchanges: ExchangeListItem[];
 }
 
 ```
 
 ### StartExchangeWalletKycOp
 ```typescript
 export type StartExchangeWalletKycOp = {
   op: WalletApiOperation.StartExchangeWalletKyc;
   request: StartExchangeWalletKycRequest;
   response: EmptyObject;
 };
 // StartExchangeWalletKyc = "startExchangeWalletKyc"
 
 ```
 ```typescript
 export interface StartExchangeWalletKycRequest {
   exchangeBaseUrl: string;
   amount: AmountString;
 }
 
 ```
 
 ### TestingWaitExchangeWalletKycOp
 ```typescript
 export type TestingWaitExchangeWalletKycOp = {
   op: WalletApiOperation.TestingWaitExchangeWalletKyc;
   request: TestingWaitWalletKycRequest;
   response: EmptyObject;
 };
 // TestingWaitExchangeWalletKyc = "testingWaitWalletKyc"
 
 ```
 ```typescript
 export interface TestingWaitWalletKycRequest {
   exchangeBaseUrl: string;
   amount: AmountString;
   /**
    * Do we wait for the KYC to be passed (true),
    * or do we already return if legitimization is
    * required (false).
    */
   passed: boolean;
 }
 
 ```
 
 ### TestingPlanMigrateExchangeBaseUrlOp
 ```typescript
 /**
  * Enable migration from an old exchange base URL to a new
  * exchange base URL.
  *
  * The actual migration is only applied once the exchange
  * returns the new base URL.
  */
 export type TestingPlanMigrateExchangeBaseUrlOp = {
   op: WalletApiOperation.TestingPlanMigrateExchangeBaseUrl;
   request: TestingPlanMigrateExchangeBaseUrlRequest;
   response: EmptyObject;
 };
 // TestingPlanMigrateExchangeBaseUrl = "testingPlanMigrateExchangeBaseUrl"
 
 ```
 ```typescript
 export interface TestingPlanMigrateExchangeBaseUrlRequest {
   oldExchangeBaseUrl: string;
   newExchangeBaseUrl: string;
 }
 
 ```
 
 ### PrepareWithdrawExchangeOp
 ```typescript
 /**
  * Prepare for withdrawing via a taler://withdraw-exchange URI.
  */
 export type PrepareWithdrawExchangeOp = {
   op: WalletApiOperation.PrepareWithdrawExchange;
   request: PrepareWithdrawExchangeRequest;
   response: PrepareWithdrawExchangeResponse;
 };
 // PrepareWithdrawExchange = "prepareWithdrawExchange"
 
 ```
 ```typescript
 export interface PrepareWithdrawExchangeRequest {
   /**
    * A taler://withdraw-exchange URI.
    */
   talerUri: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface PrepareWithdrawExchangeResponse {
   /**
    * Base URL of the exchange that already existed
    * or was ephemerally added as an exchange entry to
    * the wallet.
    */
   exchangeBaseUrl: string;
   /**
    * Amount from the taler://withdraw-exchange URI.
    * Only present if specified in the URI.
    */
   amount?: AmountString;
 }
 
 ```
 
 ### AddExchangeOp
 ```typescript
 /**
  * Add / force-update an exchange.
  */
 export type AddExchangeOp = {
   op: WalletApiOperation.AddExchange;
   request: AddExchangeRequest;
   response: AddExchangeResponse;
 };
 // AddExchange = "addExchange"
 
 ```
 ```typescript
 export interface AddExchangeRequest {
   /**
    * Either an http(s) exchange base URL or
    * a taler://add-exchange/ URI.
    */
   uri?: string;
   /**
    * Only ephemerally add the exchange.
    */
   ephemeral?: boolean;
   /**
    * Allow passing incomplete URLs.  The wallet will try to complete
    * the URL and throw an error if completion is not possible.
    */
   allowCompletion?: boolean;
   /**
    * @deprecated use a separate API call to start a forced exchange update instead
    */
   forceUpdate?: boolean;
   /**
    * @deprecated Use {@link uri} instead
    */
   exchangeBaseUrl?: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface AddExchangeResponse {
   /**
    * Base URL of the exchange that was added to the wallet.
    */
   exchangeBaseUrl: string;
 }
 
 ```
 
 ### UpdateExchangeEntryOp
 ```typescript
 /**
  * Update an exchange entry.
  *
  * Only starts updating the exchange entry.
  * After this request finishes, it is not guaranteed that
  * the exchange entry has been updated.
  *
  * Use notifications and the listExchanges request
  * to check the status.
  */
 export type UpdateExchangeEntryOp = {
   op: WalletApiOperation.UpdateExchangeEntry;
   request: UpdateExchangeEntryRequest;
   response: EmptyObject;
 };
 // UpdateExchangeEntry = "updateExchangeEntry"
 
 ```
 ```typescript
 export interface UpdateExchangeEntryRequest {
   exchangeBaseUrl: string;
   force?: boolean;
 }
 
 ```
 
 ### ListBankAccountsOp
 ```typescript
 export type ListBankAccountsOp = {
   op: WalletApiOperation.ListBankAccounts;
   request: ListBankAccountsRequest;
   response: ListBankAccountsResponse;
 };
 // ListBankAccounts = "listBankAccounts"
 
 ```
 ```typescript
 export interface ListBankAccountsRequest {
   currency?: string;
 }
 
 ```
 ```typescript
 export interface ListBankAccountsResponse {
   accounts: WalletBankAccountInfo[];
 }
 
 ```
 
 ### GetBankAccountByIdOp
 ```typescript
 export type GetBankAccountByIdOp = {
   op: WalletApiOperation.GetBankAccountById;
   request: GetBankAccountByIdRequest;
   response: GetBankAccountByIdResponse;
 };
 // GetBankAccountById = "getBankAccountById"
 
 ```
 ```typescript
 export interface GetBankAccountByIdRequest {
   bankAccountId: string;
 }
 
 ```
 
 ### AddBankAccountsOp
 ```typescript
 export type AddBankAccountsOp = {
   op: WalletApiOperation.AddBankAccount;
   request: AddBankAccountRequest;
   response: AddBankAccountResponse;
 };
 // AddBankAccount = "addBankAccount"
 
 ```
 ```typescript
 export interface AddBankAccountRequest {
   /**
    * Payto URI of the bank account that should be added.
    */
   paytoUri: string;
   /**
    * Human-readable label for the account.
    */
   label: string;
   /**
    * Currencies supported by the bank (if known).
    */
   currencies?: string[] | undefined;
   /**
    * Bank account that this new account should replace.
    */
   replaceBankAccountId?: string;
 }
 
 ```
 ```typescript
 export interface AddBankAccountResponse {
   /**
    * Identifier of the added bank account.
    */
   bankAccountId: string;
 }
 
 ```
 
 ### ForgetBankAccountsOp
 ```typescript
 export type ForgetBankAccountsOp = {
   op: WalletApiOperation.ForgetBankAccount;
   request: ForgetBankAccountRequest;
   response: EmptyObject;
 };
 // ForgetBankAccount = "forgetBankAccount"
 
 ```
 ```typescript
 export interface ForgetBankAccountRequest {
   bankAccountId: string;
 }
 
 ```
 
 ### SetExchangeTosAcceptedOp
 ```typescript
 /**
  * Accept a particular version of the exchange terms of service.
  */
 export type SetExchangeTosAcceptedOp = {
   op: WalletApiOperation.SetExchangeTosAccepted;
   request: AcceptExchangeTosRequest;
   response: EmptyObject;
 };
 // SetExchangeTosAccepted = "setExchangeTosAccepted"
 
 ```
 
 ### SetExchangeTosForgottenOp
 ```typescript
 /**
  * Accept a particular version of the exchange terms of service.
  */
 export type SetExchangeTosForgottenOp = {
   op: WalletApiOperation.SetExchangeTosForgotten;
   request: AcceptExchangeTosRequest;
   response: EmptyObject;
 };
 // SetExchangeTosForgotten = "setExchangeTosForgotten"
 
 ```
 
 ### GetExchangeTosOp
 ```typescript
 /**
  * Get the current terms of a service of an exchange.
  */
 export type GetExchangeTosOp = {
   op: WalletApiOperation.GetExchangeTos;
   request: GetExchangeTosRequest;
   response: GetExchangeTosResult;
 };
 // GetExchangeTos = "getExchangeTos"
 
 ```
 ```typescript
 export interface GetExchangeTosRequest {
   exchangeBaseUrl: string;
   acceptedFormat?: string[];
   acceptLanguage?: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface GetExchangeTosResult {
   /**
    * Markdown version of the current ToS.
    */
   content: string;
   /**
    * Version tag of the current ToS.
    */
   currentEtag: string;
   /**
    * Version tag of the last ToS that the user has accepted,
    * if any.
    */
   acceptedEtag: string | undefined;
   /**
    * Accepted content type
    */
   contentType: string;
   /**
    * Language of the returned content.
    *
    * If missing, language is unknown.
    */
   contentLanguage: string | undefined;
   /**
    * Available languages as advertised by the exchange.
    */
   tosAvailableLanguages: string[];
   tosStatus: ExchangeTosStatus;
 }
 
 ```
 
 ### GetDepositWireTypesOp
 ```typescript
 export type GetDepositWireTypesOp = {
   op: WalletApiOperation.GetDepositWireTypes;
   request: GetDepositWireTypesRequest;
   response: GetDepositWireTypesResponse;
 };
 // GetDepositWireTypes = "getDepositWireTypes"
 
 ```
 ```typescript
 export interface GetDepositWireTypesRequest {
   currency?: string;
   /**
    * Optional scope info to further restrict the result.
    * Currency must match the currency field.
    */
   scopeInfo?: ScopeInfo;
 }
 
 ```
 ```typescript
 export interface GetDepositWireTypesResponse {
   /**
    * Details for each wire type.
    */
   wireTypeDetails: WireTypeDetails[];
 }
 
 ```
 
 ### GetDepositWireTypesForCurrencyOp
 ```typescript
 /**
  * Get wire types that can be used for a deposit operation
  * with the provided currency.
  *
  * @deprecated Use getDepositWireTypes instead
  */
 export type GetDepositWireTypesForCurrencyOp = {
   op: WalletApiOperation.GetDepositWireTypesForCurrency;
   request: GetDepositWireTypesForCurrencyRequest;
   response: GetDepositWireTypesForCurrencyResponse;
 };
 // GetDepositWireTypesForCurrency = "getDepositWireTypesForCurrency"
 
 ```
 ```typescript
 export interface GetDepositWireTypesForCurrencyRequest {
   currency: string;
   /**
    * Optional scope info to further restrict the result.
    * Currency must match the currency field.
    */
   scopeInfo?: ScopeInfo;
 }
 
 ```
 ```typescript
 /**
  * Response with wire types that are supported for a deposit.
  *
  * In the future, we might surface more information here, such as debit restrictions
  * by the exchange, which then can be shown by UIs to the user before they
  * enter their payment information.
  */
 export interface GetDepositWireTypesForCurrencyResponse {
   /**
    * @deprecated, use wireTypeDetails instead.
    */
   wireTypes: string[];
   /**
    * Details for each wire type.
    */
   wireTypeDetails: WireTypeDetails[];
 }
 
 ```
 
 ### GetExchangeDetailedInfoOp
 ```typescript
 /**
  * Get the current terms of a service of an exchange.
  */
 export type GetExchangeDetailedInfoOp = {
   op: WalletApiOperation.GetExchangeDetailedInfo;
   request: GetExchangeDetailedInfoRequest;
   response: ExchangeDetailedResponse;
 };
 // GetExchangeDetailedInfo = "getExchangeDetailedInfo"
 
 ```
 ```typescript
 export interface GetExchangeDetailedInfoRequest {
   exchangeBaseUrl: string;
 }
 
 ```
 ```typescript
 export interface ExchangeDetailedResponse {
   exchange: ExchangeFullDetails;
 }
 
 ```
 ```typescript
 export interface ExchangeFullDetails {
   exchangeBaseUrl: string;
   currency: string;
   paytoUris: string[];
   auditors: ExchangeAuditor[];
   wireInfo: WireInfo;
   denomFees: DenomOperationMap<FeeDescription[]>;
   transferFees: Record<string, FeeDescription[]>;
   globalFees: FeeDescription[];
 }
 
 ```
 ```typescript
 /**
  * Auditor information as given by the exchange in /keys.
  */
 export interface ExchangeAuditor {
   /**
    * Auditor's public key.
    */
   auditor_pub: string;
   /**
    * Base URL of the auditor.
    */
   auditor_url: string;
   /**
    * List of signatures for denominations by the auditor.
    */
   denomination_keys: AuditorDenomSig[];
 }
 
 ```
 ```typescript
 /**
  * Signature by the auditor that a particular denomination key is audited.
  */
 export interface AuditorDenomSig {
   /**
    * Denomination public key's hash.
    */
   denom_pub_h: string;
   /**
    * The signature.
    */
   auditor_sig: string;
 }
 
 ```
 ```typescript
 export interface WireInfo {
   feesForType: WireFeeMap;
   accounts: ExchangeWireAccount[];
 }
 
 ```
 ```typescript
 export type WireFeeMap = {
   [wireMethod: string]: WireFee[];
 };
 
 ```
 ```typescript
 /**
  * Wire fee for one wire method
  */
 export interface WireFee {
   /**
    * Fee for wire transfers.
    */
   wireFee: AmountString;
   /**
    * Fees to close and refund a reserve.
    */
   closingFee: AmountString;
   /**
    * Start date of the fee.
    */
   startStamp: TalerProtocolTimestamp;
   /**
    * End date of the fee.
    */
   endStamp: TalerProtocolTimestamp;
   /**
    * Signature made by the exchange master key.
    */
   sig: string;
 }
 
 ```
 ```typescript
 export interface ExchangeWireAccount {
   payto_uri: string;
   conversion_url?: string;
   open_banking_gateway?: string;
   prepared_transfer_url?: string;
   credit_restrictions: AccountRestriction[];
   debit_restrictions: AccountRestriction[];
   master_sig: EddsaSignatureString;
   bank_label?: string;
   priority?: number;
 }
 
 ```
 ```typescript
 export type DenomOperationMap<T> = {
   [op in DenomOperation]: T;
 };
 
 ```
 ```typescript
 export type DenomOperation = "deposit" | "withdraw" | "refresh" | "refund";
 
 ```
 ```typescript
 export interface FeeDescription {
   group: string;
   from: AbsoluteTime;
   until: AbsoluteTime;
   fee?: AmountString;
 }
 
 ```
 
 ### GetDefaultExchangesOp
 ```typescript
 /**
  * Get the current terms of a service of an exchange.
  */
 export type GetDefaultExchangesOp = {
   op: WalletApiOperation.GetDefaultExchanges;
   request: EmptyObject;
   response: GetDefaultExchangesResponse;
 };
 // GetDefaultExchanges = "getDefaultExchanges"
 
 ```
 ```typescript
 export interface GetDefaultExchangesResponse {
   defaultExchanges: {
     /**
      * A taler://withdraw-exchange URI for the
      * exchange.
      */
     talerUri: string;
     /**
      * Currency offered by the exchange.
      */
     currency: string;
     /**
      * Currency spec for the currency offered
      * by the exchange.
      */
     currencySpec: CurrencySpecification;
   }[];
 }
 
 ```
 
 ### GetExchangeEntryByUrlOp
 ```typescript
 /**
  * Get the current terms of a service of an exchange.
  */
 export type GetExchangeEntryByUrlOp = {
   op: WalletApiOperation.GetExchangeEntryByUrl;
   request: GetExchangeEntryByUrlRequest;
   response: GetExchangeEntryByUrlResponse;
 };
 // GetExchangeEntryByUrl = "getExchangeEntryByUrl"
 
 ```
 ```typescript
 export interface GetExchangeEntryByUrlRequest {
   exchangeBaseUrl: string;
 }
 
 ```
 
 ### GetExchangeResourcesOp
 ```typescript
 /**
  * Get resources associated with an exchange.
  */
 export type GetExchangeResourcesOp = {
   op: WalletApiOperation.GetExchangeResources;
   request: GetExchangeResourcesRequest;
   response: GetExchangeResourcesResponse;
 };
 // GetExchangeResources = "getExchangeResources"
 
 ```
 ```typescript
 export interface GetExchangeResourcesRequest {
   exchangeBaseUrl: string;
 }
 
 ```
 ```typescript
 export interface GetExchangeResourcesResponse {
   hasResources: boolean;
 }
 
 ```
 
 ### DeleteExchangeOp
 ```typescript
 /**
  * Get resources associated with an exchange.
  */
 export type DeleteExchangeOp = {
   op: WalletApiOperation.GetExchangeResources;
   request: DeleteExchangeRequest;
   response: EmptyObject;
 };
 // GetExchangeResources = "getExchangeResources"
 
 ```
 ```typescript
 export interface DeleteExchangeRequest {
   exchangeBaseUrl: string;
   /**
    * Delete the exchange even if it's in use.
    */
   purge?: boolean;
 }
 
 ```
 
 ### GetCurrencySpecificationOp
 ```typescript
 export type GetCurrencySpecificationOp = {
   op: WalletApiOperation.GetCurrencySpecification;
   request: GetCurrencySpecificationRequest;
   response: GetCurrencySpecificationResponse;
 };
 // GetCurrencySpecification = "getCurrencySpecification"
 
 ```
 ```typescript
 export interface GetCurrencySpecificationRequest {
   scope: ScopeInfo;
 }
 
 ```
 ```typescript
 export interface GetCurrencySpecificationResponse {
   currencySpecification: CurrencySpecification;
 }
 
 ```
 
 ### CreateDepositGroupOp
 ```typescript
 /**
  * Create a new deposit group.
  *
  * Deposit groups are used to deposit multiple coins to a bank
  * account, usually the wallet user's own bank account.
  */
 export type CreateDepositGroupOp = {
   op: WalletApiOperation.CreateDepositGroup;
   request: CreateDepositGroupRequest;
   response: CreateDepositGroupResponse;
 };
 // CreateDepositGroup = "createDepositGroup"
 
 ```
 ```typescript
 export interface CreateDepositGroupRequest {
   depositPaytoUri: string;
   /**
    * Amount to deposit (effective amount).
    */
   amount: AmountString;
   /**
    * Restrict the deposit to a certain scope.
    */
   restrictScope?: ScopeInfo;
   /**
    * Use a fixed merchant private key.
    */
   testingFixedPriv?: string;
   /**
    * Optional wire deadline for the deposits.
    */
   wireDeadline?: TalerProtocolTimestamp;
   /**
    * Pre-allocated transaction ID.
    * Allows clients to easily handle notifications
    * that occur while the operation has been created but
    * before the creation request has returned.
    */
   transactionId?: TransactionIdStr;
   progressToken?: string;
 }
 
 ```
 ```typescript
 /**
  * Response to a createDepositGroup request.
  */
 export interface CreateDepositGroupResponse {
   /**
    * Transaction ID of the newly created deposit transaction.
    */
   transactionId: TransactionIdStr;
   /**
    * Current state of the new deposit transaction.
    * Returned as a performance optimization, so that the UI
    * doesn't have to do a separate getTransactionById.
    */
   txState: TransactionState;
   /**
    * @deprecated 2025-06-03, use transactionId instead.
    */
   depositGroupId: string;
 }
 
 ```
 
 ### CheckDepositOp
 ```typescript
 export type CheckDepositOp = {
   op: WalletApiOperation.CheckDeposit;
   request: CheckDepositRequest;
   response: CheckDepositResponse;
 };
 // CheckDeposit = "checkDeposit"
 
 ```
 ```typescript
 export interface CheckDepositRequest {
   /**
    * Payto URI to identify the (bank) account that the exchange will wire
    * the money to.
    */
   depositPaytoUri: string;
   /**
    * Amount that should be deposited.
    *
    * Raw amount, fees will be added on top.
    */
   amount: AmountString;
   /**
    * Restrict the deposit to a certain scope.
    */
   restrictScope?: ScopeInfo;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface CheckDepositResponse {
   totalDepositCost: AmountString;
   effectiveDepositAmount: AmountString;
   fees: DepositGroupFees;
   kycSoftLimit?: AmountString;
   kycHardLimit?: AmountString;
   /**
    * Base URL of exchanges that would likely require soft KYC.
    */
   kycExchanges?: string[];
 }
 
 ```
 ```typescript
 export interface DepositGroupFees {
   coin: AmountString;
   wire: AmountString;
   refresh: AmountString;
 }
 
 ```
 
 ### ExportDbToFileOp
 ```typescript
 /**
  * Export the database to a file.
  *
  * The target directory must already exist.
  */
 export type ExportDbToFileOp = {
   op: WalletApiOperation.ExportDbToFile;
   request: ExportDbToFileRequest;
   response: ExportDbToFileResponse;
 };
 // ExportDbToFile = "exportDbToFile"
 
 ```
 ```typescript
 export interface ExportDbToFileRequest {
   /**
    * Directory that the DB should be exported into.
    */
   directory: string;
   /**
    * Stem of the exported DB filename.
    *
    * The final name will be ${directory}/${stem}.${extension},
    * where the extension depends on the used DB backend.
    */
   stem: string;
   /**
    * Force the format of the export.
    *
    * Currently only "json" is supported as a forced
    * export format.
    */
   forceFormat?: string;
 }
 
 ```
 ```typescript
 export interface ExportDbToFileResponse {
   /**
    * Full path to the backup.
    */
   path: string;
 }
 
 ```
 
 ### ImportDbFromFileOp
 ```typescript
 /**
  * Export the database from a file.
  *
  * CAUTION: Overrides existing data.
  */
 export type ImportDbFromFileOp = {
   op: WalletApiOperation.ImportDbFromFile;
   request: ImportDbFromFileRequest;
   response: EmptyObject;
 };
 // ImportDbFromFile = "importDbFromFile"
 
 ```
 ```typescript
 export interface ImportDbFromFileRequest {
   /**
    * Full path to the backup.
    */
   path: string;
 }
 
 ```
 
 ### ListStoredBackupsOp
 ```typescript
 export type ListStoredBackupsOp = {
   op: WalletApiOperation.ListStoredBackups;
   request: EmptyObject;
   response: StoredBackupList;
 };
 // ListStoredBackups = "listStoredBackups"
 
 ```
 ```typescript
 export interface StoredBackupList {
   storedBackups: {
     name: string;
   }[];
 }
 
 ```
 
 ### CreateStoredBackupsOp
 ```typescript
 export type CreateStoredBackupsOp = {
   op: WalletApiOperation.CreateStoredBackup;
   request: EmptyObject;
   response: CreateStoredBackupResponse;
 };
 // CreateStoredBackup = "createStoredBackup"
 
 ```
 ```typescript
 export interface CreateStoredBackupResponse {
   name: string;
 }
 
 ```
 
 ### RecoverStoredBackupsOp
 ```typescript
 export type RecoverStoredBackupsOp = {
   op: WalletApiOperation.RecoverStoredBackup;
   request: RecoverStoredBackupRequest;
   response: EmptyObject;
 };
 // RecoverStoredBackup = "recoverStoredBackup"
 
 ```
 ```typescript
 export interface RecoverStoredBackupRequest {
   name: string;
 }
 
 ```
 
 ### DeleteStoredBackupOp
 ```typescript
 export type DeleteStoredBackupOp = {
   op: WalletApiOperation.DeleteStoredBackup;
   request: DeleteStoredBackupRequest;
   response: EmptyObject;
 };
 // DeleteStoredBackup = "deleteStoredBackup"
 
 ```
 ```typescript
 export interface DeleteStoredBackupRequest {
   name: string;
 }
 
 ```
 
 ### CheckPeerPushDebitOp
 ```typescript
 /**
  * Check if initiating a peer push payment is possible
  * based on the funds in the wallet.
  */
 export type CheckPeerPushDebitOp = {
   op: WalletApiOperation.CheckPeerPushDebit;
   request: CheckPeerPushDebitRequest;
   response: CheckPeerPushDebitOkResponse;
 };
 // CheckPeerPushDebit = "checkPeerPushDebit"
 
 ```
 
 ### CheckPeerPushDebitV2Op
 ```typescript
 /**
  * Check if initiating a peer push payment is possible
  * based on the funds in the wallet.
  */
 export type CheckPeerPushDebitV2Op = {
   op: WalletApiOperation.CheckPeerPushDebitV2;
   request: CheckPeerPushDebitRequest;
   response: CheckPeerPushDebitResponse;
 };
 // CheckPeerPushDebitV2 = "checkPeerPushDebitV2"
 
 ```
 ```typescript
 export type CheckPeerPushDebitResponse =
   | CheckPeerPushDebitOkResponse
   | CheckPeerPushDebitInsufficientBalanceResponse;
 
 ```
 ```typescript
 export interface CheckPeerPushDebitInsufficientBalanceResponse {
   type: "insufficient-balance";
   insufficientBalanceDetails: PaymentInsufficientBalanceDetails;
 }
 
 ```
 
 ### InitiatePeerPushDebitOp
 ```typescript
 /**
  * Initiate an outgoing peer push payment.
  */
 export type InitiatePeerPushDebitOp = {
   op: WalletApiOperation.InitiatePeerPushDebit;
   request: InitiatePeerPushDebitRequest;
   response: InitiatePeerPushDebitResponse;
 };
 // InitiatePeerPushDebit = "initiatePeerPushDebit"
 
 ```
 ```typescript
 export interface InitiatePeerPushDebitRequest {
   exchangeBaseUrl?: string;
   /**
    * Restrict the scope of funds that can be spent via the given
    * scope info.
    */
   restrictScope?: ScopeInfo;
   partialContractTerms: PartialPeerContractTerms;
 }
 
 ```
 ```typescript
 export interface PartialPeerContractTerms {
   amount: AmountString;
   summary: string;
   icon_id?: string;
   purse_expiration?: TalerProtocolTimestamp;
 }
 
 ```
 ```typescript
 export interface InitiatePeerPushDebitResponse {
   exchangeBaseUrl: string;
   pursePub: string;
   mergePriv: string;
   contractPriv: string;
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### PreparePeerPushCreditOp
 ```typescript
 /**
  * Check an incoming peer push payment.
  */
 export type PreparePeerPushCreditOp = {
   op: WalletApiOperation.PreparePeerPushCredit;
   request: PreparePeerPushCreditRequest;
   response: PreparePeerPushCreditResponse;
 };
 // PreparePeerPushCredit = "preparePeerPushCredit"
 
 ```
 ```typescript
 /**
  * Result of initiating a peer-push-credit payment.
  *
  * Either {@link talerUri} or {@link transactionId} must be specified.
  */
 export interface PreparePeerPushCreditRequest {
   talerUri?: string;
   transactionId?: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface PreparePeerPushCreditResponse {
   contractTerms: PeerContractTerms;
   amountRaw: AmountString;
   amountEffective: AmountString;
   transactionId: TransactionIdStr;
   /**
    * State of the existing or newly created transaction.
    */
   txState: TransactionState;
   exchangeBaseUrl: string;
   scopeInfo: ScopeInfo;
   /**
    * @deprecated
    */
   amount: AmountString;
 }
 
 ```
 
 ### ConfirmPeerPushCreditOp
 ```typescript
 /**
  * Accept an incoming peer push payment.
  */
 export type ConfirmPeerPushCreditOp = {
   op: WalletApiOperation.ConfirmPeerPushCredit;
   request: ConfirmPeerPushCreditRequest;
   response: AcceptPeerPushPaymentResponse;
 };
 // ConfirmPeerPushCredit = "confirmPeerPushCredit"
 
 ```
 ```typescript
 export interface ConfirmPeerPushCreditRequest {
   transactionId: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface AcceptPeerPushPaymentResponse {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### CheckPeerPullCreditOp
 ```typescript
 /**
  * Check fees for an outgoing peer pull payment.
  */
 export type CheckPeerPullCreditOp = {
   op: WalletApiOperation.CheckPeerPullCredit;
   request: CheckPeerPullCreditRequest;
   response: CheckPeerPullCreditResponse;
 };
 // CheckPeerPullCredit = "checkPeerPullCredit"
 
 ```
 ```typescript
 export interface CheckPeerPullCreditRequest {
   /**
    * Require using this particular exchange for this operation.
    */
   exchangeBaseUrl?: string;
   restrictScope?: ScopeInfo;
   amount: AmountString;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface CheckPeerPullCreditResponse {
   exchangeBaseUrl: string;
   amountRaw: AmountString;
   amountEffective: AmountString;
   /**
    * Number of coins that will be used,
    * can be used by the UI to warn if excessively large.
    */
   numCoins: number;
 }
 
 ```
 
 ### InitiatePeerPullCreditOp
 ```typescript
 /**
  * Initiate an outgoing peer pull payment.
  */
 export type InitiatePeerPullCreditOp = {
   op: WalletApiOperation.InitiatePeerPullCredit;
   request: InitiatePeerPullCreditRequest;
   response: InitiatePeerPullCreditResponse;
 };
 // InitiatePeerPullCredit = "initiatePeerPullCredit"
 
 ```
 ```typescript
 export interface InitiatePeerPullCreditRequest {
   exchangeBaseUrl?: string;
   partialContractTerms: PeerContractTerms;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface InitiatePeerPullCreditResponse {
   /**
    * Taler URI for the other party to make the payment
    * that was requested.
    *
    * @deprecated since it's not necessarily valid yet until the tx is in the right state
    */
   talerUri: string;
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### PreparePeerPullDebitOp
 ```typescript
 /**
  * Prepare for an incoming peer pull payment.
  */
 export type PreparePeerPullDebitOp = {
   op: WalletApiOperation.PreparePeerPullDebit;
   request: PreparePeerPullDebitRequest;
   response: PreparePeerPullDebitResponse;
 };
 // PreparePeerPullDebit = "preparePeerPullDebit"
 
 ```
 ```typescript
 /**
  * Result of initiating a peer-pull-debit payment.
  *
  * Either {@link talerUri} or {@link transactionId} must be specified.
  */
 export interface PreparePeerPullDebitRequest {
   talerUri?: string;
   transactionId?: string;
   progressToken?: string;
 }
 
 ```
 ```typescript
 export interface PreparePeerPullDebitResponse {
   contractTerms: PeerContractTerms;
   amountRaw: AmountString;
   amountEffective: AmountString;
   transactionId: TransactionIdStr;
   /**
    * State of the existing or newly created transaction.
    */
   txState: TransactionState;
   exchangeBaseUrl: string;
   scopeInfo: ScopeInfo;
   /**
    * @deprecated Redundant field with bad name, will be removed soon.
    */
   amount: AmountString;
 }
 
 ```
 
 ### ConfirmPeerPullDebitOp
 ```typescript
 /**
  * Accept an incoming peer pull payment (i.e. pay the other party).
  */
 export type ConfirmPeerPullDebitOp = {
   op: WalletApiOperation.ConfirmPeerPullDebit;
   request: ConfirmPeerPullDebitRequest;
   response: AcceptPeerPullPaymentResponse;
 };
 // ConfirmPeerPullDebit = "confirmPeerPullDebit"
 
 ```
 ```typescript
 export interface ConfirmPeerPullDebitRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 ```typescript
 export interface AcceptPeerPullPaymentResponse {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### ValidateIbanOp
 ```typescript
 export type ValidateIbanOp = {
   op: WalletApiOperation.ValidateIban;
   request: ValidateIbanRequest;
   response: ValidateIbanResponse;
 };
 // ValidateIban = "validateIban"
 
 ```
 ```typescript
 export interface ValidateIbanRequest {
   iban: string;
 }
 
 ```
 ```typescript
 export interface ValidateIbanResponse {
   valid: boolean;
 }
 
 ```
 
 ### CanonicalizeBaseUrlOp
 ```typescript
 export type CanonicalizeBaseUrlOp = {
   op: WalletApiOperation.CanonicalizeBaseUrl;
   request: CanonicalizeBaseUrlRequest;
   response: CanonicalizeBaseUrlResponse;
 };
 // CanonicalizeBaseUrl = "canonicalizeBaseUrl"
 
 ```
 ```typescript
 export interface CanonicalizeBaseUrlRequest {
   url: string;
 }
 
 ```
 ```typescript
 export interface CanonicalizeBaseUrlResponse {
   url: string;
 }
 
 ```
 
 ### GetQrCodesForPaytoOp
 ```typescript
 export type GetQrCodesForPaytoOp = {
   op: WalletApiOperation.GetQrCodesForPayto;
   request: GetQrCodesForPaytoRequest;
   response: GetQrCodesForPaytoResponse;
 };
 // GetQrCodesForPayto = "getQrCodesForPayto"
 
 ```
 ```typescript
 export interface GetQrCodesForPaytoRequest {
   paytoUri: string;
 }
 
 ```
 ```typescript
 export interface GetQrCodesForPaytoResponse {
   codes: QrCodeSpec[];
 }
 
 ```
 
 ### ConvertIbanAccountFieldToPaytoOp
 ```typescript
 export type ConvertIbanAccountFieldToPaytoOp = {
   op: WalletApiOperation.ConvertIbanAccountFieldToPayto;
   request: ConvertIbanAccountFieldToPaytoRequest;
   response: ConvertIbanAccountFieldToPaytoResponse;
 };
 // ConvertIbanAccountFieldToPayto = "convertIbanAccountFieldToPayto"
 
 ```
 ```typescript
 export interface ConvertIbanAccountFieldToPaytoRequest {
   value: string;
   currency: string;
 }
 
 ```
 ```typescript
 export type ConvertIbanAccountFieldToPaytoResponse =
   | {
       ok: true;
       type: "iban" | "bban";
       paytoUri: string;
     }
   | {
       ok: false;
     };
 
 ```
 
 ### ConvertIbanPaytoToAccountFieldOp
 ```typescript
 export type ConvertIbanPaytoToAccountFieldOp = {
   op: WalletApiOperation.ConvertIbanPaytoToAccountField;
   request: ConvertIbanPaytoToAccountFieldRequest;
   response: ConvertIbanPaytoToAccountFieldResponse;
 };
 // ConvertIbanPaytoToAccountField = "convertIbanPaytoToAccountField"
 
 ```
 ```typescript
 export interface ConvertIbanPaytoToAccountFieldRequest {
   paytoUri: string;
 }
 
 ```
 ```typescript
 export interface ConvertIbanPaytoToAccountFieldResponse {
   type: "iban" | "bban";
   value: string;
 }
 
 ```
 
 ### GetBankingChoicesForPaytoOp
 ```typescript
 export type GetBankingChoicesForPaytoOp = {
   op: WalletApiOperation.GetBankingChoicesForPayto;
   request: GetBankingChoicesForPaytoRequest;
   response: GetBankingChoicesForPaytoResponse;
 };
 // GetBankingChoicesForPayto = "getBankingChoicesForPayto"
 
 ```
 ```typescript
 export interface GetBankingChoicesForPaytoRequest {
   paytoUri: string;
 }
 
 ```
 ```typescript
 export interface GetBankingChoicesForPaytoResponse {
   choices: BankingChoiceSpec[];
 }
 
 ```
 ```typescript
 export interface BankingChoiceSpec {
   label: string;
   type: "link";
   uri: string;
 }
 
 ```
 
 ### ExportDbOp
 ```typescript
 /**
  * Export the wallet database's contents to JSON.
  */
 export type ExportDbOp = {
   op: WalletApiOperation.ExportDb;
   request: EmptyObject;
   response: any;
 };
 // ExportDb = "exportDb"
 
 ```
 
 ### ImportDbOp
 ```typescript
 export type ImportDbOp = {
   op: WalletApiOperation.ImportDb;
   request: ImportDbRequest;
   response: EmptyObject;
 };
 // ImportDb = "importDb"
 
 ```
 ```typescript
 export interface ImportDbRequest {
   dump?: any;
 }
 
 ```
 
 ### ClearDbOp
 ```typescript
 /**
  * Dangerously clear the whole wallet database.
  */
 export type ClearDbOp = {
   op: WalletApiOperation.ClearDb;
   request: EmptyObject;
   response: EmptyObject;
 };
 // ClearDb = "clearDb"
 
 ```
 
 ### RecycleOp
 ```typescript
 /**
  * Export a backup, clear the database and re-import it.
  */
 export type RecycleOp = {
   op: WalletApiOperation.Recycle;
   request: EmptyObject;
   response: EmptyObject;
 };
 // Recycle = "recycle"
 
 ```
 
 ### ApplyDevExperimentOp
 ```typescript
 /**
  * Apply a developer experiment to the current wallet state.
  *
  * This allows UI developers / testers to play around without
  * an elaborate test environment.
  */
 export type ApplyDevExperimentOp = {
   op: WalletApiOperation.ApplyDevExperiment;
   request: ApplyDevExperimentRequest;
   response: EmptyObject;
 };
 // ApplyDevExperiment = "applyDevExperiment"
 
 ```
 ```typescript
 export interface ApplyDevExperimentRequest {
   devExperimentUri: string;
 }
 
 ```
 
 ### RunIntegrationTestOp
 ```typescript
 /**
  * Run a simple integration test on a test deployment
  * of the exchange and merchant.
  */
 export type RunIntegrationTestOp = {
   op: WalletApiOperation.RunIntegrationTest;
   request: IntegrationTestArgs;
   response: EmptyObject;
 };
 // RunIntegrationTest = "runIntegrationTest"
 
 ```
 ```typescript
 export interface IntegrationTestArgs {
   exchangeBaseUrl: string;
   corebankApiBaseUrl: string;
   merchantBaseUrl: string;
   merchantAuthToken?: string;
   amountToWithdraw: AmountString;
   amountToSpend: AmountString;
 }
 
 ```
 
 ### RunIntegrationTestV2Op
 ```typescript
 /**
  * Run a simple integration test on a test deployment
  * of the exchange and merchant.
  */
 export type RunIntegrationTestV2Op = {
   op: WalletApiOperation.RunIntegrationTestV2;
   request: IntegrationTestV2Args;
   response: EmptyObject;
 };
 // RunIntegrationTestV2 = "runIntegrationTestV2"
 
 ```
 ```typescript
 export interface IntegrationTestV2Args {
   exchangeBaseUrl: string;
   corebankApiBaseUrl: string;
   merchantBaseUrl: string;
   merchantAuthToken?: string;
 }
 
 ```
 
 ### TestCryptoOp
 ```typescript
 /**
  * Test crypto worker.
  */
 export type TestCryptoOp = {
   op: WalletApiOperation.TestCrypto;
   request: EmptyObject;
   response: any;
 };
 // TestCrypto = "testCrypto"
 
 ```
 
 ### WithdrawTestBalanceOp
 ```typescript
 /**
  * Make withdrawal on a test deployment of the exchange
  * and merchant.
  */
 export type WithdrawTestBalanceOp = {
   op: WalletApiOperation.WithdrawTestBalance;
   request: WithdrawTestBalanceRequest;
   response: WithdrawTestBalanceResult;
 };
 // WithdrawTestBalance = "withdrawTestBalance"
 
 ```
 ```typescript
 export interface WithdrawTestBalanceRequest {
   /**
    * Amount to withdraw.
    */
   amount: AmountString;
   /**
    * Corebank API base URL.
    */
   corebankApiBaseUrl: string;
   /**
    * Exchange to use for withdrawal.
    */
   exchangeBaseUrl: string;
   /**
    * Force the usage of a particular denomination selection.
    *
    * Only useful for testing.
    */
   forcedDenomSel?: ForcedDenomSel;
   /**
    * If set to true, treat the account created during
    * the withdrawal as a foreign withdrawal account.
    */
   useForeignAccount?: boolean;
 }
 
 ```
 
 ### WithdrawTestkudosOp
 ```typescript
 /**
  * Make a withdrawal of testkudos on test.taler.net.
  */
 export type WithdrawTestkudosOp = {
   op: WalletApiOperation.WithdrawTestkudos;
   request: EmptyObject;
   response: WithdrawTestBalanceResult;
 };
 // WithdrawTestkudos = "withdrawTestkudos"
 
 ```
 
 ### TestPayOp
 ```typescript
 /**
  * Make a test payment using a test deployment of
  * the exchange and merchant.
  */
 export type TestPayOp = {
   op: WalletApiOperation.TestPay;
   request: TestPayArgs;
   response: TestPayResult;
 };
 // TestPay = "testPay"
 
 ```
 ```typescript
 export interface TestPayArgs {
   merchantBaseUrl: string;
   merchantAuthToken?: string;
   amount: AmountString;
   summary: string;
   forcedCoinSel?: ForcedCoinSel;
 }
 
 ```
 ```typescript
 export interface TestPayResult {
   /**
    * Number of coins used for the payment.
    */
   numCoins: number;
 }
 
 ```
 
 ### GetActiveTasksOp
 ```typescript
 export type GetActiveTasksOp = {
   op: WalletApiOperation.GetActiveTasks;
   request: EmptyObject;
   response: GetActiveTasksResponse;
 };
 // GetActiveTasks = "getActiveTasks"
 
 ```
 ```typescript
 export interface GetActiveTasksResponse {
   tasks: ActiveTask[];
 }
 
 ```
 ```typescript
 export interface ActiveTask {
   taskId: string;
   transaction?: TransactionIdStr | undefined;
   firstTry?: AbsoluteTime | undefined;
   nextTry?: AbsoluteTime | undefined;
   retryCounter?: number | undefined;
   lastError?: TalerErrorDetail | undefined;
 }
 
 ```
 
 ### GetPerformanceStatsOp
 ```typescript
 /**
  * Get a list of performance stats for diagnostics.
  *
  * Requires observability events to be enabled. Performance tables for the
  * current running wallet instance are generated from observability events and
  * stored in memory.
  *
  * Under each table, different types of duration for each operation
  * (e.g. `getBalances` wallet request) are included.
  */
 export type GetPerformanceStatsOp = {
   op: WalletApiOperation.TestingGetPerformanceStats;
   request: GetPerformanceStatsRequest;
   response: GetPerformanceStatsResponse;
 };
 // TestingGetPerformanceStats = "testingGetPerformanceStats"
 
 ```
 ```typescript
 export interface GetPerformanceStatsRequest {
   /**
    * Limit to N largest average performance stats of each table.
    *
    * When undefined, all performance stats will be returned.
    */
   limit?: number;
 }
 
 ```
 ```typescript
 export interface GetPerformanceStatsResponse {
   stats: PerformanceTable;
 }
 
 ```
 ```typescript
 export type PerformanceTable = {
   [key in PerformanceStatType]?: PerformanceStat[];
 };
 
 ```
 ```typescript
 export declare enum PerformanceStatType {
   HttpFetch = "http-fetch",
   DbQuery = "db-query",
   Crypto = "crypto",
   WalletRequest = "wallet-request",
   WalletTask = "wallet-task",
 }
 
 ```
 ```typescript
 export type PerformanceStat =
   | {
       type: PerformanceStatType.HttpFetch;
       url: string;
       avgDurationMs: number;
       maxDurationMs: number;
       minDurationMs: number;
       totalDurationMs: number;
       count: number;
     }
   | {
       type: PerformanceStatType.DbQuery;
       name: string;
       location: string;
       avgDurationMs: number;
       maxDurationMs: number;
       minDurationMs: number;
       totalDurationMs: number;
       count: number;
     }
   | {
       type: PerformanceStatType.Crypto;
       operation: string;
       avgDurationMs: number;
       maxDurationMs: number;
       minDurationMs: number;
       totalDurationMs: number;
       count: number;
     }
   | {
       type: PerformanceStatType.WalletRequest;
       operation: string;
       avgDurationMs: number;
       maxDurationMs: number;
       minDurationMs: number;
       totalDurationMs: number;
       count: number;
     }
   | {
       type: PerformanceStatType.WalletTask;
       taskId: string;
       avgDurationMs: number;
       maxDurationMs: number;
       minDurationMs: number;
       totalDurationMs: number;
       count: number;
     };
 
 ```
 ```typescript
 export type ObservabilityEvent =
   | {
       id: string;
       when: AbsoluteTime;
       type: ObservabilityEventType.HttpFetchStart;
       url: string;
       longPolling: boolean;
     }
   | {
       id: string;
       when: AbsoluteTime;
       type: ObservabilityEventType.HttpFetchFinishSuccess;
       url: string;
       status: number;
       durationMs: number;
       longPolling: boolean;
     }
   | {
       id: string;
       when: AbsoluteTime;
       type: ObservabilityEventType.HttpFetchFinishError;
       url: string;
       error: TalerErrorDetail;
       durationMs: number;
       longPolling: boolean;
     }
   | {
       type: ObservabilityEventType.DbQueryStart;
       name: string;
       location: string;
     }
   | {
       type: ObservabilityEventType.DbQueryFinishSuccess;
       name: string;
       location: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.DbQueryFinishError;
       name: string;
       location: string;
       error: TalerErrorDetail;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.RequestStart;
       name: string;
     }
   | {
       type: ObservabilityEventType.RequestFinishSuccess;
       operation: string;
       requestId: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.RequestFinishError;
       operation: string;
       requestId: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.TaskStart;
       taskId: string;
     }
   | {
       type: ObservabilityEventType.TaskStop;
       taskId: string;
     }
   | {
       type: ObservabilityEventType.TaskReset;
       taskId: string;
     }
   | {
       type: ObservabilityEventType.DeclareTaskDependency;
       taskId: string;
     }
   | {
       type: ObservabilityEventType.CryptoStart;
       operation: string;
     }
   | {
       type: ObservabilityEventType.CryptoFinishSuccess;
       operation: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.CryptoFinishError;
       operation: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.ShepherdTaskResult;
       taskId: string;
       resultType: string;
       durationMs: number;
     }
   | {
       type: ObservabilityEventType.Message;
       contents: string;
     }
   | {
       type: ObservabilityEventType.DeclareConcernsTransaction;
       transactionId: TransactionIdStr;
     };
 
 ```
 
 ### DumpCoinsOp
 ```typescript
 /**
  * Dump all coins of the wallet in a simple JSON format.
  */
 export type DumpCoinsOp = {
   op: WalletApiOperation.DumpCoins;
   request: EmptyObject;
   response: CoinDumpJson;
 };
 // DumpCoins = "dumpCoins"
 
 ```
 ```typescript
 /**
  * Easy to process format for the public data of coins
  * managed by the wallet.
  */
 export interface CoinDumpJson {
   coins: Array<{
     /**
      * The coin's denomination's public key.
      */
     denomPub: DenominationPubKey;
     /**
      * Hash of denom_pub.
      */
     denomPubHash: string;
     /**
      * Value of the denomination (without any fees).
      */
     denomValue: string;
     /**
      * Public key of the coin.
      */
     coinPub: string;
     /**
      * Base URL of the exchange for the coin.
      */
     exchangeBaseUrl: string;
     /**
      * Public key of the parent coin.
      * Only present if this coin was obtained via refreshing.
      */
     refreshParentCoinPub: string | undefined;
     /**
      * Public key of the reserve for this coin.
      * Only present if this coin was obtained via refreshing.
      */
     withdrawalReservePub: string | undefined;
     /**
      * Status of the coin.
      */
     coinStatus: CoinStatus;
     /**
      * Information about the age restriction
      */
     ageCommitmentProof: AgeCommitmentProof | undefined;
     history: WalletCoinHistoryItem[];
   }>;
 }
 
 ```
 ```typescript
 export type DenominationPubKey = RsaDenominationPubKey | CsDenominationPubKey;
 
 ```
 ```typescript
 export interface RsaDenominationPubKey {
   readonly cipher: DenomKeyType.Rsa;
   readonly rsa_public_key: string;
   readonly age_mask: number;
 }
 
 ```
 ```typescript
 export interface CsDenominationPubKey {
   readonly cipher: DenomKeyType.ClauseSchnorr;
   readonly age_mask: number;
   readonly cs_public_key: string;
 }
 
 ```
 ```typescript
 /**
  * Status of a coin.
  */
 export declare enum CoinStatus {
   /**
    * Withdrawn and never shown to anybody.
    */
   Fresh = "fresh",
   /**
    * Coin was lost as the denomination is not usable anymore.
    */
   DenomLoss = "denom-loss",
   /**
    * Fresh, but currently marked as "suspended", thus won't be used
    * for spending.  Used for testing.
    */
   FreshSuspended = "fresh-suspended",
   /**
    * A coin that has been spent and refreshed.
    */
   Dormant = "dormant",
 }
 
 ```
 ```typescript
 export interface AgeCommitmentProof {
   commitment: AgeCommitment;
   proof: AgeProof;
 }
 
 ```
 ```typescript
 export interface AgeCommitment {
   mask: number;
   /**
    * Public keys, one for each age group specified in the age mask.
    */
   publicKeys: Edx25519PublicKeyEnc[];
 }
 
 ```
 ```typescript
 export type Edx25519PublicKeyEnc = string & FlavorEdx25519PublicKeyEnc;
 
 ```
 ```typescript
 type FlavorEdx25519PublicKeyEnc = {
   readonly [isEdx25519PublicKeyEnc]?: true;
 };
 
 ```
 ```typescript
 export interface AgeProof {
   /**
    * Private keys.  Typically smaller than the number of public keys,
    * because we drop private keys from age groups that are restricted.
    */
   privateKeys: Edx25519PrivateKeyEnc[];
 }
 
 ```
 ```typescript
 export type Edx25519PrivateKeyEnc = string & FlavorEdx25519PrivateKeyEnc;
 
 ```
 ```typescript
 type FlavorEdx25519PrivateKeyEnc = {
   readonly [isEdx25519PrivateKeyEnc]?: true;
 };
 
 ```
 ```typescript
 export type WalletCoinHistoryItem =
   | {
       type: "withdraw";
       transactionId: TransactionIdStr;
     }
   | {
       type: "spend";
       transactionId: TransactionIdStr;
       amount: AmountString;
     }
   | {
       type: "refresh";
       transactionId: TransactionIdStr;
       amount: AmountString;
     }
   | {
       type: "recoup";
       transactionId: TransactionIdStr;
       amount: AmountString;
     }
   | {
       type: "refund";
       transactionId: TransactionIdStr;
       amount: AmountString;
     };
 
 ```
 
 ### TestingSetTimetravelOp
 ```typescript
 /**
  * Add an offset to the wallet's internal time.
  */
 export type TestingSetTimetravelOp = {
   op: WalletApiOperation.TestingSetTimetravel;
   request: TestingSetTimetravelRequest;
   response: EmptyObject;
 };
 // TestingSetTimetravel = "testingSetTimetravel"
 
 ```
 ```typescript
 export interface TestingSetTimetravelRequest {
   offsetMs: number;
 }
 
 ```
 
 ### TestingWaitTransactionsFinalOp
 ```typescript
 /**
  * Wait until all transactions are in a final state.
  */
 export type TestingWaitTransactionsFinalOp = {
   op: WalletApiOperation.TestingWaitTransactionsFinal;
   request: EmptyObject;
   response: EmptyObject;
 };
 // TestingWaitTransactionsFinal = "testingWaitTransactionsFinal"
 
 ```
 
 ### TestingWaitTasksDoneOp
 ```typescript
 /**
  * Wait until all transactions are in a final state.
  */
 export type TestingWaitTasksDoneOp = {
   op: WalletApiOperation.TestingWaitTasksDone;
   request: EmptyObject;
   response: EmptyObject;
 };
 // TestingWaitTasksDone = "testingWaitTasksDone"
 
 ```
 
 ### TestingWaitRefreshesFinalOp
 ```typescript
 /**
  * Wait until all refresh transactions are in a final state.
  */
 export type TestingWaitRefreshesFinalOp = {
   op: WalletApiOperation.TestingWaitRefreshesFinal;
   request: EmptyObject;
   response: EmptyObject;
 };
 // TestingWaitRefreshesFinal = "testingWaitRefreshesFinal"
 
 ```
 
 ### TestingWaitBalanceOp
 ```typescript
 /**
  * Wait until a balance has reached the desired value.
  */
 export type TestingWaitBalanceOp = {
   op: WalletApiOperation.TestingWaitBalance;
   request: TestingWaitBalanceRequest;
   response: EmptyObject;
 };
 // TestingWaitBalance = "testingWaitBalance"
 
 ```
 ```typescript
 export interface TestingWaitBalanceRequest {
   type: "material" | "available";
   amount: AmountString;
 }
 
 ```
 
 ### TestingWaitTransactionStateOp
 ```typescript
 /**
  * Wait until a transaction is in a particular state.
  */
 export type TestingWaitTransactionStateOp = {
   op: WalletApiOperation.TestingWaitTransactionState;
   request: TestingWaitTransactionRequest;
   response: EmptyObject;
 };
 // TestingWaitTransactionState = "testingWaitTransactionState"
 
 ```
 ```typescript
 export interface TestingWaitTransactionRequest {
   transactionId: TransactionIdStr;
   /**
    * Additional identifier that is used in the logs
    * to easily find the status of the particular wait
    * request.
    */
   logId?: string;
   /**
    * After the timeout has passed, give up on
    * waiting for the desired state and raise
    * an error instead.
    */
   timeout?: DurationUnitSpec;
   /**
    * If set to true, wait until the desired state
    * is reached with an error.
    */
   requireError?: boolean;
   txState:
     | TransactionStatePattern
     | TransactionStatePattern[]
     | number
     | "nonpending";
 }
 
 ```
 ```typescript
 export interface TransactionStatePattern {
   major: TransactionMajorState | TransactionStateWildcard;
   minor?: TransactionMinorState | TransactionStateWildcard;
 }
 
 ```
 
 ### TestingWaitExchangeStateOp
 ```typescript
 /**
  * Wait until an exchange entry is in a particular state.
  */
 export type TestingWaitExchangeStateOp = {
   op: WalletApiOperation.TestingWaitExchangeState;
   request: TestingWaitExchangeStateRequest;
   response: EmptyObject;
 };
 // TestingWaitExchangeState = "testingWaitExchangeState"
 
 ```
 ```typescript
 export interface TestingWaitExchangeStateRequest {
   exchangeBaseUrl: string;
   walletKycStatus?: ExchangeWalletKycStatus;
 }
 
 ```
 
 ### TestingWaitExchangeReadyOp
 ```typescript
 /**
  * Wait until an exchange entry is ready.
  * Returns an error if updating the exchange
  * failed.
  */
 export type TestingWaitExchangeReadyOp = {
   op: WalletApiOperation.TestingWaitExchangeReady;
   request: TestingWaitExchangeReadyRequest;
   response: EmptyObject;
 };
 // TestingWaitExchangeReady = "testingWaitExchangeReady"
 
 ```
 ```typescript
 export interface TestingWaitExchangeReadyRequest {
   exchangeBaseUrl: string;
   /**
    * Do not stop waiting even when the exchange is
    * in an error state.
    */
   noBail?: boolean;
   /**
    * Force waiting until an update really happened.
    */
   forceUpdate?: boolean;
   /**
    * Only consider the exchange as ready if the
    * next auto-refresh is scheduled for the future.
    */
   waitAutoRefresh?: boolean;
 }
 
 ```
 
 ### TestingPingOp
 ```typescript
 export type TestingPingOp = {
   op: WalletApiOperation.TestingPing;
   request: EmptyObject;
   response: EmptyObject;
 };
 // TestingPing = "testingPing"
 
 ```
 
 ### TestingGetReserveHistoryOp
 ```typescript
 export type TestingGetReserveHistoryOp = {
   op: WalletApiOperation.TestingGetReserveHistory;
   request: TestingGetReserveHistoryRequest;
   response: any;
 };
 // TestingGetReserveHistory = "testingGetReserveHistory"
 
 ```
 ```typescript
 export interface TestingGetReserveHistoryRequest {
   reservePub: string;
   exchangeBaseUrl: string;
 }
 
 ```
 
 ### TestingResetAllRetriesOp
 ```typescript
 /**
  * Reset all task/transaction retries,
  * resulting in immediate re-try of all operations.
  */
 export type TestingResetAllRetriesOp = {
   op: WalletApiOperation.TestingResetAllRetries;
   request: EmptyObject;
   response: EmptyObject;
 };
 // TestingResetAllRetries = "testingResetAllRetries"
 
 ```
 
 ### TestingGetDenomStatsOp
 ```typescript
 /**
  * Get stats about an exchange denomination.
  */
 export type TestingGetDenomStatsOp = {
   op: WalletApiOperation.TestingGetDenomStats;
   request: TestingGetDenomStatsRequest;
   response: TestingGetDenomStatsResponse;
 };
 // TestingGetDenomStats = "testingGetDenomStats"
 
 ```
 ```typescript
 export interface TestingGetDenomStatsRequest {
   exchangeBaseUrl: string;
 }
 
 ```
 ```typescript
 export interface TestingGetDenomStatsResponse {
   numKnown: number;
   numOffered: number;
   numLost: number;
 }
 
 ```
 
 ### TestingRunFixupOp
 ```typescript
 export type TestingRunFixupOp = {
   op: WalletApiOperation.TestingRunFixup;
   request: RunFixupRequest;
   response: EmptyObject;
 };
 // TestingRunFixup = "testingRunFixup"
 
 ```
 ```typescript
 export interface RunFixupRequest {
   id: string;
 }
 
 ```
 
 ### TestingGetDiagnosticsOp
 ```typescript
 export type TestingGetDiagnosticsOp = {
   op: WalletApiOperation.GetDiagnostics;
   request: EmptyObject;
   response: TestingGetDiagnosticsResponse;
 };
 // GetDiagnostics = "getDiagnostics"
 
 ```
 ```typescript
 export interface TestingGetDiagnosticsResponse {
   version: 0;
   /**
    * Statistics about the size of object stores.
    */
   idbObjectStoreCounts?: Record<string, number>;
   exchangeEntries: {
     exchangeBaseUrl: string;
     numDenoms: number;
     numWithdrawableDenoms: number;
     numCandidateWithdrawableDenoms: number;
   }[];
 }
 
 ```
 
 ### TestingGetFlightRecordsOp
 ```typescript
 export type TestingGetFlightRecordsOp = {
   op: WalletApiOperation.TestingGetFlightRecords;
   request: EmptyObject;
   response: TestingGetFlightRecordsResponse;
 };
 // TestingGetFlightRecords = "testingGetFlightRecords"
 
 ```
 ```typescript
 export interface TestingGetFlightRecordsResponse {
   flightRecords: FlightRecordEntry[];
 }
 
 ```
 ```typescript
 export interface FlightRecordEntry {
   timestamp: TalerPreciseTimestamp;
   target: string;
   event: FlightRecordEvent;
 }
 
 ```
 ```typescript
 export declare enum FlightRecordEvent {
   MeltGone = "melt-gone",
   WithdrawalRedenominate = "withdrawal-redenominate",
 }
 
 ```
 
 ### TestingCorruptWithdrawalCoinSelOp
 ```typescript
 export type TestingCorruptWithdrawalCoinSelOp = {
   op: WalletApiOperation.TestingCorruptWithdrawalCoinSel;
   request: TestingCorruptWithdrawalCoinSelRequest;
   response: EmptyObject;
 };
 // TestingCorruptWithdrawalCoinSel = "testingCorruptWithdrawalCoinSel"
 
 ```
 ```typescript
 export interface TestingCorruptWithdrawalCoinSelRequest {
   transactionId: TransactionIdStr;
 }
 
 ```
 
 ### SetCoinSuspendedOp
 ```typescript
 /**
  * Set a coin as (un-)suspended.
  * Suspended coins won't be used for payments.
  */
 export type SetCoinSuspendedOp = {
   op: WalletApiOperation.SetCoinSuspended;
   request: SetCoinSuspendedRequest;
   response: EmptyObject;
 };
 // SetCoinSuspended = "setCoinSuspended"
 
 ```
 ```typescript
 export interface SetCoinSuspendedRequest {
   coinPub: string;
   suspended: boolean;
 }
 
 ```
 
 ### ForceRefreshOp
 ```typescript
 /**
  * Force a refresh on coins where it would not
  * be necessary.
  */
 export type ForceRefreshOp = {
   op: WalletApiOperation.ForceRefresh;
   request: ForceRefreshRequest;
   response: EmptyObject;
 };
 // ForceRefresh = "forceRefresh"
 
 ```
 ```typescript
 export interface ForceRefreshRequest {
   refreshCoinSpecs: RefreshCoinSpec[];
 }
 
 ```
 ```typescript
 export interface RefreshCoinSpec {
   coinPub: string;
   amount?: AmountString;
 }
 
 ```
 
 ## Common Declarations
 ```typescript
 export interface InitRequest {
   config?: PartialWalletRunConfig;
 }
 ```
 ```typescript
 export interface PartialWalletRunConfig {
   testing?: Partial<WalletRunConfig["testing"]>;
   features?: Partial<WalletRunConfig["features"]>;
   lazyTaskLoop?: Partial<WalletRunConfig["lazyTaskLoop"]>;
   logLevel?: Partial<WalletRunConfig["logLevel"]>;
 }
 ```
 ```typescript
 export interface WalletRunConfig {
   /**
    * Unsafe options which it should only be used to create
    * testing environment.
    */
   testing: {
     devModeActive: boolean;
     insecureTrustExchange: boolean;
     preventThrottling: boolean;
     skipDefaults: boolean;
     emitObservabilityEvents?: boolean;
   };
   /**
    * Configurations values that may be safe to show to the user
    */
   features: {
     allowHttp: boolean;
   };
   /**
    * Start processing tasks only when explicitly required, even after
    * init has been called.
    *
    * Useful when the wallet is started to make single read-only request,
    * as otherwise wallet-core starts making network request and process
    * unrelated pending tasks.
    */
   lazyTaskLoop: boolean;
   /**
    * Global log level.
    */
   logLevel: string;
 }
 ```
 ```typescript
 export interface InitResponse {
   versionInfo: WalletCoreVersion;
 }
 ```
 ```typescript
 export interface WalletCoreVersion {
   implementationSemver: string;
   implementationGitHash: string;
   /**
    * Wallet-core protocol version supported by this implementation
    * of the API ("server" version).
    */
   version: string;
   exchange: string;
   merchant: string;
   bankIntegrationApiRange: string;
   bankConversionApiRange: string;
   corebankApiRange: string;
   /**
    * @deprecated as bank was split into multiple APIs with separate versioning
    */
   bank: string;
   /**
    * @deprecated
    */
   hash: string | undefined;
   /**
    * @deprecated will be removed
    */
   devMode: boolean;
 }
 ```
 ```typescript
 export type EmptyObject = Record<string, never>;
 ```
 ```typescript
 export type AmountString =
   | (string & {
       [__amount_str]: true;
     })
   | LitAmountString;
 ```
 ```typescript
 export interface ContactEntry {
   /**
    * Contact alias
    */
   alias: string;
   /**
    * Alias type
    */
   aliasType: string;
   /**
    * mailbox URI
    */
   mailboxBaseUri: string;
   /**
    * mailbox identity
    */
   mailboxAddress: HashCodeString;
   /**
    * The source of this contact
    * may be a URI
    */
   source: string;
   /**
    * The local petname of the contact
    */
   petname: string;
 }
 ```
 ```typescript
 export interface TalerProtocolDuration {
   readonly d_us: number | "forever";
 }
 ```
 ```typescript
 export interface DurationUnitSpec {
   seconds?: number;
   minutes?: number;
   hours?: number;
   days?: number;
   months?: number;
   years?: number;
 }
 ```
 ```typescript
 export interface MailboxConfiguration {
   mailboxBaseUrl: string;
   privateKey: EddsaPrivateKeyString;
   privateEncryptionKey: string;
   expiration: Timestamp;
   hAddress: string;
   payUri?: TalerUri;
 }
 ```
 ```typescript
 export interface TalerProtocolTimestamp {
   /**
    * Seconds (as integer) since epoch.
    */
   readonly t_s: number | "never";
   readonly _flavor?: typeof flavor_TalerProtocolTimestamp;
 }
 ```
 ```typescript
 /**
  * A parsed taler URI.
  */
 export type TalerUri =
   | TalerPayUriResult
   | TalerPayTemplateUri
   | TalerDevExperimentUri
   | TalerPayPullUri
   | TalerPayPushUri
   | TalerRestoreUri
   | TalerRefundUri
   | TalerWithdrawUri
   | TalerWithdrawExchangeUri
   | TalerAddExchangeUri
   | TalerWithdrawalTransferResultUri
   | TalerAddContactUri;
 ```
 ```typescript
 export interface TalerPayUriResult {
   type: TalerUriAction.Pay;
   merchantBaseUrl: HostPortPath;
   orderId: string;
   sessionId: string;
   claimToken?: string;
   /**
    * Nonce priv, only present in the
    * "continue on mobile" payment flow.
    */
   noncePriv?: string;
   nfc?: boolean;
 }
 ```
 ```typescript
 export type HostPortPath = string & {
   [__hostport_str]: true;
 };
 ```
 ```typescript
 export interface TalerPayTemplateUri {
   type: TalerUriAction.PayTemplate;
   merchantBaseUrl: HostPortPath;
   templateId: string;
   sessionId?: string;
   fulfillmentUrl?: string;
   editableSummary?: boolean;
   summary?: string;
   editableAmount?: boolean;
   amount?: AmountString;
   nfc?: boolean;
 }
 ```
 ```typescript
 export interface TalerDevExperimentUri {
   type: TalerUriAction.DevExperiment;
   devExperimentId: string;
   query?: Record<string, string>;
 }
 ```
 ```typescript
 export interface TalerPayPullUri {
   type: TalerUriAction.PayPull;
   exchangeBaseUrl: HostPortPath;
   contractPriv: string;
 }
 ```
 ```typescript
 export interface TalerPayPushUri {
   type: TalerUriAction.PayPush;
   exchangeBaseUrl: HostPortPath;
   contractPriv: string;
 }
 ```
 ```typescript
 export interface TalerRestoreUri {
   type: TalerUriAction.Restore;
   walletRootPriv: string;
   providers: Array<HostPortPath>;
 }
 ```
 ```typescript
 export interface TalerRefundUri {
   type: TalerUriAction.Refund;
   merchantBaseUrl: HostPortPath;
   orderId: string;
 }
 ```
 ```typescript
 export interface TalerWithdrawUri {
   type: TalerUriAction.Withdraw;
   bankIntegrationApiBaseUrl: HostPortPath;
   withdrawalOperationId: string;
   externalConfirmation?: boolean;
 }
 ```
 ```typescript
 export interface TalerWithdrawExchangeUri {
   type: TalerUriAction.WithdrawExchange;
   exchangeBaseUrl: HostPortPath;
   amount?: AmountString;
 }
 ```
 ```typescript
 export interface TalerAddExchangeUri {
   type: TalerUriAction.AddExchange;
   exchangeBaseUrl: HostPortPath;
 }
 ```
 ```typescript
 export interface TalerWithdrawalTransferResultUri {
   type: TalerUriAction.WithdrawalTransferResult;
   ref: string;
   status?: "success" | "aborted";
 }
 ```
 ```typescript
 export interface TalerAddContactUri {
   type: TalerUriAction.AddContact;
   alias: string;
   aliasType: string;
   mailboxBaseUri: string;
   mailboxIdentity: HashCodeString;
   sourceBaseUrl: string;
 }
 ```
 ```typescript
 /**
  * Record metadata for mailbox messages
  */
 export interface MailboxMessageRecord {
   originMailboxBaseUrl: string;
   downloadedAt: Timestamp;
   talerUri: string;
 }
 ```
 ```typescript
 export interface MailboxBaseUrl {
   mailboxBaseUrl: string;
 }
 ```
 ```typescript
 export type ScopeInfo = ScopeInfoGlobal | ScopeInfoExchange | ScopeInfoAuditor;
 ```
 ```typescript
 export type ScopeInfoGlobal = {
   type: ScopeType.Global;
   currency: string;
 };
 ```
 ```typescript
 export type ScopeInfoExchange = {
   type: ScopeType.Exchange;
   currency: string;
   url: string;
 };
 ```
 ```typescript
 export interface Exchange {
   url: string;
   priority: Integer;
   master_pub: EddsaPublicKey;
   max_contribution?: AmountString;
 }
 ```
 ```typescript
 export type ScopeInfoAuditor = {
   type: ScopeType.Auditor;
   currency: string;
   url: string;
 };
 ```
 ```typescript
 export type AccountRestriction =
   | RegexAccountRestriction
   | DenyAllAccountRestriction;
 ```
 ```typescript
 export interface RegexAccountRestriction {
   type: "regex";
   payto_regex: string;
   human_hint: string;
   human_hint_i18n?: InternationalizedString;
 }
 ```
 ```typescript
 export interface InternationalizedString {
   [lang_tag: string]: string;
 }
 ```
 ```typescript
 export interface DenyAllAccountRestriction {
   type: "deny";
 }
 ```
 ```typescript
 export interface TransactionsResponse {
   transactions: Transaction[];
 }
 ```
 ```typescript
 export type Transaction =
   | TransactionWithdrawal
   | TransactionPayment
   | TransactionRefund
   | TransactionRefresh
   | TransactionDeposit
   | TransactionPeerPullCredit
   | TransactionPeerPullDebit
   | TransactionPeerPushCredit
   | TransactionPeerPushDebit
   | TransactionInternalWithdrawal
   | TransactionRecoup
   | TransactionDenomLoss;
 ```
 ```typescript
 /**
  * A withdrawal transaction (either bank-integrated or manual).
  */
 export interface TransactionWithdrawal extends TransactionCommon {
   type: TransactionType.Withdrawal;
   /**
    * Exchange of the withdrawal.
    */
   exchangeBaseUrl: string | undefined;
   /**
    * Amount that got subtracted from the reserve balance.
    */
   amountRaw: AmountString;
   /**
    * Amount that actually was (or will be) added to the wallet's balance.
    */
   amountEffective: AmountString;
   withdrawalDetails: WithdrawalDetails;
 }
 ```
 ```typescript
 export interface TransactionCommon {
   transactionId: TransactionIdStr;
   type: TransactionType;
   timestamp: TalerPreciseTimestamp;
   /**
    * Scope of this tx
    */
   scopes: ScopeInfo[];
   /**
    * Transaction state, as per DD37.
    */
   txState: TransactionState;
   /**
    * Wallet-internal state ID, only used for debugging and testing.
    */
   stId: number;
   /**
    * Possible transitions based on the current state.
    */
   txActions: TransactionAction[];
   /**
    * Raw amount of the transaction (exclusive of fees or other extra costs).
    */
   amountRaw: AmountString;
   /**
    * Amount added or removed from the wallet's balance (including all fees and other costs).
    */
   amountEffective: AmountString;
   error?: TalerErrorDetail;
   abortReason?: TalerErrorDetail;
   failReason?: TalerErrorDetail;
   /**
    * If the transaction minor state is in KycRequired this field is going to
    * have the location where the user need to go to complete KYC information.
    */
   kycUrl?: string;
   /**
    * KYC payto hash. Useful for testing, not so useful for UIs.
    */
   kycPaytoHash?: string;
   /**
    * KYC access token. Useful for testing, not so useful for UIs.
    */
   kycAccessToken?: string;
   kycAuthTransferInfo?: KycAuthTransferInfo;
 }
 ```
 ```typescript
 export type TransactionIdStr = `txn:${string}:${string}` & {
   [__txId]: true;
 };
 ```
 ```typescript
 export declare enum TransactionType {
   Withdrawal = "withdrawal",
   InternalWithdrawal = "internal-withdrawal",
   Payment = "payment",
   Refund = "refund",
   Refresh = "refresh",
   Deposit = "deposit",
   PeerPushDebit = "peer-push-debit",
   PeerPushCredit = "peer-push-credit",
   PeerPullDebit = "peer-pull-debit",
   PeerPullCredit = "peer-pull-credit",
   Recoup = "recoup",
   DenomLoss = "denom-loss",
 }
 ```
 ```typescript
 /**
  * Precise timestamp, typically used in the wallet-core
  * API but not in other Taler APIs so far.
  */
 export interface TalerPreciseTimestamp {
   /**
    * Seconds (as integer) since epoch.
    */
   readonly t_s: number | "never";
   /**
    * Optional microsecond offset (non-negative integer).
    */
   readonly off_us?: number;
   readonly _flavor?: typeof flavor_TalerPreciseTimestamp;
 }
 ```
 ```typescript
 export interface TransactionState {
   /**
    * Major state component of the transaction state.
    */
   major: TransactionMajorState;
   /**
    * Minor state component of the transaction.
    */
   minor?: TransactionMinorState;
   /**
    * Indicator of whether the wallet is currently
    * actively processing the transaction or waiting
    * for a counterparty.
    *
    * Will eventually be folded into a new major state,
    * first via a feature flag and then permanently.
    */
   working?: boolean;
 }
 ```
 ```typescript
 export declare enum TransactionMajorState {
   None = "none",
   Pending = "pending",
   Done = "done",
   Aborting = "aborting",
   Aborted = "aborted",
   Dialog = "dialog",
   Finalizing = "finalizing",
   Suspended = "suspended",
   SuspendedFinalizing = "suspended-finalizing",
   SuspendedAborting = "suspended-aborting",
   Failed = "failed",
   Expired = "expired",
   Deleted = "deleted",
 }
 ```
 ```typescript
 export declare enum TransactionMinorState {
   AbortingBank = "aborting-bank",
   AcceptRefund = "accept-refund",
   AutoRefund = "auto-refund",
   BalanceKycRequired = "balance-kyc",
   Bank = "bank",
   BankConfirmTransfer = "bank-confirm-transfer",
   BankRegisterReserve = "bank-register-reserve",
   CheckRefund = "check-refund",
   ClaimProposal = "claim-proposal",
   CompletedByOtherWallet = "completed-by-other-wallet",
   CreatePurse = "create-purse",
   DeletePurse = "delete-purse",
   Deposit = "deposit",
   Exchange = "exchange",
   ExchangeWaitReserve = "exchange-wait-reserve",
   KycAuthRequired = "kyc-auth",
   KycInit = "kyc-init",
   KycRequired = "kyc",
   Merge = "merge",
   PaidByOther = "paid-by-other",
   Proposed = "proposed",
   Ready = "ready",
   RebindSession = "rebind-session",
   Refresh = "refresh",
   Refused = "refused",
   Repurchase = "repurchase",
   SubmitPayment = "submit-payment",
   Track = "track",
   Unknown = "unknown",
   Withdraw = "withdraw",
   Abort = "abort",
 }
 ```
 ```typescript
 export declare enum TransactionAction {
   Delete = "delete",
   Suspend = "suspend",
   Resume = "resume",
   Abort = "abort",
   Fail = "fail",
   Retry = "retry",
 }
 ```
 ```typescript
 export interface TalerErrorDetail {
   code: TalerErrorCode;
   when?: AbsoluteTime;
   hint?: string;
   [x: string]: unknown;
 }
 ```
 ```typescript
 export interface AbsoluteTime {
   /**
    * Timestamp in milliseconds.
    */
   readonly t_ms: number | "never";
   readonly _flavor?: typeof flavor_AbsoluteTime;
   [opaque_AbsoluteTime]: true;
 }
 ```
 ```typescript
 export interface Duration {
   /**
    * Duration in milliseconds.
    */
   readonly d_ms: number | "forever";
 }
 ```
 ```typescript
 export interface KycAuthTransferInfo {
   /**
    * Payto URI of the account that must make the transfer.
    *
    * The KYC auth transfer will *not* work if it originates
    * from a different account.
    */
   debitPaytoUri: string;
   /**
    * Account public key that must be included in the subject.
    */
   accountPub: string;
   /**
    * Options for making the KYC auth transfer payment
    * to the exchange.
    */
   transferOptions: TransferOption[];
   /**
    * Validity of the transferOptions or undefined
    * if transferOptions does not expire.
    */
   transferExpiry: TalerProtocolTimestamp | undefined;
   /**
    * Amount that the exchange expects to be deposited.
    *
    * Usually corresponds to the TINY_AMOUNT configuration of the exchange,
    * and thus is the smallest amount that can be transferred
    * via a bank transfer.
    *
    * @deprecated Use transferOptions instead.
    */
   amount: AmountString;
   /**
    * Possible target payto URIs.
    *
    * @deprecated Use transferOptions instead.
    */
   creditPaytoUris: string[];
 }
 ```
 ```typescript
 export type TransferOption =
   | TransferOptionPayto
   | TransferOptionUri
   | TransferOptionSwissQrBill;
 ```
 ```typescript
 export interface TransferOptionPayto {
   type: "payto";
   paytoUri: string;
   qrCodes: QrCodeSpec[];
 }
 ```
 ```typescript
 /**
  * Specification of a QR code that includes payment information.
  */
 export interface QrCodeSpec {
   /**
    * Type of the QR code.
    *
    * Depending on the type, different visual styles
    * might be applied.
    */
   type: SupportedBankQr;
   /**
    * Content of the QR code that should be rendered.
    */
   qrContent: string;
 }
 ```
 ```typescript
 export type SupportedBankQr = "epc-qr" | "spc";
 ```
 ```typescript
 export interface TransferOptionUri {
   type: "uri";
   uri: string;
 }
 ```
 ```typescript
 export interface TransferOptionSwissQrBill {
   type: "ch-qr-bill";
   paytoUri: string;
   qrReferenceNumber: string;
   qrCodes: QrCodeSpec[];
 }
 ```
 ```typescript
 export type WithdrawalDetails =
   | WithdrawalDetailsForManualTransfer
   | WithdrawalDetailsForTalerBankIntegrationApi;
 ```
 ```typescript
 interface WithdrawalDetailsForManualTransfer {
   type: WithdrawalType.ManualTransfer;
   /**
    * Payto URIs that the exchange supports.
    *
    * Already contains the amount and message.
    *
    * @deprecated in favor of exchangeCreditAccounts
    */
   exchangePaytoUris: string[];
   exchangeCreditAccountDetails?: WithdrawalExchangeAccountDetails[];
   reservePub: string;
   /**
    * Is the reserve ready for withdrawal?
    */
   reserveIsReady: boolean;
   /**
    * How long does the exchange wait to transfer back funds from a
    * reserve?
    */
   reserveClosingDelay: TalerProtocolDuration;
 }
 ```
 ```typescript
 export interface WithdrawalExchangeAccountDetails {
   /**
    * Payto URI to of the exchange.
    *
    * Depending on whether the (manual!) withdrawal is accepted or just
    * being checked, this already includes the subject with the
    * reserve public key.
    *
    * Wallet UIs should never show instructions to send money to the exchange's payto
    */
   paytoUri: string;
   /**
    * Status that indicates whether the account can be used
    * by the user to send funds for a withdrawal.
    *
    * ok: account should be shown to the user
    * error: account should not be shown to the user, UIs might render the error (in conversionError),
    *   especially in dev mode.
    */
   status: "ok" | "error";
   /**
    * Transfer amount. Might be in a different currency than the requested
    * amount for withdrawal.
    *
    * Absent if this is a conversion account and the conversion failed.
    */
   transferAmount?: AmountString;
   /**
    * Currency specification for the external currency.
    *
    * Only included if this account requires a currency conversion.
    */
   currencySpecification?: CurrencySpecification;
   /**
    * Further restrictions for sending money to the
    * exchange.
    */
   creditRestrictions?: AccountRestriction[];
   /**
    * Label given to the account or the account's bank by the exchange.
    */
   bankLabel?: string;
   priority?: number;
   /**
    * Error that happened when attempting to request the conversion rate.
    */
   conversionError?: TalerErrorDetail;
   /**
    * Timestamp that indicates when the transfer options expire.
    *
    * If missing, options do not expire.
    */
   transferExpiry?: TalerProtocolTimestamp;
   /**
    * Options for transfering funds to the exchange for the withdrawal.
    */
   transferOptions: TransferOption[];
 }
 ```
 ```typescript
 /**
  * DD51 https://docs.taler.net/design-documents/051-fractional-digits.html
  */
 export interface CurrencySpecification {
   name: string;
   num_fractional_input_digits: Integer;
   num_fractional_normal_digits: Integer;
   num_fractional_trailing_zero_digits: Integer;
   alt_unit_names: {
     [log10: string]: string;
   };
   common_amounts?: AmountString[];
 }
 ```
 ```typescript
 interface WithdrawalDetailsForTalerBankIntegrationApi {
   type: WithdrawalType.TalerBankIntegrationApi;
   /**
    * Set to true if the bank has confirmed the withdrawal, false if not.
    * An unconfirmed withdrawal usually requires user-input and should be highlighted in the UI.
    * See also bankConfirmationUrl below.
    */
   confirmed: boolean;
   /**
    * If the withdrawal is unconfirmed, this can include a URL for user
    * initiated confirmation.
    */
   bankConfirmationUrl?: string;
   reservePub: string;
   /**
    * Is the reserve ready for withdrawal?
    */
   reserveIsReady: boolean;
   /**
    * Is the bank transfer for the withdrawal externally confirmed?
    */
   externalConfirmation?: boolean;
   exchangeCreditAccountDetails?: WithdrawalExchangeAccountDetails[];
 }
 ```
 ```typescript
 export interface TransactionPayment extends TransactionCommon {
   type: TransactionType.Payment;
   /**
    * Additional information about the payment.
    *
    * Only present if the information about the
    * order is already available.
    */
   info: OrderShortInfo | undefined;
   /**
    * Full contract terms.
    *
    * Only included if explicitly included in the request.
    */
   contractTerms?: MerchantContractTerms;
   /**
    * Amount that must be paid for the contract
    */
   amountRaw: AmountString;
   /**
    * Amount that was paid, including deposit, wire and refresh fees.
    */
   amountEffective: AmountString;
   /**
    * Amount that has been refunded by the merchant
    */
   totalRefundRaw: AmountString;
   /**
    * Amount will be added to the wallet's balance after fees and refreshing
    */
   totalRefundEffective: AmountString;
   /**
    * Amount pending to be picked up
    */
   refundPending: AmountString | undefined;
   /**
    * Reference to applied refunds
    */
   refunds: RefundInfoShort[];
   /**
    * Is the wallet currently checking for a refund?
    */
   refundQueryActive: boolean;
   /**
    * PoS confirmation codes, separated by newlines.
    * Only present for purchases that support PoS confirmation.
    */
   posConfirmation: string | undefined;
   /**
    * Until when will the posConfirmation be valid?
    */
   posConfirmationDeadline?: TalerProtocolTimestamp;
   /**
    * Did we receive the payment via a taler://pay-template/ URI
    * and did the URI contain a nfc=1 flag?
    */
   posConfirmationViaNfc?: boolean;
   /**
    * In case this payment transaction was detected as a repurchase,
    * this is the transaction ID of the original payment.
    */
   repurchaseTransactionId?: TransactionIdStr;
   /**
    * If applicable, the choice that the user selected.
    */
   choiceIndex?: number;
 }
 ```
 ```typescript
 export interface OrderShortInfo {
   /**
    * Order ID, uniquely identifies the order within a merchant instance
    */
   orderId: string;
   /**
    * Hash of the contract terms.
    */
   contractTermsHash: string;
   /**
    * More information about the merchant
    */
   merchant: MerchantInfo;
   /**
    * Summary of the order, given by the merchant
    */
   summary: string;
   /**
    * Map from IETF BCP 47 language tags to localized summaries
    */
   summary_i18n?: InternationalizedString;
   /**
    * URL of the fulfillment, given by the merchant
    */
   fulfillmentUrl?: string;
   /**
    * Plain text message that should be shown to the user
    * when the payment is complete.
    */
   fulfillmentMessage?: string;
   /**
    * Translations of fulfillmentMessage.
    */
   fulfillmentMessage_i18n?: InternationalizedString;
 }
 ```
 ```typescript
 export interface MerchantInfo {
   name: string;
   email?: string;
   website?: string;
   logo?: ImageDataUrl;
   address?: Location;
   jurisdiction?: Location;
 }
 ```
 ```typescript
 export interface Location {
   country?: string;
   country_subdivision?: string;
   district?: string;
   town?: string;
   town_location?: string;
   post_code?: string;
   street?: string;
   building_name?: string;
   building_number?: string;
   address_lines?: string[];
 }
 ```
 ```typescript
 export type MerchantContractTerms =
   | MerchantContractTermsV0
   | MerchantContractTermsV1;
 ```
 ```typescript
 export interface MerchantContractTermsV0 extends MerchantContractTermsCommon {
   version?: MerchantContractVersion.V0;
   amount: AmountString;
   max_fee: AmountString;
 }
 ```
 ```typescript
 /**
  * Contract terms from a merchant.
  */
 interface MerchantContractTermsCommon {
   h_wire: string;
   auto_refund?: TalerProtocolDuration;
   wire_method: string;
   summary: string;
   summary_i18n?: InternationalizedString;
   order_id: string;
   nonce: string;
   pay_deadline: TalerProtocolTimestamp;
   merchant: MerchantInfo;
   merchant_pub: string;
   delivery_date?: TalerProtocolTimestamp;
   delivery_location?: Location;
   exchanges: Exchange[];
   products?: ProductSold[];
   refund_deadline: TalerProtocolTimestamp;
   wire_transfer_deadline: TalerProtocolTimestamp;
   timestamp: TalerProtocolTimestamp;
   merchant_base_url: string;
   fulfillment_url?: string;
   public_reorder_url?: string;
   fulfillment_message?: string;
   fulfillment_message_i18n?: InternationalizedString;
   extra?: any;
   minimum_age?: Integer;
   default_money_pot?: Integer;
 }
 ```
 ```typescript
 export interface ProductSold {
   product_id?: string;
   product_name?: string;
   description: string;
   description_i18n?: {
     [lang_tag: string]: string;
   };
   quantity?: Integer;
   unit?: string;
   price?: AmountString;
   image?: ImageDataUrl;
   taxes?: Tax[];
   delivery_date?: Timestamp;
   product_money_pot?: Integer;
 }
 ```
 ```typescript
 export interface Tax {
   name: string;
   tax: AmountString;
 }
 ```
 ```typescript
 export interface MerchantContractTermsV1 extends MerchantContractTermsCommon {
   version: MerchantContractVersion.V1;
   choices: MerchantContractChoice[];
   token_families: {
     [token_family_slug: string]: MerchantContractTokenFamily;
   };
 }
 ```
 ```typescript
 export interface MerchantContractChoice {
   amount: AmountString;
   description?: string;
   description_i18n?: InternationalizedString;
   inputs: MerchantContractInput[];
   outputs: MerchantContractOutput[];
   max_fee: AmountString;
 }
 ```
 ```typescript
 export interface MerchantContractInputToken {
   type: MerchantContractInputType.Token;
   token_family_slug: string;
   count?: Integer;
 }
 ```
 ```typescript
 export type MerchantContractOutput =
   | MerchantContractOutputToken
   | MerchantContractOutputTaxReceipt;
 ```
 ```typescript
 export interface MerchantContractOutputToken {
   type: MerchantContractOutputType.Token;
   token_family_slug: string;
   count?: Integer;
   valid_at?: Timestamp;
   key_index: Integer;
 }
 ```
 ```typescript
 export interface MerchantContractOutputTaxReceipt {
   type: MerchantContractOutputType.TaxReceipt;
   donau_urls: string[];
   amount?: AmountString;
 }
 ```
 ```typescript
 export interface MerchantContractTokenFamily {
   name: string;
   description: string;
   description_i18n?: {
     [lang_tag: string]: string;
   };
   keys: TokenIssuePublicKey[];
   details: MerchantContractTokenDetails;
   critical: boolean;
 }
 ```
 ```typescript
 export type TokenIssuePublicKey =
   | TokenIssueRsaPublicKey
   | TokenIssueCsPublicKey;
 ```
 ```typescript
 export interface TokenIssueRsaPublicKey {
   cipher: "RSA";
   rsa_pub: RsaPublicKey;
   signature_validity_start: Timestamp;
   signature_validity_end: Timestamp;
 }
 ```
 ```typescript
 export interface TokenIssueCsPublicKey {
   cipher: "CS";
   cs_pub: Cs25519Point;
   signature_validity_start: Timestamp;
   signature_validity_end: Timestamp;
 }
 ```
 ```typescript
 export type MerchantContractTokenDetails =
   | MerchantContractSubscriptionTokenDetails
   | MerchantContractDiscountTokenDetails;
 ```
 ```typescript
 export interface MerchantContractSubscriptionTokenDetails {
   class: MerchantContractTokenKind.Subscription;
   trusted_domains: string[];
 }
 ```
 ```typescript
 export interface MerchantContractDiscountTokenDetails {
   class: MerchantContractTokenKind.Discount;
   expected_domains: string[];
 }
 ```
 ```typescript
 export interface RefundInfoShort {
   transactionId: string;
   timestamp: TalerProtocolTimestamp;
   amountEffective: AmountString;
   amountRaw: AmountString;
 }
 ```
 ```typescript
 export interface TransactionRefund extends TransactionCommon {
   type: TransactionType.Refund;
   amountRaw: AmountString;
   amountEffective: AmountString;
   refundedTransactionId: string;
   paymentInfo: RefundPaymentInfo | undefined;
 }
 ```
 ```typescript
 /**
  * Summary information about the payment that we got a refund for.
  */
 export interface RefundPaymentInfo {
   summary: string;
   summary_i18n?: InternationalizedString;
   /**
    * More information about the merchant
    */
   merchant: MerchantInfo;
 }
 ```
 ```typescript
 /**
  * A transaction shown for refreshes.
  * Only shown for (1) refreshes not associated with other transactions
  * and (2) refreshes in an error state.
  */
 export interface TransactionRefresh extends TransactionCommon {
   type: TransactionType.Refresh;
   refreshReason: RefreshReason;
   /**
    * Transaction ID that caused this refresh.
    */
   originatingTransactionId?: string;
   /**
    * Always zero for refreshes
    */
   amountRaw: AmountString;
   /**
    * Fees, i.e. the effective, negative effect of the refresh
    * on the balance.
    *
    * Only applicable for stand-alone refreshes, and zero for
    * other refreshes where the transaction itself accounts for the
    * refresh fee.
    */
   amountEffective: AmountString;
   refreshInputAmount: AmountString;
   refreshOutputAmount: AmountString;
 }
 ```
 ```typescript
 /**
  * Reasons for why a coin is being refreshed.
  */
 export declare enum RefreshReason {
   Manual = "manual",
   PayMerchant = "pay-merchant",
   PayDeposit = "pay-deposit",
   PayPeerPush = "pay-peer-push",
   PayPeerPull = "pay-peer-pull",
   Refund = "refund",
   AbortPay = "abort-pay",
   AbortDeposit = "abort-deposit",
   AbortPeerPushDebit = "abort-peer-push-debit",
   AbortPeerPullDebit = "abort-peer-pull-debit",
   Recoup = "recoup",
   BackupRestored = "backup-restored",
   Scheduled = "scheduled",
 }
 ```
 ```typescript
 /**
  * Deposit transaction, which effectively sends
  * money from this wallet somewhere else.
  */
 export interface TransactionDeposit extends TransactionCommon {
   type: TransactionType.Deposit;
   depositGroupId: string;
   /**
    * Target for the deposit.
    */
   targetPaytoUri: string;
   /**
    * Raw amount that is being deposited
    */
   amountRaw: AmountString;
   /**
    * Deposit account public key.
    */
   accountPub: string;
   /**
    * Effective amount that is being deposited
    */
   amountEffective: AmountString;
   wireTransferDeadline: TalerProtocolTimestamp;
   wireTransferProgress: number;
   /**
    * Did all the deposit requests succeed?
    */
   deposited: boolean;
   trackingState: Array<DepositTransactionTrackingState>;
 }
 ```
 ```typescript
 export interface DepositTransactionTrackingState {
   wireTransferId: string;
   timestampExecuted: TalerProtocolTimestamp;
   amountRaw: AmountString;
   wireFee: AmountString;
 }
 ```
 ```typescript
 /**
  * Credit because we were paid for a P2P invoice we created.
  */
 export interface TransactionPeerPullCredit extends TransactionCommon {
   type: TransactionType.PeerPullCredit;
   info: PeerInfoShort;
   /**
    * Exchange used.
    */
   exchangeBaseUrl: string;
   /**
    * Amount that got subtracted from the reserve balance.
    */
   amountRaw: AmountString;
   /**
    * Amount that actually was (or will be) added to the wallet's balance.
    */
   amountEffective: AmountString;
   /**
    * URI to send to the other party.
    *
    * Only available in the right state.
    */
   talerUri: string | undefined;
 }
 ```
 ```typescript
 export interface PeerInfoShort {
   expiration: TalerProtocolTimestamp | undefined;
   summary: string | undefined;
   iconId: string | undefined;
 }
 ```
 ```typescript
 /**
  * Debit because we paid someone's invoice.
  */
 export interface TransactionPeerPullDebit extends TransactionCommon {
   type: TransactionType.PeerPullDebit;
   info: PeerInfoShort;
   /**
    * Exchange used.
    */
   exchangeBaseUrl: string;
   amountRaw: AmountString;
   amountEffective: AmountString;
 }
 ```
 ```typescript
 /**
  * We received money via a P2P payment.
  */
 export interface TransactionPeerPushCredit extends TransactionCommon {
   type: TransactionType.PeerPushCredit;
   info: PeerInfoShort;
   /**
    * Exchange used.
    */
   exchangeBaseUrl: string;
   /**
    * Amount that got subtracted from the reserve balance.
    */
   amountRaw: AmountString;
   /**
    * Amount that actually was (or will be) added to the wallet's balance.
    */
   amountEffective: AmountString;
 }
 ```
 ```typescript
 /**
  * We sent money via a P2P payment.
  */
 export interface TransactionPeerPushDebit extends TransactionCommon {
   type: TransactionType.PeerPushDebit;
   info: PeerInfoShort;
   /**
    * Exchange used.
    */
   exchangeBaseUrl: string;
   /**
    * Amount that got subtracted from the reserve balance.
    */
   amountRaw: AmountString;
   /**
    * Amount that actually was (or will be) added to the wallet's balance.
    */
   amountEffective: AmountString;
   /**
    * URI to accept the payment.
    *
    * Only present if the transaction is in a state where the other party can
    * accept the payment.
    */
   talerUri?: string;
 }
 ```
 ```typescript
 /**
  * Internal withdrawal operation, only reported on request.
  *
  * Some transactions (peer-*-credit) internally do a withdrawal,
  * but only the peer-*-credit transaction is reported.
  *
  * The internal withdrawal transaction allows to access the details of
  * the underlying withdrawal for testing/debugging.
  *
  * It is usually not reported, so that amounts of transactions properly
  * add up, since the amountEffecive of the withdrawal is already reported
  * in the peer-*-credit transaction.
  */
 export interface TransactionInternalWithdrawal extends TransactionCommon {
   type: TransactionType.InternalWithdrawal;
   /**
    * Exchange of the withdrawal.
    */
   exchangeBaseUrl: string;
   /**
    * Amount that got subtracted from the reserve balance.
    */
   amountRaw: AmountString;
   /**
    * Amount that actually was (or will be) added to the wallet's balance.
    */
   amountEffective: AmountString;
   withdrawalDetails: WithdrawalDetails;
 }
 ```
 ```typescript
 /**
  * The exchange revoked a key and the wallet recoups funds.
  */
 export interface TransactionRecoup extends TransactionCommon {
   type: TransactionType.Recoup;
 }
 ```
 ```typescript
 /**
  * A transaction to indicate financial loss due to denominations
  * that became unusable for deposits.
  */
 export interface TransactionDenomLoss extends TransactionCommon {
   type: TransactionType.DenomLoss;
   lossEventType: DenomLossEventType;
   exchangeBaseUrl: string;
 }
 ```
 ```typescript
 export declare enum DenomLossEventType {
   DenomExpired = "denom-expired",
   DenomVanished = "denom-vanished",
   DenomUnoffered = "denom-unoffered",
 }
 ```
 ```typescript
 export interface AbortTransactionRequest {
   transactionId: TransactionIdStr;
 }
 ```
 ```typescript
 export interface WithdrawUriInfoResponse {
   operationId: string;
   status: WithdrawalOperationStatusFlag;
   confirmTransferUrl?: string;
   currency: string;
   amount: AmountString | undefined;
   /**
    * Set to true if the user is allowed to edit the amount.
    *
    * Note that even with a non-editable amount, the amount
    * might be undefined at the beginning of the withdrawal
    * process.
    */
   editableAmount: boolean;
   maxAmount: AmountString | undefined;
   wireFee: AmountString | undefined;
   defaultExchangeBaseUrl?: string;
   editableExchange: boolean;
   possibleExchanges: ExchangeListItem[];
 }
 ```
 ```typescript
 export type WithdrawalOperationStatusFlag =
   | "pending"
   | "selected"
   | "aborted"
   | "confirmed";
 ```
 ```typescript
 /**
  * Info about an exchange entry in the wallet.
  */
 export interface ExchangeListItem {
   exchangeBaseUrl: string;
   masterPub: string | undefined;
   currency: string;
   paytoUris: string[];
   tosStatus: ExchangeTosStatus;
   exchangeEntryStatus: ExchangeEntryStatus;
   exchangeUpdateStatus: ExchangeUpdateStatus;
   ageRestrictionOptions: number[];
   walletKycStatus?: ExchangeWalletKycStatus;
   walletKycReservePub?: string;
   walletKycAccessToken?: string;
   walletKycUrl?: string;
   /** Threshold that we've requested to satisfy. */
   walletKycRequestedThreshold?: string;
   /**
    * P2P payments are disabled with this exchange
    * (e.g. because no global fees are configured).
    */
   peerPaymentsDisabled: boolean;
   directDepositsDisabled: boolean;
   /** Set to true if this exchange doesn't charge any fees. */
   noFees: boolean;
   /** Most general scope that the exchange is a part of. */
   scopeInfo: ScopeInfo;
   /**
    * Instructs wallets to use certain bank-specific
    * language (for buttons) and/or other UI/UX customization
    * for compliance with the rules of that bank.
    */
   bankComplianceLanguage?: string;
   lastUpdateTimestamp: TalerPreciseTimestamp | undefined;
   /**
    * Information about the last error that occurred when trying
    * to update the exchange info.
    */
   lastUpdateErrorInfo?: OperationErrorInfo;
   /**
    * Currency spec for the currency offered
    * by the exchange.
    */
   currencySpec: CurrencySpecification;
 }
 ```
 ```typescript
 export declare enum ExchangeTosStatus {
   Pending = "pending",
   Proposed = "proposed",
   Accepted = "accepted",
   MissingTos = "missing-tos",
 }
 ```
 ```typescript
 export declare enum ExchangeEntryStatus {
   Preset = "preset",
   Ephemeral = "ephemeral",
   Used = "used",
 }
 ```
 ```typescript
 export declare enum ExchangeUpdateStatus {
   Initial = "initial",
   InitialUpdate = "initial-update",
   Suspended = "suspended",
   UnavailableUpdate = "unavailable-update",
   Ready = "ready",
   ReadyUpdate = "ready-update",
   OutdatedUpdate = "outdated-update",
 }
 ```
 ```typescript
 export declare enum ExchangeWalletKycStatus {
   Done = "done",
   /**
    * Wallet needs to request KYC status.
    */
   LegiInit = "legi-init",
   /**
    * User requires KYC or AML.
    */
   Legi = "legi",
 }
 ```
 ```typescript
 export interface OperationErrorInfo {
   error: TalerErrorDetail;
 }
 ```
 ```typescript
 export interface ForcedDenomSel {
   denoms: {
     value: AmountString;
     count: number;
   }[];
 }
 ```
 ```typescript
 export interface PreparePayRequest {
   talerPayUri: string;
 }
 ```
 ```typescript
 /**
  * Result of a prepare pay operation.
  */
 export type PreparePayResult =
   | PreparePayResultInsufficientBalance
   | PreparePayResultAlreadyConfirmed
   | PreparePayResultPaymentPossible
   | PreparePayResultChoiceSelection;
 ```
 ```typescript
 export interface PreparePayResultInsufficientBalance {
   status: PreparePayResultType.InsufficientBalance;
   transactionId: TransactionIdStr;
   /**
    * Scopes involved in this transaction.
    *
    * For the insufficient balance response, contains scopes
    * of *possible* payment providers.
    */
   scopes: ScopeInfo[];
   contractTerms: MerchantContractTermsV0;
   amountRaw: AmountString;
   talerUri: string;
   balanceDetails: PaymentInsufficientBalanceDetails;
 }
 ```
 ```typescript
 /**
  * Detailed reason for why the wallet's balance is insufficient.
  */
 export interface PaymentInsufficientBalanceDetails {
   /**
    * Amount requested by the merchant.
    */
   amountRequested: AmountString;
   /**
    * Wire method for the requested payment, only applicable
    * for merchant payments.
    */
   wireMethod?: string | undefined;
   /**
    * Hint as to why the balance is insufficient.
    *
    * If this hint is not provided, the balance hints of
    * the individual exchanges should be shown, as the overall
    * reason might be a combination of the reasons for different exchanges.
    */
   causeHint?: InsufficientBalanceHint;
   /**
    * Balance of type "available" (see balance.ts for definition).
    */
   balanceAvailable: AmountString;
   /**
    * Balance of type "material" (see balance.ts for definition).
    */
   balanceMaterial: AmountString;
   /**
    * Balance of type "age-acceptable" (see balance.ts for definition).
    */
   balanceAgeAcceptable: AmountString;
   /**
    * Balance of type "receiver-acceptable" (see balance.ts for definition).
    *
    * @deprecated (2025-12-05) use balanceReceiver[...]Acceptable instead.
    */
   balanceReceiverAcceptable: AmountString;
   /**
    * Balance of type "receiver-exchange-url-acceptable" (see balance.ts for definition).
    */
   balanceReceiverExchangeUrlAcceptable: AmountString;
   /**
    * Balance of type "receiver-exchange-pub-acceptable" (see balance.ts for definition).
    */
   balanceReceiverExchangePubAcceptable: AmountString;
   /**
    * Balance of type "receiver-auditor-url-acceptable" (see balance.ts for definition).
    */
   balanceReceiverAuditorUrlAcceptable: AmountString;
   /**
    * Balance of type "merchant-depositable" (see balance.ts for definition).
    */
   balanceReceiverDepositable: AmountString;
   balanceExchangeDepositable: AmountString;
   /**
    * Maximum effective amount that the wallet can spend,
    * when all fees are paid by the wallet.
    */
   maxEffectiveSpendAmount: AmountString;
   perExchange: {
     [url: string]: {
       balanceAvailable: AmountString;
       balanceMaterial: AmountString;
       balanceExchangeDepositable: AmountString;
       balanceAgeAcceptable: AmountString;
       /**
        * @deprecated (2025-12-05) use balanceReceiver[...]Acceptable instead.
        */
       balanceReceiverAcceptable: AmountString;
       balanceReceiverExchangeUrlAcceptable: AmountString;
       balanceReceiverExchangePubAcceptable: AmountString;
       balanceReceiverAuditorUrlAcceptable: AmountString;
       balanceReceiverDepositable: AmountString;
       maxEffectiveSpendAmount: AmountString;
       /**
        * The exchange master public key configured by the merchant
        * backend differs from the one of the coins stored in the wallet.
        */
       exchangeMasterPubMismatch: boolean;
       /**
        * Exchange doesn't have global fees configured for the relevant year,
        * p2p payments aren't possible.
        *
        * @deprecated (2025-02-18) use causeHint instead
        */
       missingGlobalFees: boolean;
       /**
        * Hint that UIs should show to explain the insufficient
        * balance.
        */
       causeHint?: InsufficientBalanceHint | undefined;
     };
   };
 }
 ```
 ```typescript
 export declare enum InsufficientBalanceHint {
   /**
    *  Merchant doesn't accept money from exchange(s) that the wallet supports.
    */
   MerchantAcceptInsufficient = "merchant-accept-insufficient",
   /**
    * Merchant accepts funds from a matching exchange, but the funds can't be
    * deposited with the wire method.
    */
   MerchantDepositInsufficient = "merchant-deposit-insufficient",
   /**
    * While in principle the balance is sufficient,
    * the age restriction on coins causes the spendable
    * balance to be insufficient.
    */
   AgeRestricted = "age-restricted",
   /**
    * Wallet has enough available funds,
    * but the material funds are insufficient. Usually because there is a
    * pending refresh operation.
    */
   WalletBalanceMaterialInsufficient = "wallet-balance-material-insufficient",
   /**
    * The wallet simply doesn't have enough available funds.
    * This is the "obvious" case of insufficient balance.
    */
   WalletBalanceAvailableInsufficient = "wallet-balance-available-insufficient",
   /**
    * Exchange is missing the global fee configuration, thus fees are unknown
    * and funds from this exchange can't be used for p2p payments.
    */
   ExchangeMissingGlobalFees = "exchange-missing-global-fees",
   /**
    * Even though the balance looks sufficient for the instructed amount,
    * the fees can be covered by neither the merchant nor the remaining wallet
    * balance.
    */
   FeesNotCovered = "fees-not-covered",
 }
 ```
 ```typescript
 export interface PreparePayResultAlreadyConfirmed {
   status: PreparePayResultType.AlreadyConfirmed;
   transactionId: TransactionIdStr;
   contractTerms: MerchantContractTerms;
   paid: boolean;
   amountRaw: AmountString;
   amountEffective?: AmountString | undefined;
   /**
    * Scopes involved in this transaction.
    */
   scopes: ScopeInfo[];
   contractTermsHash: string;
   talerUri: string;
 }
 ```
 ```typescript
 /**
  * Payment is possible.
  *
  * This response is only returned for v0 contracts
  * or when v1 are not enabled yet.
  */
 export interface PreparePayResultPaymentPossible {
   status: PreparePayResultType.PaymentPossible;
   transactionId: TransactionIdStr;
   contractTerms: MerchantContractTermsV0;
   /**
    * Scopes involved in this transaction.
    */
   scopes: ScopeInfo[];
   amountRaw: AmountString;
   amountEffective: AmountString;
   /**
    * FIXME: Unclear why this is needed.  Remove?
    */
   contractTermsHash: string;
   /**
    * FIXME: Unclear why this is needed!  Remove?
    */
   talerUri: string;
 }
 ```
 ```typescript
 /**
  * Unconfirmed contract v1 payment.
  */
 export interface PreparePayResultChoiceSelection {
   status: PreparePayResultType.ChoiceSelection;
   transactionId: TransactionIdStr;
   contractTerms: MerchantContractTerms;
   contractTermsHash: string;
   talerUri: string;
 }
 ```
 ```typescript
 export interface PreparePayTemplateRequest {
   talerPayTemplateUri: string;
   templateParams?: TemplateParams;
   progressToken?: string;
 }
 ```
 ```typescript
 export type TemplateParams = {
   amount?: AmountString;
   summary?: string;
 };
 ```
 ```typescript
 export interface PreparePayV2Result {
   transactionId: TransactionIdStr;
 }
 ```
 ```typescript
 /**
  * Forced coin selection for deposits/payments.
  */
 export interface ForcedCoinSel {
   coins: {
     value: AmountString;
     contribution: AmountString;
   }[];
 }
 ```
 ```typescript
 export interface ListDiscountsRequest {
   /**
    * Filter by hash of token issue public key.
    */
   tokenIssuePubHash?: string;
   /**
    * Filter by merchant base URL.
    */
   merchantBaseUrl?: string;
 }
 ```
 ```typescript
 export interface DiscountListDetail {
   /**
    * Hash of token family info.
    */
   tokenFamilyHash: string;
   /**
    * Hash of token issue public key.
    */
   tokenIssuePubHash: string;
   /**
    * URL of the merchant issuing the token.
    */
   merchantBaseUrl: string;
   /**
    * Name of the merchant instance issuing the token.
    */
   merchantInfo?: MerchantInfo;
   /**
    * Human-readable name for the token family.
    */
   name: string;
   /**
    * Human-readable description for the token family.
    */
   description: string;
   /**
    * Optional map from IETF BCP 47 language tags to localized descriptions.
    */
   descriptionI18n: any | undefined;
   /**
    * Start time of the token's validity period.
    */
   validityStart: Timestamp;
   /**
    * End time of the token's validity period.
    */
   validityEnd: Timestamp;
   /**
    * Number of tokens available to use.
    */
   tokensAvailable: number;
 }
 ```
 ```typescript
 export interface WalletBankAccountInfo {
   bankAccountId: string;
   paytoUri: string;
   /**
    * Did we previously complete a KYC process for this bank account?
    *
    * @deprecated no enough information since the kyc can be completed for one exchange but not for another
    * https://bugs.gnunet.org/view.php?id=9696
    */
   kycCompleted: boolean;
   /**
    * Currencies supported by the bank, if known.
    */
   currencies: string[] | undefined;
   label: string | undefined;
 }
 ```
 ```typescript
 export interface AcceptExchangeTosRequest {
   exchangeBaseUrl: string;
 }
 ```
 ```typescript
 export interface WireTypeDetails {
   paymentTargetType: string;
   /**
    * Only applicable for payment target type IBAN.
    *
    * Specifies whether the user wants to preferably
    * enter their bank account details as an IBAN
    * or as a BBAN.
    *
    * Mandatory for paymentTargetType="iban".
    */
   preferredEntryType?: "iban" | "bban";
   /**
    * Allowed hostnames for the deposit payto URI.
    * Only applicable to x-taler-bank.
    */
   talerBankHostnames?: string[];
 }
 ```
 ```typescript
 export interface CheckPeerPushDebitRequest {
   /**
    * Preferred exchange to use for the p2p payment.
    */
   exchangeBaseUrl?: string;
   /**
    * Instructed amount.
    *
    * FIXME: Allow specifying the instructed amount type.
    */
   amount: AmountString;
   /**
    * Restrict the scope of funds that can be spent via the given
    * scope info.
    */
   restrictScope?: ScopeInfo;
   progressToken?: string;
 }
 ```
 ```typescript
 export interface CheckPeerPushDebitOkResponse {
   type: "ok";
   amountRaw: AmountString;
   amountEffective: AmountString;
   /**
    * Exchange base URL.
    */
   exchangeBaseUrl: string;
   /**
    * Maximum expiration date, based on how close the coins
    * used for the payment are to expiry.
    *
    * The value is based on when the wallet would typically
    * automatically refresh the coins on its own, leaving enough
    * time to get a refund for the push payment and refresh the
    * coin.
    */
   maxExpirationDate: TalerProtocolTimestamp;
   /**
    * Default expiration, as given by the exchange
    * (or 1 week if the exchange does not specify it).
    */
   defaultExpiration: TalerProtocolDuration;
 }
 ```
 ```typescript
 /**
  * Contract terms between two wallets (as opposed to a merchant and wallet).
  */
 export interface PeerContractTerms {
   amount: AmountString;
   summary: string;
   icon_id?: string;
   purse_expiration: TalerProtocolTimestamp;
 }
 ```
 ```typescript
 export interface WithdrawTestBalanceResult {
   /**
    * Transaction ID of the newly created withdrawal transaction.
    */
   transactionId: TransactionIdStr;
   /**
    * Account of the user registered for the withdrawal.
    */
   accountPaytoUri: string;
 }
 ```