8 files changed, 6594 insertions, 0 deletions
diff --git a/extract-tsdefs/.gitignore b/extract-tsdefs/.gitignore
new file mode 100644
index 00000000..fa298802
--- /dev/null
+++ b/extract-tsdefs/.gitignore
@@ -0,0 +1,3 @@
+extract.js
+node_modules/
+dist
diff --git a/extract-tsdefs/README.md b/extract-tsdefs/README.md
new file mode 100644
index 00000000..e668be8d
--- /dev/null
+++ b/extract-tsdefs/README.md
@@ -0,0 +1,8 @@
+# Auto-generated wallet-core API docs
+
+Usage:
+```
+pnpm install
+pnpm run compile
+node dist/extract.js $WALLET_CORE_DIR $OUTFILENAME
+```
diff --git a/extract-tsdefs/extract.ts b/extract-tsdefs/extract.ts
new file mode 100644
index 00000000..5be82479
--- /dev/null
+++ b/extract-tsdefs/extract.ts
@@ -0,0 +1,341 @@
+/*
+ This file is part of GNU Taler
+ (C) 2022 Taler Systems S.A.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+import * as ts from "typescript";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as prettier from "prettier";
+
+if (process.argv.length != 4) {
+  console.log(
+    `usage: ${process.argv[0]} ${process.argv[1]} WALLET_CORE_REPO OUTFILE`
+  );
+  process.exit(2);
+}
+
+const walletRootDir = process.argv[2];
+const outfile = process.argv[3];
+
+const walletCoreDir = path.join(walletRootDir, "packages/taler-wallet-core");
+const excludedNames = new Set([
+  "TalerErrorCode",
+  "WalletBackupContentV1",
+  "Array",
+]);
+
+const configFile = ts.findConfigFile(
+  walletCoreDir,
+  ts.sys.fileExists,
+  "tsconfig.json"
+);
+if (!configFile) throw Error("tsconfig.json not found");
+const { config } = ts.readConfigFile(configFile, ts.sys.readFile);
+
+const { options, fileNames, errors } = ts.parseJsonConfigFileContent(
+  config,
+  ts.sys,
+  walletCoreDir
+);
+
+const program = ts.createProgram({
+  options,
+  rootNames: fileNames,
+  configFileParsingDiagnostics: errors,
+});
+
+const checker = program.getTypeChecker();
+
+const walletApiTypesFiles = `${walletCoreDir}/src/wallet-api-types.ts`;
+console.log("api types file:", walletApiTypesFiles);
+
+const sourceFile = program.getSourceFile(walletApiTypesFiles);
+
+if (!sourceFile) {
+  throw Error();
+}
+
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+
+const fileSymbol = program.getTypeChecker().getSymbolAtLocation(sourceFile);
+
+const expo = fileSymbol?.exports;
+if (!expo) {
+  throw Error();
+}
+
+interface PerOpGatherState {
+  opName: string;
+  nameSet: Set<string>;
+  group: string;
+  /**
+   * Enum member declaration in the form 'Foo = "bar"'.
+   */
+  enumMemberDecl: string | undefined;
+}
+
+interface GatherState {
+  declTexts: Map<string, string>;
+}
+
+function gatherDecls(
+  node: ts.Node,
+  gatherState: GatherState,
+  perOpState: PerOpGatherState
+): void {
+  switch (node.kind) {
+    case ts.SyntaxKind.EnumDeclaration:
+      // Always handled via parent
+      return;
+    case ts.SyntaxKind.Identifier:
+    case ts.SyntaxKind.TypeReference: {
+      console.log(`start typeref-or-id ${node.getText()}`);
+      const type = checker.getTypeAtLocation(node);
+      if (type.flags === ts.TypeFlags.String) {
+        console.log("string!");
+        break;
+      }
+      const symbol = type.symbol || type.aliasSymbol;
+      if (!symbol) {
+        console.log(`no type symbol for ${node.getText()}`);
+        break;
+      }
+      const name = symbol.name;
+      console.log(`symbol name: ${type.symbol?.name}`);
+      console.log(`alias symbol name: ${type.aliasSymbol?.name}`);
+      if (perOpState.nameSet.has(name)) {
+        console.log("already found!");
+        break;
+      }
+      perOpState.nameSet.add(name);
+      if (excludedNames.has(name)) {
+        console.log("excluded!");
+        break;
+      }
+      const decls = symbol.getDeclarations();
+      decls?.forEach((decl) => {
+        const sourceFilename = decl.getSourceFile().fileName;
+        if (path.basename(sourceFilename).startsWith("lib.")) {
+          return;
+        }
+        switch (decl.kind) {
+          case ts.SyntaxKind.EnumMember: {
+            gatherDecls(decl.parent, gatherState, perOpState);
+            console.log("enum member", decl.getText());
+            break;
+          }
+          case ts.SyntaxKind.InterfaceDeclaration:
+          case ts.SyntaxKind.EnumDeclaration:
+          case ts.SyntaxKind.TypeAliasDeclaration: {
+            const declText = printer.printNode(
+              ts.EmitHint.Unspecified,
+              decl,
+              decl.getSourceFile()!
+            );
+            gatherState.declTexts.set(name, declText);
+            console.log(declText);
+            break;
+          }
+          default:
+            console.log(`unknown decl kind ${ts.SyntaxKind[decl.kind]}`);
+            break;
+        }
+        gatherDecls(decl, gatherState, perOpState);
+        console.log(`end typeref-or-id ${node.getText()}`);
+      });
+      break;
+    }
+    default:
+      break;
+  }
+  console.log(`syntax children for ${node.getText()}`);
+  node.forEachChild((child) => {
+    console.log(`syntax child: ${ts.SyntaxKind[child.kind]}`);
+    gatherDecls(child, gatherState, perOpState);
+  });
+  //console.log(`// unknown node kind ${ts.SyntaxKind[node.kind]}`);
+  return;
+}
+
+function getOpEnumDecl(decl: ts.Declaration): string | undefined {
+  let enumMemberDecl: undefined | string = undefined;
+  function walk(node: ts.Node) {
+    node.forEachChild((x) => {
+      console.log(`child kind: ${ts.SyntaxKind[x.kind]}`);
+      console.log(x.getText());
+      switch (x.kind) {
+        case ts.SyntaxKind.PropertySignature: {
+          const sig = x as ts.PropertySignature;
+          if (sig.name.getText() == "op") {
+            const type = checker.getTypeFromTypeNode(sig.type!);
+            enumMemberDecl = type.symbol.declarations![0]!.getText();
+          }
+          break;
+        }
+      }
+      walk(x);
+    });
+  }
+  walk(decl);
+  return enumMemberDecl;
+}
+
+const main = async () => {
+  const f = await fs.open(outfile, "w");
+  const gatherState: GatherState = {
+    declTexts: new Map<string, string>(),
+  };
+  const perOpStates: PerOpGatherState[] = [];
+
+  let currentGroup: string = "Unknown Group";
+
+  expo.forEach((v, k) => {
+    if (!v.name.endsWith("Op")) {
+      return;
+    }
+    const decls = v.getDeclarations();
+    decls?.forEach((decl) => {
+      console.log(`export decl, kind ${ts.SyntaxKind[decl.kind]}`);
+
+      const commentRanges = ts.getLeadingCommentRanges(
+        sourceFile.getFullText(),
+        decl.getFullStart()
+      );
+      commentRanges?.forEach((r) => {
+        const text = sourceFile.getFullText().slice(r.pos, r.end);
+        console.log("comment text:", text);
+        const groupPrefix = "group:";
+        const loc = text.indexOf(groupPrefix);
+        if (loc >= 0) {
+          const groupName = text.slice(loc + groupPrefix.length);
+          console.log("got new group", groupName);
+          currentGroup = groupName;
+        }
+      });
+
+      const perOpState: PerOpGatherState = {
+        opName: v.name,
+        nameSet: new Set<string>(),
+        group: currentGroup,
+        enumMemberDecl: getOpEnumDecl(decl),
+      };
+      let declText = printer.printNode(
+        ts.EmitHint.Unspecified,
+        decl,
+        decl.getSourceFile()!
+      );
+      if (perOpState.enumMemberDecl) {
+        declText = declText + `\n// ${perOpState.enumMemberDecl}\n`;
+      }
+      console.log("replacing group in", declText);
+      // Remove group comments
+      declText = declText.replace(/\/\/ group: [^\n]*[\n]/m, "");
+      perOpState.nameSet.add(v.name);
+      gatherState.declTexts.set(v.name, declText);
+      gatherDecls(decl, gatherState, perOpState);
+      perOpStates.push(perOpState);
+    });
+  });
+
+  const allNames: Set<string> = new Set();
+
+  for (const g of perOpStates) {
+    for (const k of g.nameSet.values()) {
+      allNames.add(k);
+    }
+  }
+
+  const commonNames: Set<string> = new Set();
+
+  for (const name of allNames) {
+    let count = 0;
+    for (const g of perOpStates) {
+      for (const k of g.nameSet.values()) {
+        if (name === k) {
+          count++;
+        }
+      }
+    }
+    if (count > 1) {
+      console.log(`common name: ${name}`);
+      commonNames.add(name);
+    }
+  }
+
+  const groups = new Set<string>();
+  for (const g of perOpStates) {
+    groups.add(g.group);
+  }
+
+  await f.write(`# Wallet-Core API Documentation\n`);
+
+  await f.write(
+    `This file is auto-generated from [wallet-core](https://git.taler.net/wallet-core.git/tree/packages/taler-wallet-core/src/wallet-api-types.ts).\n`
+  );
+
+  await f.write(`## Overview\n`);
+  for (const g of groups.values()) {
+    await f.write(`### ${g}\n`);
+    for (const op of perOpStates) {
+      if (op.group !== g) {
+        continue;
+      }
+      await f.write(`* [${op.opName}](#${op.opName.toLowerCase()})\n`);
+    }
+  }
+
+  await f.write(`## Operation Reference\n`);
+  for (const g of perOpStates) {
+    // Not yet supported, switch to myst first!
+    // await f.write(`(${g.opName.toLowerCase()})=\n`);
+    await f.write(`### ${g.opName}\n`);
+    for (const name of g.nameSet.values()) {
+      if (commonNames.has(name)) {
+        continue;
+      }
+      const text = gatherState.declTexts.get(name);
+      if (!text) {
+        continue;
+      }
+      await f.write("```typescript\n");
+      const formatted = prettier.format(text, {
+        semi: true,
+        parser: "typescript",
+      });
+      await f.write(`${formatted}\n`);
+      await f.write("```\n");
+    }
+    await f.write("\n");
+  }
+
+  await f.write(`## Common Declarations\n`);
+  for (const name of commonNames.values()) {
+    const text = gatherState.declTexts.get(name);
+    if (!text) {
+      continue;
+    }
+    await f.write("```typescript\n");
+    const formatted = prettier.format(text, {
+      semi: true,
+      parser: "typescript",
+    });
+    await f.write(`${formatted}`);
+    await f.write("```\n");
+  }
+
+  await f.close();
+};
+
+main();
diff --git a/extract-tsdefs/foo b/extract-tsdefs/foo
new file mode 100644
index 00000000..ade427c7
--- /dev/null
+++ b/extract-tsdefs/foo
@@ -0,0 +1,3562 @@
+# Wallet-Core API Documentation
+This file is auto-generated from [wallet-core](https://git.taler.net/wallet-core.git/tree/packages/taler-wallet-core/src/wallet-api-types.ts).
+## Overview
+### Unknown Group
+* [InitWalletOp](#initwalletop)
+* [GetVersionOp](#getversionop)
+###  Basic Wallet Information
+* [GetBalancesOp](#getbalancesop)
+* [GetBalancesDetailOp](#getbalancesdetailop)
+###  Managing Transactions
+* [GetTransactionsOp](#gettransactionsop)
+* [GetTransactionByIdOp](#gettransactionbyidop)
+* [RetryPendingNowOp](#retrypendingnowop)
+* [DeleteTransactionOp](#deletetransactionop)
+* [RetryTransactionOp](#retrytransactionop)
+* [AbortTransactionOp](#aborttransactionop)
+* [SuspendTransactionOp](#suspendtransactionop)
+* [ResumeTransactionOp](#resumetransactionop)
+###  Withdrawals
+* [GetWithdrawalDetailsForAmountOp](#getwithdrawaldetailsforamountop)
+* [GetWithdrawalDetailsForUriOp](#getwithdrawaldetailsforuriop)
+* [AcceptBankIntegratedWithdrawalOp](#acceptbankintegratedwithdrawalop)
+* [AcceptManualWithdrawalOp](#acceptmanualwithdrawalop)
+###  Merchant Payments
+* [PreparePayForUriOp](#preparepayforuriop)
+* [PreparePayForTemplateOp](#preparepayfortemplateop)
+* [GetContractTermsDetailsOp](#getcontracttermsdetailsop)
+* [ConfirmPayOp](#confirmpayop)
+* [ApplyRefundOp](#applyrefundop)
+* [ApplyRefundFromPurchaseIdOp](#applyrefundfrompurchaseidop)
+* [PrepareRefundOp](#preparerefundop)
+###  Tipping
+* [PrepareTipOp](#preparetipop)
+* [AcceptTipOp](#accepttipop)
+###  Exchange Management
+* [ListExchangesOp](#listexchangesop)
+* [AddExchangeOp](#addexchangeop)
+* [ListKnownBankAccountsOp](#listknownbankaccountsop)
+* [AddKnownBankAccountsOp](#addknownbankaccountsop)
+* [ForgetKnownBankAccountsOp](#forgetknownbankaccountsop)
+* [SetExchangeTosAcceptedOp](#setexchangetosacceptedop)
+* [GetExchangeTosOp](#getexchangetosop)
+* [GetExchangeDetailedInfoOp](#getexchangedetailedinfoop)
+* [ListCurrenciesOp](#listcurrenciesop)
+###  Deposits
+* [GenerateDepositGroupTxIdOp](#generatedepositgrouptxidop)
+* [CreateDepositGroupOp](#createdepositgroupop)
+* [PrepareDepositOp](#preparedepositop)
+###  Backups
+* [ExportBackupRecoveryOp](#exportbackuprecoveryop)
+* [ImportBackupRecoveryOp](#importbackuprecoveryop)
+* [RunBackupCycleOp](#runbackupcycleop)
+* [ExportBackupOp](#exportbackupop)
+* [AddBackupProviderOp](#addbackupproviderop)
+* [RemoveBackupProviderOp](#removebackupproviderop)
+* [GetBackupInfoOp](#getbackupinfoop)
+* [SetWalletDeviceIdOp](#setwalletdeviceidop)
+* [ExportBackupPlainOp](#exportbackupplainop)
+###  Peer Payments
+* [CheckPeerPushDebitOp](#checkpeerpushdebitop)
+* [InitiatePeerPushDebitOp](#initiatepeerpushdebitop)
+* [PreparePeerPushCreditOp](#preparepeerpushcreditop)
+* [ConfirmPeerPushCreditOp](#confirmpeerpushcreditop)
+* [CheckPeerPullCreditOp](#checkpeerpullcreditop)
+* [InitiatePeerPullCreditOp](#initiatepeerpullcreditop)
+* [PreparePeerPullDebitOp](#preparepeerpulldebitop)
+* [ConfirmPeerPullDebitOp](#confirmpeerpulldebitop)
+###  Data Validation
+* [ValidateIbanOp](#validateibanop)
+###  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)
+* [WithdrawFakebankOp](#withdrawfakebankop)
+* [GetPendingTasksOp](#getpendingtasksop)
+* [DumpCoinsOp](#dumpcoinsop)
+* [SetCoinSuspendedOp](#setcoinsuspendedop)
+* [ForceRefreshOp](#forcerefreshop)
+## Operation Reference
+### InitWalletOp
+```typescript
+/**
+ * Initialize wallet-core.
+ *
+ * Must be the request before any other operations.
+ */
+export type InitWalletOp = {
+  op: WalletApiOperation.InitWallet;
+  request: InitRequest;
+  response: InitResponse;
+};
+// InitWallet = "initWallet"
+
+```
+```typescript
+export interface InitRequest {
+  skipDefaults?: boolean;
+}
+
+```
+```typescript
+export interface InitResponse {
+  versionInfo: WalletCoreVersion;
+}
+
+```
+
+### GetVersionOp
+```typescript
+export type GetVersionOp = {
+  op: WalletApiOperation.GetVersion;
+  request: EmptyObject;
+  response: WalletCoreVersion;
+};
+// GetVersion = "getVersion"
+
+```
+
+### GetBalancesOp
+```typescript
+/**
+ * Get current wallet balance.
+ */
+export type GetBalancesOp = {
+  op: WalletApiOperation.GetBalances;
+  request: EmptyObject;
+  response: BalancesResponse;
+};
+// GetBalances = "getBalances"
+
+```
+```typescript
+export interface BalancesResponse {
+  balances: Balance[];
+}
+
+```
+```typescript
+export interface Balance {
+  scopeInfo: ScopeInfo;
+  available: AmountString;
+  pendingIncoming: AmountString;
+  pendingOutgoing: AmountString;
+  hasPendingTransactions: boolean;
+  requiresUserInput: boolean;
+}
+
+```
+```typescript
+export type ScopeInfo =
+  | {
+      type: ScopeType.Global;
+      currency: string;
+    }
+  | {
+      type: ScopeType.Exchange;
+      currency: string;
+      url: string;
+    }
+  | {
+      type: ScopeType.Auditor;
+      currency: string;
+      url: string;
+    };
+
+```
+
+### GetBalancesDetailOp
+```typescript
+export type GetBalancesDetailOp = {
+  op: WalletApiOperation.GetBalanceDetail;
+  request: GetBalanceDetailRequest;
+  response: MerchantPaymentBalanceDetails;
+};
+// GetBalanceDetail = "getBalanceDetail"
+
+```
+```typescript
+export interface GetBalanceDetailRequest {
+  currency: string;
+}
+
+```
+```typescript
+export interface MerchantPaymentBalanceDetails {
+  /**
+   * 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 "merchant-acceptable" (see balance.ts for definition).
+   */
+  balanceMerchantAcceptable: AmountJson;
+  /**
+   * Balance of type "merchant-depositable" (see balance.ts for definition).
+   */
+  balanceMerchantDepositable: 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;
+}
+
+```
+
+### 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
+   */
+  currency?: string;
+  /**
+   * if present, results will be limited to transactions related to the given search string
+   */
+  search?: string;
+  /**
+   * If true, include all refreshes in the transactions list.
+   */
+  includeRefreshes?: boolean;
+}
+
+```
+```typescript
+export interface TransactionsResponse {
+  transactions: Transaction[];
+}
+
+```
+
+### GetTransactionByIdOp
+```typescript
+export type GetTransactionByIdOp = {
+  op: WalletApiOperation.GetTransactionById;
+  request: TransactionByIdRequest;
+  response: Transaction;
+};
+// GetTransactionById = "getTransactionById"
+
+```
+```typescript
+export interface TransactionByIdRequest {
+  transactionId: string;
+}
+
+```
+
+### RetryPendingNowOp
+```typescript
+export type RetryPendingNowOp = {
+  op: WalletApiOperation.RetryPendingNow;
+  request: EmptyObject;
+  response: EmptyObject;
+};
+// RetryPendingNow = "retryPendingNow"
+
+```
+
+### 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: string;
+}
+
+```
+
+### RetryTransactionOp
+```typescript
+/**
+ * Immediately retry a transaction.
+ */
+export type RetryTransactionOp = {
+  op: WalletApiOperation.RetryTransaction;
+  request: RetryTransactionRequest;
+  response: EmptyObject;
+};
+// RetryTransaction = "retryTransaction"
+
+```
+```typescript
+export interface RetryTransactionRequest {
+  transactionId: string;
+}
+
+```
+
+### 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"
+
+```
+
+### 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: ManualWithdrawalDetails;
+};
+// GetWithdrawalDetailsForAmount = "getWithdrawalDetailsForAmount"
+
+```
+```typescript
+export interface GetWithdrawalDetailsForAmountRequest {
+  exchangeBaseUrl: string;
+  amount: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface ManualWithdrawalDetails {
+  /**
+   * Did the user accept the current version of the exchange's
+   * terms of service?
+   */
+  tosAccepted: boolean;
+  /**
+   * Amount that the user will transfer to the exchange.
+   */
+  amountRaw: AmountString;
+  /**
+   * Amount that will be added to the user's wallet balance.
+   */
+  amountEffective: AmountString;
+  /**
+   * Ways to pay the exchange.
+   */
+  paytoUris: string[];
+  /**
+   * If the exchange supports age-restricted coins it will return
+   * the array of ages.
+   */
+  ageRestrictionOptions?: number[];
+}
+
+```
+
+### GetWithdrawalDetailsForUriOp
+```typescript
+/**
+ * Get details for withdrawing via a particular taler:// URI.
+ */
+export type GetWithdrawalDetailsForUriOp = {
+  op: WalletApiOperation.GetWithdrawalDetailsForUri;
+  request: GetWithdrawalDetailsForUriRequest;
+  response: WithdrawUriInfoResponse;
+};
+// GetWithdrawalDetailsForUri = "getWithdrawalDetailsForUri"
+
+```
+```typescript
+export interface GetWithdrawalDetailsForUriRequest {
+  talerWithdrawUri: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface WithdrawUriInfoResponse {
+  amount: AmountString;
+  defaultExchangeBaseUrl?: string;
+  possibleExchanges: ExchangeListItem[];
+}
+
+```
+
+### AcceptBankIntegratedWithdrawalOp
+```typescript
+/**
+ * Accept a bank-integrated withdrawal.
+ */
+export type AcceptBankIntegratedWithdrawalOp = {
+  op: WalletApiOperation.AcceptBankIntegratedWithdrawal;
+  request: AcceptBankIntegratedWithdrawalRequest;
+  response: AcceptWithdrawalResponse;
+};
+// AcceptBankIntegratedWithdrawal = "acceptBankIntegratedWithdrawal"
+
+```
+```typescript
+export interface AcceptBankIntegratedWithdrawalRequest {
+  talerWithdrawUri: string;
+  exchangeBaseUrl: string;
+  forcedDenomSel?: ForcedDenomSel;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptWithdrawalResponse {
+  reservePub: string;
+  confirmTransferUrl?: string;
+  transactionId: string;
+}
+
+```
+
+### 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: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptManualWithdrawalResult {
+  /**
+   * Payto URIs that can be used to fund the withdrawal.
+   */
+  exchangePaytoUris: string[];
+  /**
+   * Public key of the newly created reserve.
+   */
+  reservePub: string;
+  transactionId: string;
+}
+
+```
+
+### 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"
+
+```
+```typescript
+export interface PreparePayRequest {
+  talerPayUri: string;
+}
+
+```
+
+### 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"
+
+```
+```typescript
+export interface PreparePayTemplateRequest {
+  talerPayTemplateUri: string;
+  templateParams: Record<string, string>;
+}
+
+```
+
+### GetContractTermsDetailsOp
+```typescript
+export type GetContractTermsDetailsOp = {
+  op: WalletApiOperation.GetContractTermsDetails;
+  request: GetContractTermsDetailsRequest;
+  response: WalletContractData;
+};
+// GetContractTermsDetails = "getContractTermsDetails"
+
+```
+```typescript
+export interface GetContractTermsDetailsRequest {
+  proposalId: string;
+}
+
+```
+```typescript
+/**
+ * Data extracted from the contract terms that is relevant for payment
+ * processing in the wallet.
+ */
+export interface WalletContractData {
+  products?: Product[];
+  summaryI18n:
+    | {
+        [lang_tag: string]: string;
+      }
+    | undefined;
+  /**
+   * Fulfillment URL, or the empty string if the order has no fulfillment URL.
+   *
+   * Stored as a non-nullable string as we use this field for IndexedDB indexing.
+   */
+  fulfillmentUrl: string;
+  contractTermsHash: string;
+  fulfillmentMessage?: string;
+  fulfillmentMessageI18n?: InternationalizedString;
+  merchantSig: string;
+  merchantPub: string;
+  merchant: MerchantInfo;
+  amount: AmountString;
+  orderId: string;
+  merchantBaseUrl: string;
+  summary: string;
+  autoRefund: TalerProtocolDuration | undefined;
+  maxWireFee: AmountString;
+  wireFeeAmortization: number;
+  payDeadline: TalerProtocolTimestamp;
+  refundDeadline: TalerProtocolTimestamp;
+  allowedAuditors: AllowedAuditorInfo[];
+  allowedExchanges: AllowedExchangeInfo[];
+  timestamp: TalerProtocolTimestamp;
+  wireMethod: string;
+  wireInfoHash: string;
+  maxDepositFee: AmountString;
+  minimumAge?: number;
+  deliveryDate: TalerProtocolTimestamp | undefined;
+  deliveryLocation: Location | undefined;
+}
+
+```
+```typescript
+export interface AllowedAuditorInfo {
+  auditorBaseUrl: string;
+  auditorPub: string;
+}
+
+```
+```typescript
+export interface AllowedExchangeInfo {
+  exchangeBaseUrl: string;
+  exchangePub: 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 {
+  proposalId: string;
+  sessionId?: string;
+  forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export type ConfirmPayResult = ConfirmPayResultDone | ConfirmPayResultPending;
+
+```
+```typescript
+/**
+ * Result for confirmPay
+ */
+export interface ConfirmPayResultDone {
+  type: ConfirmPayResultType.Done;
+  contractTerms: MerchantContractTerms;
+  transactionId: string;
+}
+
+```
+```typescript
+export interface ConfirmPayResultPending {
+  type: ConfirmPayResultType.Pending;
+  transactionId: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+
+### ApplyRefundOp
+```typescript
+/**
+ * Check for a refund based on a taler://refund URI.
+ */
+export type ApplyRefundOp = {
+  op: WalletApiOperation.ApplyRefund;
+  request: ApplyRefundRequest;
+  response: ApplyRefundResponse;
+};
+// ApplyRefund = "applyRefund"
+
+```
+```typescript
+export interface ApplyRefundRequest {
+  talerRefundUri: string;
+}
+
+```
+
+### ApplyRefundFromPurchaseIdOp
+```typescript
+export type ApplyRefundFromPurchaseIdOp = {
+  op: WalletApiOperation.ApplyRefundFromPurchaseId;
+  request: ApplyRefundFromPurchaseIdRequest;
+  response: ApplyRefundResponse;
+};
+// ApplyRefundFromPurchaseId = "applyRefundFromPurchaseId"
+
+```
+```typescript
+export interface ApplyRefundFromPurchaseIdRequest {
+  purchaseId: string;
+}
+
+```
+
+### PrepareRefundOp
+```typescript
+export type PrepareRefundOp = {
+  op: WalletApiOperation.PrepareRefund;
+  request: PrepareRefundRequest;
+  response: PrepareRefundResult;
+};
+// PrepareRefund = "prepareRefund"
+
+```
+```typescript
+export interface PrepareRefundRequest {
+  talerRefundUri: string;
+}
+
+```
+```typescript
+export interface PrepareRefundResult {
+  proposalId: string;
+  effectivePaid: AmountString;
+  gone: AmountString;
+  granted: AmountString;
+  pending: boolean;
+  awaiting: AmountString;
+  info: OrderShortInfo;
+}
+
+```
+
+### PrepareTipOp
+```typescript
+/**
+ * Query and store information about a tip.
+ */
+export type PrepareTipOp = {
+  op: WalletApiOperation.PrepareTip;
+  request: PrepareTipRequest;
+  response: PrepareTipResult;
+};
+// PrepareTip = "prepareTip"
+
+```
+```typescript
+export interface PrepareTipRequest {
+  talerTipUri: string;
+}
+
+```
+```typescript
+export interface PrepareTipResult {
+  /**
+   * Unique ID for the tip assigned by the wallet.
+   * Typically different from the merchant-generated tip ID.
+   */
+  walletTipId: string;
+  /**
+   * Has the tip already been accepted?
+   */
+  accepted: boolean;
+  /**
+   * Amount that the merchant gave.
+   */
+  tipAmountRaw: AmountString;
+  /**
+   * Amount that arrived at the wallet.
+   * Might be lower than the raw amount due to fees.
+   */
+  tipAmountEffective: AmountString;
+  /**
+   * Base URL of the merchant backend giving then tip.
+   */
+  merchantBaseUrl: string;
+  /**
+   * Base URL of the exchange that is used to withdraw the tip.
+   * Determined by the merchant, the wallet/user has no choice here.
+   */
+  exchangeBaseUrl: string;
+  /**
+   * Time when the tip will expire.  After it expired, it can't be picked
+   * up anymore.
+   */
+  expirationTimestamp: TalerProtocolTimestamp;
+}
+
+```
+
+### AcceptTipOp
+```typescript
+/**
+ * Accept a tip.
+ */
+export type AcceptTipOp = {
+  op: WalletApiOperation.AcceptTip;
+  request: AcceptTipRequest;
+  response: AcceptTipResponse;
+};
+// AcceptTip = "acceptTip"
+
+```
+```typescript
+export interface AcceptTipRequest {
+  walletTipId: string;
+}
+
+```
+```typescript
+export interface AcceptTipResponse {
+  transactionId: string;
+  next_url?: string;
+}
+
+```
+
+### ListExchangesOp
+```typescript
+/**
+ * List exchanges known to the wallet.
+ */
+export type ListExchangesOp = {
+  op: WalletApiOperation.ListExchanges;
+  request: EmptyObject;
+  response: ExchangesListResponse;
+};
+// ListExchanges = "listExchanges"
+
+```
+```typescript
+export interface ExchangesListResponse {
+  exchanges: ExchangeListItem[];
+}
+
+```
+
+### AddExchangeOp
+```typescript
+/**
+ * Add / force-update an exchange.
+ */
+export type AddExchangeOp = {
+  op: WalletApiOperation.AddExchange;
+  request: AddExchangeRequest;
+  response: EmptyObject;
+};
+// AddExchange = "addExchange"
+
+```
+
+### ListKnownBankAccountsOp
+```typescript
+export type ListKnownBankAccountsOp = {
+  op: WalletApiOperation.ListKnownBankAccounts;
+  request: ListKnownBankAccountsRequest;
+  response: KnownBankAccounts;
+};
+// ListKnownBankAccounts = "listKnownBankAccounts"
+
+```
+```typescript
+export interface ListKnownBankAccountsRequest {
+  currency?: string;
+}
+
+```
+```typescript
+export interface KnownBankAccounts {
+  accounts: KnownBankAccountsInfo[];
+}
+
+```
+```typescript
+export interface KnownBankAccountsInfo {
+  uri: PaytoUri;
+  kyc_completed: boolean;
+  currency: string;
+  alias: string;
+}
+
+```
+```typescript
+export type PaytoUri =
+  | PaytoUriUnknown
+  | PaytoUriIBAN
+  | PaytoUriTalerBank
+  | PaytoUriBitcoin;
+
+```
+```typescript
+export interface PaytoUriUnknown extends PaytoUriGeneric {
+  isKnown: false;
+}
+
+```
+```typescript
+export interface PaytoUriGeneric {
+  targetType: string;
+  targetPath: string;
+  params: {
+    [name: string]: string;
+  };
+}
+
+```
+```typescript
+export interface PaytoUriIBAN extends PaytoUriGeneric {
+  isKnown: true;
+  targetType: "iban";
+  iban: string;
+  bic?: string;
+}
+
+```
+```typescript
+export interface PaytoUriTalerBank extends PaytoUriGeneric {
+  isKnown: true;
+  targetType: "x-taler-bank";
+  host: string;
+  account: string;
+}
+
+```
+```typescript
+export interface PaytoUriBitcoin extends PaytoUriGeneric {
+  isKnown: true;
+  targetType: "bitcoin";
+  segwitAddrs: Array<string>;
+}
+
+```
+
+### AddKnownBankAccountsOp
+```typescript
+export type AddKnownBankAccountsOp = {
+  op: WalletApiOperation.AddKnownBankAccounts;
+  request: AddKnownBankAccountsRequest;
+  response: EmptyObject;
+};
+// AddKnownBankAccounts = "addKnownBankAccounts"
+
+```
+```typescript
+export interface AddKnownBankAccountsRequest {
+  payto: string;
+  alias: string;
+  currency: string;
+}
+
+```
+
+### ForgetKnownBankAccountsOp
+```typescript
+export type ForgetKnownBankAccountsOp = {
+  op: WalletApiOperation.ForgetKnownBankAccounts;
+  request: ForgetKnownBankAccountsRequest;
+  response: EmptyObject;
+};
+// ForgetKnownBankAccounts = "forgetKnownBankAccounts"
+
+```
+```typescript
+export interface ForgetKnownBankAccountsRequest {
+  payto: 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"
+
+```
+```typescript
+export interface AcceptExchangeTosRequest {
+  exchangeBaseUrl: string;
+  etag: string | undefined;
+}
+
+```
+
+### 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[];
+}
+
+```
+```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;
+  tosStatus: ExchangeTosStatus;
+}
+
+```
+
+### GetExchangeDetailedInfoOp
+```typescript
+/**
+ * Get the current terms of a service of an exchange.
+ */
+export type GetExchangeDetailedInfoOp = {
+  op: WalletApiOperation.GetExchangeDetailedInfo;
+  request: AddExchangeRequest;
+  response: ExchangeDetailedResponse;
+};
+// GetExchangeDetailedInfo = "getExchangeDetailedInfo"
+
+```
+```typescript
+export interface ExchangeDetailedResponse {
+  exchange: ExchangeFullDetails;
+}
+
+```
+```typescript
+export interface ExchangeFullDetails {
+  exchangeBaseUrl: string;
+  currency: string;
+  paytoUris: string[];
+  tos: ExchangeTosStatusDetails;
+  auditors: ExchangeAuditor[];
+  wireInfo: WireInfo;
+  denomFees: DenomOperationMap<FeeDescription[]>;
+  transferFees: Record<string, FeeDescription[]>;
+  globalFees: FeeDescription[];
+}
+
+```
+```typescript
+export interface ExchangeTosStatusDetails {
+  acceptedVersion?: string;
+  currentVersion?: string;
+  contentType?: string;
+  content?: string;
+}
+
+```
+```typescript
+export interface WireInfo {
+  feesForType: WireFeeMap;
+  accounts: ExchangeAccount[];
+}
+
+```
+```typescript
+/**
+ * Information about one of the exchange's bank accounts.
+ */
+export interface ExchangeAccount {
+  payto_uri: string;
+  master_sig: string;
+}
+
+```
+```typescript
+export interface FeeDescription {
+  group: string;
+  from: AbsoluteTime;
+  until: AbsoluteTime;
+  fee?: AmountString;
+}
+
+```
+
+### ListCurrenciesOp
+```typescript
+/**
+ * List currencies known to the wallet.
+ */
+export type ListCurrenciesOp = {
+  op: WalletApiOperation.ListCurrencies;
+  request: EmptyObject;
+  response: WalletCurrencyInfo;
+};
+// ListCurrencies = "listCurrencies"
+
+```
+```typescript
+export interface WalletCurrencyInfo {
+  trustedAuditors: {
+    currency: string;
+    auditorPub: string;
+    auditorBaseUrl: string;
+  }[];
+  trustedExchanges: {
+    currency: string;
+    exchangeMasterPub: string;
+    exchangeBaseUrl: string;
+  }[];
+}
+
+```
+
+### GenerateDepositGroupTxIdOp
+```typescript
+/**
+ * Generate a fresh transaction ID for a deposit group.
+ *
+ * The resulting transaction ID can be specified when creating
+ * a deposit group, so that the client can already start waiting for notifications
+ * on that specific deposit group before the GreateDepositGroup request returns.
+ */
+export type GenerateDepositGroupTxIdOp = {
+  op: WalletApiOperation.GenerateDepositGroupTxId;
+  request: EmptyObject;
+  response: TxIdResponse;
+};
+// GenerateDepositGroupTxId = "generateDepositGroupTxId"
+
+```
+```typescript
+export interface TxIdResponse {
+  transactionId: string;
+}
+
+```
+
+### 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 {
+  /**
+   * 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?: string;
+  depositPaytoUri: string;
+  amount: AmountString;
+}
+
+```
+```typescript
+export interface CreateDepositGroupResponse {
+  depositGroupId: string;
+  transactionId: string;
+}
+
+```
+
+### PrepareDepositOp
+```typescript
+export type PrepareDepositOp = {
+  op: WalletApiOperation.PrepareDeposit;
+  request: PrepareDepositRequest;
+  response: PrepareDepositResponse;
+};
+// PrepareDeposit = "prepareDeposit"
+
+```
+```typescript
+export interface PrepareDepositRequest {
+  depositPaytoUri: string;
+  amount: AmountString;
+}
+
+```
+```typescript
+export interface PrepareDepositResponse {
+  totalDepositCost: AmountString;
+  effectiveDepositAmount: AmountString;
+  fees: DepositGroupFees;
+}
+
+```
+```typescript
+export interface DepositGroupFees {
+  coin: AmountString;
+  wire: AmountString;
+  refresh: AmountString;
+}
+
+```
+
+### ExportBackupRecoveryOp
+```typescript
+/**
+ * Export the recovery information for the wallet.
+ */
+export type ExportBackupRecoveryOp = {
+  op: WalletApiOperation.ExportBackupRecovery;
+  request: EmptyObject;
+  response: BackupRecovery;
+};
+// ExportBackupRecovery = "exportBackupRecovery"
+
+```
+
+### ImportBackupRecoveryOp
+```typescript
+/**
+ * Import recovery information into the wallet.
+ */
+export type ImportBackupRecoveryOp = {
+  op: WalletApiOperation.ImportBackupRecovery;
+  request: RecoveryLoadRequest;
+  response: EmptyObject;
+};
+// ImportBackupRecovery = "importBackupRecovery"
+
+```
+```typescript
+/**
+ * Load recovery information into the wallet.
+ */
+export interface RecoveryLoadRequest {
+  recovery: BackupRecovery;
+  strategy?: RecoveryMergeStrategy;
+}
+
+```
+```typescript
+/**
+ * Strategy for loading recovery information.
+ */
+export declare enum RecoveryMergeStrategy {
+  /**
+   * Keep the local wallet root key, import and take over providers.
+   */
+  Ours = "ours",
+  /**
+   * Migrate to the wallet root key from the recovery information.
+   */
+  Theirs = "theirs",
+}
+
+```
+
+### RunBackupCycleOp
+```typescript
+/**
+ * Manually make and upload a backup.
+ */
+export type RunBackupCycleOp = {
+  op: WalletApiOperation.RunBackupCycle;
+  request: RunBackupCycleRequest;
+  response: EmptyObject;
+};
+// RunBackupCycle = "runBackupCycle"
+
+```
+```typescript
+export interface RunBackupCycleRequest {
+  /**
+   * List of providers to backup or empty for all known providers.
+   */
+  providers?: Array<string>;
+}
+
+```
+
+### ExportBackupOp
+```typescript
+export type ExportBackupOp = {
+  op: WalletApiOperation.ExportBackup;
+  request: EmptyObject;
+  response: EmptyObject;
+};
+// ExportBackup = "exportBackup"
+
+```
+
+### AddBackupProviderOp
+```typescript
+/**
+ * Add a new backup provider.
+ */
+export type AddBackupProviderOp = {
+  op: WalletApiOperation.AddBackupProvider;
+  request: AddBackupProviderRequest;
+  response: AddBackupProviderResponse;
+};
+// AddBackupProvider = "addBackupProvider"
+
+```
+```typescript
+export interface AddBackupProviderRequest {
+  backupProviderBaseUrl: string;
+  name: string;
+  /**
+   * Activate the provider.  Should only be done after
+   * the user has reviewed the provider.
+   */
+  activate?: boolean;
+}
+
+```
+```typescript
+export type AddBackupProviderResponse =
+  | AddBackupProviderOk
+  | AddBackupProviderPaymentRequired;
+
+```
+```typescript
+interface AddBackupProviderOk {
+  status: "ok";
+}
+
+```
+```typescript
+interface AddBackupProviderPaymentRequired {
+  status: "payment-required";
+  talerUri?: string;
+}
+
+```
+
+### RemoveBackupProviderOp
+```typescript
+export type RemoveBackupProviderOp = {
+  op: WalletApiOperation.RemoveBackupProvider;
+  request: RemoveBackupProviderRequest;
+  response: EmptyObject;
+};
+// RemoveBackupProvider = "removeBackupProvider"
+
+```
+```typescript
+export interface RemoveBackupProviderRequest {
+  provider: string;
+}
+
+```
+
+### GetBackupInfoOp
+```typescript
+/**
+ * Get some useful stats about the backup state.
+ */
+export type GetBackupInfoOp = {
+  op: WalletApiOperation.GetBackupInfo;
+  request: EmptyObject;
+  response: BackupInfo;
+};
+// GetBackupInfo = "getBackupInfo"
+
+```
+```typescript
+export interface BackupInfo {
+  walletRootPub: string;
+  deviceId: string;
+  providers: ProviderInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about one provider.
+ *
+ * We don't store the account key here,
+ * as that's derived from the wallet root key.
+ */
+export interface ProviderInfo {
+  active: boolean;
+  syncProviderBaseUrl: string;
+  name: string;
+  terms?: BackupProviderTerms;
+  /**
+   * Last communication issue with the provider.
+   */
+  lastError?: TalerErrorDetail;
+  lastSuccessfulBackupTimestamp?: TalerProtocolTimestamp;
+  lastAttemptedBackupTimestamp?: TalerProtocolTimestamp;
+  paymentProposalIds: string[];
+  backupProblem?: BackupProblem;
+  paymentStatus: ProviderPaymentStatus;
+}
+
+```
+```typescript
+export interface BackupProviderTerms {
+  supportedProtocolVersion: string;
+  annualFee: AmountString;
+  storageLimitInMegabytes: number;
+}
+
+```
+```typescript
+export type BackupProblem =
+  | BackupUnreadableProblem
+  | BackupConflictingDeviceProblem;
+
+```
+```typescript
+export interface BackupUnreadableProblem {
+  type: "backup-unreadable";
+}
+
+```
+```typescript
+export interface BackupConflictingDeviceProblem {
+  type: "backup-conflicting-device";
+  otherDeviceId: string;
+  myDeviceId: string;
+  backupTimestamp: AbsoluteTime;
+}
+
+```
+```typescript
+export type ProviderPaymentStatus =
+  | ProviderPaymentTermsChanged
+  | ProviderPaymentPaid
+  | ProviderPaymentInsufficientBalance
+  | ProviderPaymentUnpaid
+  | ProviderPaymentPending;
+
+```
+```typescript
+export interface ProviderPaymentTermsChanged {
+  type: ProviderPaymentType.TermsChanged;
+  paidUntil: AbsoluteTime;
+  oldTerms: BackupProviderTerms;
+  newTerms: BackupProviderTerms;
+}
+
+```
+```typescript
+export interface ProviderPaymentPaid {
+  type: ProviderPaymentType.Paid;
+  paidUntil: AbsoluteTime;
+}
+
+```
+```typescript
+export interface ProviderPaymentInsufficientBalance {
+  type: ProviderPaymentType.InsufficientBalance;
+  amount: AmountString;
+}
+
+```
+```typescript
+export interface ProviderPaymentUnpaid {
+  type: ProviderPaymentType.Unpaid;
+}
+
+```
+```typescript
+export interface ProviderPaymentPending {
+  type: ProviderPaymentType.Pending;
+  talerUri?: string;
+}
+
+```
+
+### SetWalletDeviceIdOp
+```typescript
+/**
+ * Set the internal device ID of the wallet, used to
+ * identify whether a different/new wallet is accessing
+ * the backup of another wallet.
+ */
+export type SetWalletDeviceIdOp = {
+  op: WalletApiOperation.SetWalletDeviceId;
+  request: SetWalletDeviceIdRequest;
+  response: EmptyObject;
+};
+// SetWalletDeviceId = "setWalletDeviceId"
+
+```
+```typescript
+export interface SetWalletDeviceIdRequest {
+  /**
+   * New wallet device ID to set.
+   */
+  walletDeviceId: string;
+}
+
+```
+
+### ExportBackupPlainOp
+```typescript
+/**
+ * Export a backup JSON, mostly useful for testing.
+ */
+export type ExportBackupPlainOp = {
+  op: WalletApiOperation.ExportBackupPlain;
+  request: EmptyObject;
+  response: WalletBackupContentV1;
+};
+// ExportBackupPlain = "exportBackupPlain"
+
+```
+
+### 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: CheckPeerPushDebitResponse;
+};
+// CheckPeerPushDebit = "checkPeerPushDebit"
+
+```
+```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;
+}
+
+```
+```typescript
+export interface CheckPeerPushDebitResponse {
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+}
+
+```
+
+### InitiatePeerPushDebitOp
+```typescript
+/**
+ * Initiate an outgoing peer push payment.
+ */
+export type InitiatePeerPushDebitOp = {
+  op: WalletApiOperation.InitiatePeerPushDebit;
+  request: InitiatePeerPushPaymentRequest;
+  response: InitiatePeerPushPaymentResponse;
+};
+// InitiatePeerPushDebit = "initiatePeerPushDebit"
+
+```
+```typescript
+export interface InitiatePeerPushPaymentRequest {
+  exchangeBaseUrl?: string;
+  partialContractTerms: PeerContractTerms;
+}
+
+```
+```typescript
+export interface InitiatePeerPushPaymentResponse {
+  exchangeBaseUrl: string;
+  pursePub: string;
+  mergePriv: string;
+  contractPriv: string;
+  talerUri: string;
+  transactionId: string;
+}
+
+```
+
+### PreparePeerPushCreditOp
+```typescript
+/**
+ * Check an incoming peer push payment.
+ */
+export type PreparePeerPushCreditOp = {
+  op: WalletApiOperation.PreparePeerPushCredit;
+  request: PreparePeerPushCredit;
+  response: PreparePeerPushCreditResponse;
+};
+// PreparePeerPushCredit = "preparePeerPushCredit"
+
+```
+```typescript
+export interface PreparePeerPushCreditResponse {
+  contractTerms: PeerContractTerms;
+  /**
+   * @deprecated
+   */
+  amount: AmountString;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+  peerPushPaymentIncomingId: string;
+}
+
+```
+
+### ConfirmPeerPushCreditOp
+```typescript
+/**
+ * Accept an incoming peer push payment.
+ */
+export type ConfirmPeerPushCreditOp = {
+  op: WalletApiOperation.ConfirmPeerPushCredit;
+  request: ConfirmPeerPushCreditRequest;
+  response: EmptyObject;
+};
+// ConfirmPeerPushCredit = "confirmPeerPushCredit"
+
+```
+```typescript
+export interface ConfirmPeerPushCreditRequest {
+  /**
+   * Transparent identifier of the incoming peer push payment.
+   */
+  peerPushPaymentIncomingId: string;
+}
+
+```
+
+### 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 {
+  exchangeBaseUrl?: string;
+  amount: AmountString;
+}
+
+```
+```typescript
+export interface CheckPeerPullCreditResponse {
+  exchangeBaseUrl: string;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+}
+
+```
+
+### 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;
+}
+
+```
+```typescript
+export interface InitiatePeerPullCreditResponse {
+  /**
+   * Taler URI for the other party to make the payment
+   * that was requested.
+   */
+  talerUri: string;
+  transactionId: string;
+}
+
+```
+
+### PreparePeerPullDebitOp
+```typescript
+/**
+ * Prepare for an incoming peer pull payment.
+ */
+export type PreparePeerPullDebitOp = {
+  op: WalletApiOperation.PreparePeerPullDebit;
+  request: PreparePeerPullDebitRequest;
+  response: PreparePeerPullDebitResponse;
+};
+// PreparePeerPullDebit = "preparePeerPullDebit"
+
+```
+```typescript
+export interface PreparePeerPullDebitRequest {
+  talerUri: string;
+}
+
+```
+```typescript
+export interface PreparePeerPullDebitResponse {
+  contractTerms: PeerContractTerms;
+  /**
+   * @deprecated Redundant field with bad name, will be removed soon.
+   */
+  amount: AmountString;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+  peerPullPaymentIncomingId: string;
+}
+
+```
+
+### ConfirmPeerPullDebitOp
+```typescript
+/**
+ * Accept an incoming peer pull payment (i.e. pay the other party).
+ */
+export type ConfirmPeerPullDebitOp = {
+  op: WalletApiOperation.ConfirmPeerPullDebit;
+  request: ConfirmPeerPullDebitRequest;
+  response: EmptyObject;
+};
+// ConfirmPeerPullDebit = "confirmPeerPullDebit"
+
+```
+```typescript
+export interface ConfirmPeerPullDebitRequest {
+  /**
+   * Transparent identifier of the incoming peer pull payment.
+   */
+  peerPullPaymentIncomingId: string;
+}
+
+```
+
+### 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;
+}
+
+```
+
+### 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: any;
+  response: any;
+};
+// ImportDb = "importDb"
+
+```
+
+### 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"
+
+```
+
+### RunIntegrationTestV2Op
+```typescript
+/**
+ * Run a simple integration test on a test deployment
+ * of the exchange and merchant.
+ */
+export type RunIntegrationTestV2Op = {
+  op: WalletApiOperation.RunIntegrationTestV2;
+  request: IntegrationTestArgs;
+  response: EmptyObject;
+};
+// RunIntegrationTestV2 = "runIntegrationTestV2"
+
+```
+
+### 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: EmptyObject;
+};
+// WithdrawTestBalance = "withdrawTestBalance"
+
+```
+```typescript
+export interface WithdrawTestBalanceRequest {
+  amount: string;
+  /**
+   * Bank access API base URL.
+   */
+  bankAccessApiBaseUrl: string;
+  exchangeBaseUrl: string;
+  forcedDenomSel?: ForcedDenomSel;
+}
+
+```
+
+### WithdrawTestkudosOp
+```typescript
+/**
+ * Make a withdrawal of testkudos on test.taler.net.
+ */
+export type WithdrawTestkudosOp = {
+  op: WalletApiOperation.WithdrawTestkudos;
+  request: EmptyObject;
+  response: EmptyObject;
+};
+// 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: string;
+  summary: string;
+  forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export interface TestPayResult {
+  payCoinSelection: PayCoinSelection;
+}
+
+```
+```typescript
+/**
+ * Result of selecting coins, contains the exchange, and selected
+ * coins with their denomination.
+ */
+export interface PayCoinSelection {
+  /**
+   * Amount requested by the merchant.
+   */
+  paymentAmount: AmountString;
+  /**
+   * Public keys of the coins that were selected.
+   */
+  coinPubs: string[];
+  /**
+   * Amount that each coin contributes.
+   */
+  coinContributions: AmountString[];
+  /**
+   * How much of the wire fees is the customer paying?
+   */
+  customerWireFees: AmountString;
+  /**
+   * How much of the deposit fees is the customer paying?
+   */
+  customerDepositFees: AmountString;
+}
+
+```
+
+### WithdrawFakebankOp
+```typescript
+/**
+ * Make a withdrawal from a fakebank, i.e.
+ * a bank where test users can be registered freely
+ * and testing APIs are available.
+ */
+export type WithdrawFakebankOp = {
+  op: WalletApiOperation.WithdrawFakebank;
+  request: WithdrawFakebankRequest;
+  response: EmptyObject;
+};
+// WithdrawFakebank = "withdrawFakebank"
+
+```
+```typescript
+export interface WithdrawFakebankRequest {
+  amount: AmountString;
+  exchange: string;
+  bank: string;
+}
+
+```
+
+### GetPendingTasksOp
+```typescript
+/**
+ * Get wallet-internal pending tasks.
+ */
+export type GetPendingTasksOp = {
+  op: WalletApiOperation.GetPendingOperations;
+  request: EmptyObject;
+  response: PendingTasksResponse;
+};
+// GetPendingOperations = "getPendingOperations"
+
+```
+```typescript
+/**
+ * Response returned from the pending operations API.
+ */
+export interface PendingOperationsResponse {
+  /**
+   * List of pending operations.
+   */
+  pendingOperations: PendingTaskInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about a pending operation.
+ */
+export type PendingTaskInfo = PendingTaskInfoCommon &
+  (
+    | PendingExchangeUpdateTask
+    | PendingExchangeCheckRefreshTask
+    | PendingPurchaseTask
+    | PendingRefreshTask
+    | PendingTipPickupTask
+    | PendingWithdrawTask
+    | PendingRecoupTask
+    | PendingDepositTask
+    | PendingBackupTask
+    | PendingPeerPushInitiationTask
+    | PendingPeerPullInitiationTask
+    | PendingPeerPullDebitTask
+    | PendingPeerPushCreditTask
+  );
+
+```
+```typescript
+/**
+ * Fields that are present in every pending operation.
+ */
+export interface PendingTaskInfoCommon {
+  /**
+   * Type of the pending operation.
+   */
+  type: PendingTaskType;
+  /**
+   * Unique identifier for the pending task.
+   */
+  id: string;
+  /**
+   * Set to true if the operation indicates that something is really in progress,
+   * as opposed to some regular scheduled operation that can be tried later.
+   */
+  givesLifeness: boolean;
+  /**
+   * Operation is active and waiting for a longpoll result.
+   */
+  isLongpolling: boolean;
+  /**
+   * Operation is waiting to be executed.
+   */
+  isDue: boolean;
+  /**
+   * Timestamp when the pending operation should be executed next.
+   */
+  timestampDue: AbsoluteTime;
+  /**
+   * Retry info.  Currently used to stop the wallet after any operation
+   * exceeds a number of retries.
+   */
+  retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+export enum PendingTaskType {
+  ExchangeUpdate = "exchange-update",
+  ExchangeCheckRefresh = "exchange-check-refresh",
+  Purchase = "purchase",
+  Refresh = "refresh",
+  Recoup = "recoup",
+  TipPickup = "tip-pickup",
+  Withdraw = "withdraw",
+  Deposit = "deposit",
+  Backup = "backup",
+  // FIXME: Rename to peer-push-debit and peer-pull-debit
+  PeerPushInitiation = "peer-push-initiation",
+  PeerPullInitiation = "peer-pull-initiation",
+  PeerPushCredit = "peer-push-credit",
+  PeerPullDebit = "peer-pull-debit",
+}
+
+```
+```typescript
+export interface RetryInfo {
+  firstTry: AbsoluteTime;
+  nextRetry: AbsoluteTime;
+  retryCounter: number;
+}
+
+```
+```typescript
+export interface RetryPolicy {
+  readonly backoffDelta: Duration;
+  readonly backoffBase: number;
+  readonly maxTimeout: Duration;
+}
+
+```
+```typescript
+// Declare "static" methods in Error
+interface ErrorConstructor {
+  /** Create .stack property on a target object */
+  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+  /**
+   * Optional override for formatting stack traces
+   *
+   * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+   */
+  prepareStackTrace?:
+    | ((err: Error, stackTraces: NodeJS.CallSite[]) => any)
+    | undefined;
+  stackTraceLimit: number;
+}
+
+```
+```typescript
+interface CallSite {
+  /**
+   * Value of "this"
+   */
+  getThis(): unknown;
+  /**
+   * Type of "this" as a string.
+   * This is the name of the function stored in the constructor field of
+   * "this", if available.  Otherwise the object's [[Class]] internal
+   * property.
+   */
+  getTypeName(): string | null;
+  /**
+   * Current function
+   */
+  getFunction(): Function | undefined;
+  /**
+   * Name of the current function, typically its name property.
+   * If a name property is not available an attempt will be made to try
+   * to infer a name from the function's context.
+   */
+  getFunctionName(): string | null;
+  /**
+   * Name of the property [of "this" or one of its prototypes] that holds
+   * the current function
+   */
+  getMethodName(): string | null;
+  /**
+   * Name of the script [if this function was defined in a script]
+   */
+  getFileName(): string | null;
+  /**
+   * Current line number [if this function was defined in a script]
+   */
+  getLineNumber(): number | null;
+  /**
+   * Current column number [if this function was defined in a script]
+   */
+  getColumnNumber(): number | null;
+  /**
+   * A call site object representing the location where eval was called
+   * [if this function was created using a call to eval]
+   */
+  getEvalOrigin(): string | undefined;
+  /**
+   * Is this a toplevel invocation, that is, is "this" the global object?
+   */
+  isToplevel(): boolean;
+  /**
+   * Does this call take place in code defined by a call to eval?
+   */
+  isEval(): boolean;
+  /**
+   * Is this call in native V8 code?
+   */
+  isNative(): boolean;
+  /**
+   * Is this a constructor call?
+   */
+  isConstructor(): boolean;
+}
+
+```
+```typescript
+/**
+ * The wallet is currently updating information about an exchange.
+ */
+export interface PendingExchangeUpdateTask {
+  type: PendingTaskType.ExchangeUpdate;
+  exchangeBaseUrl: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * The wallet should check whether coins from this exchange
+ * need to be auto-refreshed.
+ */
+export interface PendingExchangeCheckRefreshTask {
+  type: PendingTaskType.ExchangeCheckRefresh;
+  exchangeBaseUrl: string;
+}
+
+```
+```typescript
+/**
+ * A purchase needs to be processed (i.e. for download / payment / refund).
+ */
+export interface PendingPurchaseTask {
+  type: PendingTaskType.Purchase;
+  proposalId: string;
+  retryInfo?: RetryInfo;
+  /**
+   * Status of the payment as string, used only for debugging.
+   */
+  statusStr: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingRefreshTask {
+  type: PendingTaskType.Refresh;
+  lastError?: TalerErrorDetail;
+  refreshGroupId: string;
+  finishedPerCoin: boolean[];
+  retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+/**
+ * The wallet is picking up a tip that the user has accepted.
+ */
+export interface PendingTipPickupTask {
+  type: PendingTaskType.TipPickup;
+  tipId: string;
+  merchantBaseUrl: string;
+  merchantTipId: string;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingWithdrawTask {
+  type: PendingTaskType.Withdraw;
+  lastError: TalerErrorDetail | undefined;
+  retryInfo?: RetryInfo;
+  withdrawalGroupId: string;
+}
+
+```
+```typescript
+export interface PendingRecoupTask {
+  type: PendingTaskType.Recoup;
+  recoupGroupId: string;
+  retryInfo?: RetryInfo;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * Status of an ongoing deposit operation.
+ */
+export interface PendingDepositTask {
+  type: PendingTaskType.Deposit;
+  lastError: TalerErrorDetail | undefined;
+  retryInfo: RetryInfo | undefined;
+  depositGroupId: string;
+}
+
+```
+```typescript
+export interface PendingBackupTask {
+  type: PendingTaskType.Backup;
+  backupProviderBaseUrl: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer push payment.
+ */
+export interface PendingPeerPushInitiationTask {
+  type: PendingTaskType.PeerPushInitiation;
+  pursePub: string;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer pull payment.
+ */
+export interface PendingPeerPullInitiationTask {
+  type: PendingTaskType.PeerPullInitiation;
+  pursePub: string;
+}
+
+```
+```typescript
+/**
+ * The wallet wants to send a peer pull payment.
+ */
+export interface PendingPeerPullDebitTask {
+  type: PendingTaskType.PeerPullDebit;
+  peerPullPaymentIncomingId: string;
+}
+
+```
+```typescript
+/**
+ */
+export interface PendingPeerPushCreditTask {
+  type: PendingTaskType.PeerPushCredit;
+  peerPushPaymentIncomingId: string;
+}
+
+```
+
+### 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.
+     */
+    denom_pub: DenominationPubKey;
+    /**
+     * Hash of denom_pub.
+     */
+    denom_pub_hash: string;
+    /**
+     * Value of the denomination (without any fees).
+     */
+    denom_value: string;
+    /**
+     * Public key of the coin.
+     */
+    coin_pub: string;
+    /**
+     * Base URL of the exchange for the coin.
+     */
+    exchange_base_url: string;
+    /**
+     * Public key of the parent coin.
+     * Only present if this coin was obtained via refreshing.
+     */
+    refresh_parent_coin_pub: string | undefined;
+    /**
+     * Public key of the reserve for this coin.
+     * Only present if this coin was obtained via refreshing.
+     */
+    withdrawal_reserve_pub: string | undefined;
+    coin_status: CoinStatus;
+    spend_allocation:
+      | {
+          id: string;
+          amount: string;
+        }
+      | undefined;
+    /**
+     * Information about the age restriction
+     */
+    ageCommitmentProof: AgeCommitmentProof | undefined;
+  }>;
+}
+
+```
+```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",
+  /**
+   * 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 = FlavorP<string, "Edx25519PublicKeyEnc", 32>;
+
+```
+```typescript
+export type FlavorP<T, FlavorT extends string, S extends number> = T & {
+  _flavor?: `taler.${FlavorT}`;
+  _size?: S;
+};
+
+```
+```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 = FlavorP<
+  string,
+  "Edx25519PrivateKeyEnc",
+  64
+>;
+
+```
+
+### 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 {
+  coinPubList: string[];
+}
+
+```
+
+## Common Declarations
+```typescript
+export interface WalletCoreVersion {
+  hash: string | undefined;
+  version: string;
+  exchange: string;
+  merchant: string;
+  bank: string;
+  /**
+   * @deprecated will be removed
+   */
+  devMode: boolean;
+}
+```
+```typescript
+export type Transaction =
+  | TransactionWithdrawal
+  | TransactionPayment
+  | TransactionRefund
+  | TransactionTip
+  | TransactionRefresh
+  | TransactionDeposit
+  | TransactionPeerPullCredit
+  | TransactionPeerPullDebit
+  | TransactionPeerPushCredit
+  | TransactionPeerPushDebit;
+```
+```typescript
+export interface TransactionWithdrawal extends TransactionCommon {
+  type: TransactionType.Withdrawal;
+  /**
+   * 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
+export interface TransactionCommon {
+  transactionId: TransactionIdStr;
+  type: TransactionType;
+  timestamp: TalerProtocolTimestamp;
+  /**
+   * Transaction state, as per DD37.
+   */
+  txState: TransactionState;
+  /**
+   * @deprecated in favor of statusMajor and statusMinor
+   */
+  extendedStatus: ExtendedStatus;
+  /**
+   * true if the transaction is still pending, false otherwise
+   * If a transaction is not longer pending, its timestamp will be updated,
+   * but its transactionId will remain unchanged
+   *
+   * @deprecated show extendedStatus
+   */
+  pending: boolean;
+  /**
+   * True if the transaction encountered a problem that might be
+   * permanent.  A frozen transaction won't be automatically retried.
+   *
+   * @deprecated show extendedStatus
+   */
+  frozen: boolean;
+  /**
+   * 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;
+}
+```
+```typescript
+export declare enum TransactionType {
+  Withdrawal = "withdrawal",
+  Payment = "payment",
+  Refund = "refund",
+  Refresh = "refresh",
+  Tip = "tip",
+  Deposit = "deposit",
+  PeerPushDebit = "peer-push-debit",
+  PeerPushCredit = "peer-push-credit",
+  PeerPullDebit = "peer-pull-debit",
+  PeerPullCredit = "peer-pull-credit",
+}
+```
+```typescript
+export interface TalerProtocolTimestamp {
+  readonly t_s: number | "never";
+}
+```
+```typescript
+export interface TransactionState {
+  major: TransactionMajorState;
+  minor?: TransactionMinorState;
+}
+```
+```typescript
+export declare enum TransactionMajorState {
+  None = "none",
+  Pending = "pending",
+  Done = "done",
+  Aborting = "aborting",
+  Aborted = "aborted",
+  Suspended = "suspended",
+  Failed = "failed",
+  Deleted = "deleted",
+  Unknown = "unknown",
+}
+```
+```typescript
+export declare enum TransactionMinorState {
+  Unknown = "unknown",
+  Deposit = "deposit",
+  KycRequired = "kyc-required",
+  Track = "track",
+  Refresh = "refresh",
+}
+```
+```typescript
+export declare enum ExtendedStatus {
+  Pending = "pending",
+  Done = "done",
+  Aborting = "aborting",
+  Aborted = "aborted",
+  Failed = "failed",
+  KycRequired = "kyc-required",
+}
+```
+```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";
+}
+```
+```typescript
+export interface Duration {
+  /**
+   * Duration in milliseconds.
+   */
+  readonly d_ms: number | "forever";
+}
+```
+```typescript
+export interface TalerProtocolDuration {
+  readonly d_us: number | "forever";
+}
+```
+```typescript
+export type WithdrawalDetails =
+  | WithdrawalDetailsForManualTransfer
+  | WithdrawalDetailsForTalerBankIntegrationApi;
+```
+```typescript
+interface WithdrawalDetailsForManualTransfer {
+  type: WithdrawalType.ManualTransfer;
+  /**
+   * Payto URIs that the exchange supports.
+   *
+   * Already contains the amount and message.
+   */
+  exchangePaytoUris: string[];
+  reservePub: string;
+  /**
+   * Is the reserve ready for withdrawal?
+   */
+  reserveIsReady: boolean;
+}
+```
+```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;
+}
+```
+```typescript
+export interface TransactionPayment extends TransactionCommon {
+  type: TransactionType.Payment;
+  /**
+   * Additional information about the payment.
+   */
+  info: OrderShortInfo;
+  /**
+   * Wallet-internal end-to-end identifier for the payment.
+   */
+  proposalId: string;
+  /**
+   * How far did the wallet get with processing the payment?
+   *
+   * @deprecated use extendedStatus
+   */
+  status: PaymentStatus;
+  /**
+   * 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;
+  /**
+   * Does this purchase has an pos validation
+   */
+  posConfirmation: string | undefined;
+}
+```
+```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;
+  /**
+   * List of products that are part of the order
+   */
+  products: Product[] | undefined;
+  /**
+   * Time indicating when the order should be delivered.
+   * May be overwritten by individual products.
+   */
+  delivery_date?: TalerProtocolTimestamp;
+  /**
+   * Delivery location for (all!) products.
+   */
+  delivery_location?: Location;
+  /**
+   * 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;
+  jurisdiction?: Location;
+  address?: Location;
+  logo?: string;
+  website?: string;
+  email?: string;
+}
+```
+```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 interface InternationalizedString {
+  [lang_tag: string]: string;
+}
+```
+```typescript
+export interface Product {
+  product_id?: string;
+  description: string;
+  description_i18n?: {
+    [lang_tag: string]: string;
+  };
+  quantity?: number;
+  unit?: string;
+  price?: AmountString;
+  image?: string;
+  taxes?: Tax[];
+  delivery_date?: TalerProtocolTimestamp;
+}
+```
+```typescript
+export interface Tax {
+  name: string;
+  tax: AmountString;
+}
+```
+```typescript
+export declare enum PaymentStatus {
+  /**
+   * Explicitly aborted after timeout / failure
+   */
+  Aborted = "aborted",
+  /**
+   * Payment failed, wallet will auto-retry.
+   * User should be given the option to retry now / abort.
+   */
+  Failed = "failed",
+  /**
+   * Paid successfully
+   */
+  Paid = "paid",
+  /**
+   * User accepted, payment is processing.
+   */
+  Accepted = "accepted",
+}
+```
+```typescript
+export interface RefundInfoShort {
+  transactionId: string;
+  timestamp: TalerProtocolTimestamp;
+  amountEffective: AmountString;
+  amountRaw: AmountString;
+}
+```
+```typescript
+export interface TransactionRefund extends TransactionCommon {
+  type: TransactionType.Refund;
+  refundedTransactionId: string;
+  info: OrderShortInfo;
+  /**
+   * Amount pending to be picked up
+   */
+  refundPending: AmountString | undefined;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+}
+```
+```typescript
+export interface TransactionTip extends TransactionCommon {
+  type: TransactionType.Tip;
+  amountRaw: AmountString;
+  /**
+   * More information about the merchant
+   */
+  amountEffective: AmountString;
+  merchantBaseUrl: string;
+}
+```
+```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",
+  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;
+  /**
+   * Effective amount that is being deposited
+   */
+  amountEffective: AmountString;
+  wireTransferDeadline: TalerProtocolTimestamp;
+  wireTransferProgress: number;
+  /**
+   * Did all the deposit requests succeed?
+   */
+  deposited: boolean;
+  trackingState: Array<{
+    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.
+   */
+  talerUri: string;
+}
+```
+```typescript
+export interface PeerInfoShort {
+  expiration: TalerProtocolTimestamp | undefined;
+  summary: 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.
+   */
+  talerUri: string;
+}
+```
+```typescript
+export interface AbortTransactionRequest {
+  transactionId: string;
+  /**
+   * Move the payment immediately into an aborted state.
+   * The UI should warn the user that this might lead
+   * to money being lost.
+   *
+   * Defaults to false.
+   */
+  forceImmediateAbort?: boolean;
+}
+```
+```typescript
+export interface ExchangeListItem {
+  exchangeBaseUrl: string;
+  currency: string | undefined;
+  paytoUris: string[];
+  tosStatus: ExchangeTosStatus;
+  exchangeStatus: ExchangeEntryStatus;
+  ageRestrictionOptions: number[];
+  /**
+   * Permanently added to the wallet, as opposed to just
+   * temporarily queried.
+   */
+  permanent: boolean;
+  /**
+   * Information about the last error that occurred when trying
+   * to update the exchange info.
+   */
+  lastUpdateErrorInfo?: OperationErrorInfo;
+}
+```
+```typescript
+export declare enum ExchangeTosStatus {
+  New = "new",
+  Accepted = "accepted",
+  Changed = "changed",
+  NotFound = "not-found",
+  Unknown = "unknown",
+}
+```
+```typescript
+export declare enum ExchangeEntryStatus {
+  Unknown = "unknown",
+  Outdated = "outdated",
+  Ok = "ok",
+}
+```
+```typescript
+export interface OperationErrorInfo {
+  error: TalerErrorDetail;
+}
+```
+```typescript
+export interface ForcedDenomSel {
+  denoms: {
+    value: AmountString;
+    count: number;
+  }[];
+}
+```
+```typescript
+/**
+ * Result of a prepare pay operation.
+ */
+export type PreparePayResult =
+  | PreparePayResultInsufficientBalance
+  | PreparePayResultAlreadyConfirmed
+  | PreparePayResultPaymentPossible;
+```
+```typescript
+export interface PreparePayResultInsufficientBalance {
+  status: PreparePayResultType.InsufficientBalance;
+  proposalId: string;
+  contractTerms: MerchantContractTerms;
+  amountRaw: string;
+  noncePriv: string;
+  talerUri: string;
+  balanceDetails: PayMerchantInsufficientBalanceDetails;
+}
+```
+```typescript
+/**
+ * Contract terms from a merchant.
+ * FIXME: Add type field!
+ */
+export interface MerchantContractTerms {
+  /**
+   * Hash of the merchant's wire details.
+   */
+  h_wire: string;
+  /**
+   * Hash of the merchant's wire details.
+   */
+  auto_refund?: TalerProtocolDuration;
+  /**
+   * Wire method the merchant wants to use.
+   */
+  wire_method: string;
+  /**
+   * Human-readable short summary of the contract.
+   */
+  summary: string;
+  summary_i18n?: InternationalizedString;
+  /**
+   * Nonce used to ensure freshness.
+   */
+  nonce: string;
+  /**
+   * Total amount payable.
+   */
+  amount: string;
+  /**
+   * Auditors accepted by the merchant.
+   */
+  auditors: AuditorHandle[];
+  /**
+   * Deadline to pay for the contract.
+   */
+  pay_deadline: TalerProtocolTimestamp;
+  /**
+   * Maximum deposit fee covered by the merchant.
+   */
+  max_fee: string;
+  /**
+   * Information about the merchant.
+   */
+  merchant: MerchantInfo;
+  /**
+   * Public key of the merchant.
+   */
+  merchant_pub: string;
+  /**
+   * Time indicating when the order should be delivered.
+   * May be overwritten by individual products.
+   */
+  delivery_date?: TalerProtocolTimestamp;
+  /**
+   * Delivery location for (all!) products.
+   */
+  delivery_location?: Location;
+  /**
+   * List of accepted exchanges.
+   */
+  exchanges: ExchangeHandle[];
+  /**
+   * Products that are sold in this contract.
+   */
+  products?: Product[];
+  /**
+   * Deadline for refunds.
+   */
+  refund_deadline: TalerProtocolTimestamp;
+  /**
+   * Deadline for the wire transfer.
+   */
+  wire_transfer_deadline: TalerProtocolTimestamp;
+  /**
+   * Time when the contract was generated by the merchant.
+   */
+  timestamp: TalerProtocolTimestamp;
+  /**
+   * Order id to uniquely identify the purchase within
+   * one merchant instance.
+   */
+  order_id: string;
+  /**
+   * Base URL of the merchant's backend.
+   */
+  merchant_base_url: string;
+  /**
+   * Fulfillment URL to view the product or
+   * delivery status.
+   */
+  fulfillment_url?: string;
+  /**
+   * URL meant to share the shopping cart.
+   */
+  public_reorder_url?: string;
+  /**
+   * Plain text fulfillment message in the merchant's default language.
+   */
+  fulfillment_message?: string;
+  /**
+   * Internationalized fulfillment messages.
+   */
+  fulfillment_message_i18n?: InternationalizedString;
+  /**
+   * Share of the wire fee that must be settled with one payment.
+   */
+  wire_fee_amortization?: number;
+  /**
+   * Maximum wire fee that the merchant agrees to pay for.
+   */
+  max_wire_fee?: string;
+  minimum_age?: number;
+  /**
+   * Extra data, interpreted by the mechant only.
+   */
+  extra?: any;
+}
+```
+```typescript
+export interface AuditorHandle {
+  /**
+   * Official name of the auditor.
+   */
+  name: string;
+  /**
+   * Master public signing key of the auditor.
+   */
+  auditor_pub: string;
+  /**
+   * Base URL of the auditor.
+   */
+  url: string;
+}
+```
+```typescript
+/**
+ * Information about an exchange as stored inside a
+ * merchant's contract terms.
+ */
+export interface ExchangeHandle {
+  /**
+   * Master public signing key of the exchange.
+   */
+  master_pub: string;
+  /**
+   * Base URL of the exchange.
+   */
+  url: string;
+}
+```
+```typescript
+/**
+ * Detailed reason for why the wallet's balance is insufficient.
+ */
+export interface PayMerchantInsufficientBalanceDetails {
+  /**
+   * Amount requested by the merchant.
+   */
+  amountRequested: AmountString;
+  /**
+   * 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 "merchant-acceptable" (see balance.ts for definition).
+   */
+  balanceMerchantAcceptable: AmountString;
+  /**
+   * Balance of type "merchant-depositable" (see balance.ts for definition).
+   */
+  balanceMerchantDepositable: AmountString;
+  /**
+   * If the payment would succeed without fees
+   * (i.e. balanceMerchantDepositable >= amountRequested),
+   * this field contains an estimate of the amount that would additionally
+   * be required to cover the fees.
+   *
+   * It is not possible to give an exact value here, since it depends
+   * on the coin selection for the amount that would be additionally withdrawn.
+   */
+  feeGapEstimate: AmountString;
+}
+```
+```typescript
+export interface PreparePayResultAlreadyConfirmed {
+  status: PreparePayResultType.AlreadyConfirmed;
+  contractTerms: MerchantContractTerms;
+  paid: boolean;
+  amountRaw: string;
+  amountEffective: string;
+  contractTermsHash: string;
+  proposalId: string;
+  talerUri?: string;
+}
+```
+```typescript
+/**
+ * Payment is possible.
+ */
+export interface PreparePayResultPaymentPossible {
+  status: PreparePayResultType.PaymentPossible;
+  proposalId: string;
+  contractTerms: MerchantContractTerms;
+  contractTermsHash: string;
+  amountRaw: string;
+  amountEffective: string;
+  noncePriv: string;
+  talerUri: string;
+}
+```
+```typescript
+/**
+ * Forced coin selection for deposits/payments.
+ */
+export interface ForcedCoinSel {
+  coins: {
+    value: AmountString;
+    contribution: AmountString;
+  }[];
+}
+```
+```typescript
+export interface ApplyRefundResponse {
+  contractTermsHash: string;
+  transactionId: string;
+  proposalId: string;
+  amountEffectivePaid: AmountString;
+  amountRefundGranted: AmountString;
+  amountRefundGone: AmountString;
+  pendingAtExchange: boolean;
+  info: OrderShortInfo;
+}
+```
+```typescript
+export interface AddExchangeRequest {
+  exchangeBaseUrl: string;
+  forceUpdate?: boolean;
+}
+```
+```typescript
+export interface BackupRecovery {
+  walletRootPriv: string;
+  providers: {
+    name: string;
+    url: string;
+  }[];
+}
+```
+```typescript
+/**
+ * Contract terms between two wallets (as opposed to a merchant and wallet).
+ */
+export interface PeerContractTerms {
+  amount: AmountString;
+  summary: string;
+  purse_expiration: TalerProtocolTimestamp;
+}
+```
+```typescript
+export interface IntegrationTestArgs {
+  exchangeBaseUrl: string;
+  bankAccessApiBaseUrl: string;
+  merchantBaseUrl: string;
+  merchantAuthToken?: string;
+  amountToWithdraw: string;
+  amountToSpend: string;
+}
+```
diff --git a/extract-tsdefs/myout.md b/extract-tsdefs/myout.md
new file mode 100644
index 00000000..abecccf0
--- /dev/null
+++ b/extract-tsdefs/myout.md
@@ -0,0 +1,2517 @@
+# Wallet API Documentation
+```{note}
+This file is auto-generated from [wallet-core](https://git.taler.net/wallet-core.git/tree/packages/taler-wallet-core/src/wallet-api-types.ts)
+```
+## Overview
+###  Initialization
+* [InitWalletOp](#initwalletop)
+###  Basic Wallet Information
+* [GetBalancesOp](#getbalancesop)
+###  Managing Transactions
+* [GetTransactionsOp](#gettransactionsop)
+* [DeleteTransactionOp](#deletetransactionop)
+* [RetryTransactionOp](#retrytransactionop)
+###  Withdrawals
+* [GetWithdrawalDetailsForAmountOp](#getwithdrawaldetailsforamountop)
+* [GetWithdrawalDetailsForUriOp](#getwithdrawaldetailsforuriop)
+* [AcceptBankIntegratedWithdrawalOp](#acceptbankintegratedwithdrawalop)
+* [AcceptManualWithdrawalOp](#acceptmanualwithdrawalop)
+###  Merchant Payments
+* [PreparePayForUriOp](#preparepayforuriop)
+* [ConfirmPayOp](#confirmpayop)
+* [AbortPayWithRefundOp](#abortpaywithrefundop)
+* [ApplyRefundOp](#applyrefundop)
+###  Tipping
+* [PrepareTipOp](#preparetipop)
+* [AcceptTipOp](#accepttipop)
+###  Exchange Management
+* [ListExchangesOp](#listexchangesop)
+* [AddExchangeOp](#addexchangeop)
+* [SetExchangeTosAcceptedOp](#setexchangetosacceptedop)
+* [GetExchangeTosOp](#getexchangetosop)
+* [ListCurrenciesOp](#listcurrenciesop)
+###  Deposits
+* [CreateDepositGroupOp](#createdepositgroupop)
+* [TrackDepositGroupOp](#trackdepositgroupop)
+###  Backups
+* [ExportBackupRecoveryOp](#exportbackuprecoveryop)
+* [ImportBackupRecoveryOp](#importbackuprecoveryop)
+* [RunBackupCycleOp](#runbackupcycleop)
+* [AddBackupProviderOp](#addbackupproviderop)
+* [GetBackupInfoOp](#getbackupinfoop)
+* [SetWalletDeviceIdOp](#setwalletdeviceidop)
+* [ExportBackupPlainOp](#exportbackupplainop)
+###  Peer Payments
+* [InitiatePeerPushPaymentOp](#initiatepeerpushpaymentop)
+* [CheckPeerPushPaymentOp](#checkpeerpushpaymentop)
+* [AcceptPeerPushPaymentOp](#acceptpeerpushpaymentop)
+* [InitiatePeerPullPaymentOp](#initiatepeerpullpaymentop)
+* [CheckPeerPullPaymentOp](#checkpeerpullpaymentop)
+* [AcceptPeerPullPaymentOp](#acceptpeerpullpaymentop)
+###  Database Management
+* [ExportDbOp](#exportdbop)
+* [ClearDbOp](#cleardbop)
+* [RecycleOp](#recycleop)
+###  Testing and Debugging
+* [RunIntegrationTestOp](#runintegrationtestop)
+* [WithdrawTestBalanceOp](#withdrawtestbalanceop)
+* [WithdrawTestkudosOp](#withdrawtestkudosop)
+* [TestPayOp](#testpayop)
+* [WithdrawFakebankOp](#withdrawfakebankop)
+* [GetPendingTasksOp](#getpendingtasksop)
+* [DumpCoinsOp](#dumpcoinsop)
+* [SetCoinSuspendedOp](#setcoinsuspendedop)
+* [ForceRefreshOp](#forcerefreshop)
+## Operation Reference
+(initwalletop)=
+### InitWalletOp
+```typescript
+// group: Initialization
+/**
+ * Initialize wallet-core.
+ *
+ * Must be the request before any other operations.
+ */
+export type InitWalletOp = {
+  op: WalletApiOperation.InitWallet;
+  request: {};
+  response: {};
+};
+
+```
+```typescript
+// Enum value:
+// WalletApiOperation.InitWallet = "initWallet"
+
+```
+
+(getbalancesop)=
+### GetBalancesOp
+```typescript
+// group: Basic Wallet Information
+/**
+ * Get current wallet balance.
+ */
+export type GetBalancesOp = {
+  request: {};
+  response: BalancesResponse;
+};
+
+```
+```typescript
+export interface BalancesResponse {
+  balances: Balance[];
+}
+
+```
+```typescript
+export interface Balance {
+  available: AmountString;
+  pendingIncoming: AmountString;
+  pendingOutgoing: AmountString;
+  hasPendingTransactions: boolean;
+  requiresUserInput: boolean;
+}
+
+```
+
+(gettransactionsop)=
+### GetTransactionsOp
+```typescript
+// group: Managing Transactions
+/**
+ * Get transactions.
+ */
+export type GetTransactionsOp = {
+  request: TransactionsRequest;
+  response: TransactionsResponse;
+};
+
+```
+```typescript
+export interface TransactionsRequest {
+  /**
+   * return only transactions in the given currency
+   */
+  currency?: string;
+  /**
+   * if present, results will be limited to transactions related to the given search string
+   */
+  search?: string;
+}
+
+```
+```typescript
+export interface TransactionsResponse {
+  transactions: Transaction[];
+}
+
+```
+```typescript
+export declare type Transaction =
+  | TransactionWithdrawal
+  | TransactionPayment
+  | TransactionRefund
+  | TransactionTip
+  | TransactionRefresh
+  | TransactionDeposit
+  | TransactionPeerPullCredit
+  | TransactionPeerPullDebit
+  | TransactionPeerPushCredit
+  | TransactionPeerPushDebit;
+
+```
+```typescript
+export interface TransactionWithdrawal extends TransactionCommon {
+  type: TransactionType.Withdrawal;
+  /**
+   * 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
+// Enum value:
+// TransactionType.Withdrawal = "withdrawal"
+
+```
+```typescript
+export declare type WithdrawalDetails =
+  | WithdrawalDetailsForManualTransfer
+  | WithdrawalDetailsForTalerBankIntegrationApi;
+
+```
+```typescript
+interface WithdrawalDetailsForManualTransfer {
+  type: WithdrawalType.ManualTransfer;
+  /**
+   * Payto URIs that the exchange supports.
+   *
+   * Already contains the amount and message.
+   */
+  exchangePaytoUris: string[];
+  reservePub: string;
+}
+
+```
+```typescript
+// Enum value:
+// WithdrawalType.ManualTransfer = "manual-transfer"
+
+```
+```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;
+}
+
+```
+```typescript
+// Enum value:
+// WithdrawalType.TalerBankIntegrationApi = "taler-bank-integration-api"
+
+```
+```typescript
+export interface TransactionPayment extends TransactionCommon {
+  type: TransactionType.Payment;
+  /**
+   * Additional information about the payment.
+   */
+  info: OrderShortInfo;
+  /**
+   * Wallet-internal end-to-end identifier for the payment.
+   */
+  proposalId: string;
+  /**
+   * How far did the wallet get with processing the payment?
+   */
+  status: PaymentStatus;
+  /**
+   * 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[];
+}
+
+```
+```typescript
+// Enum value:
+// TransactionType.Payment = "payment"
+
+```
+```typescript
+export declare enum PaymentStatus {
+  /**
+   * Explicitly aborted after timeout / failure
+   */
+  Aborted = "aborted",
+  /**
+   * Payment failed, wallet will auto-retry.
+   * User should be given the option to retry now / abort.
+   */
+  Failed = "failed",
+  /**
+   * Paid successfully
+   */
+  Paid = "paid",
+  /**
+   * User accepted, payment is processing.
+   */
+  Accepted = "accepted",
+}
+
+```
+```typescript
+export interface RefundInfoShort {
+  transactionId: string;
+  timestamp: TalerProtocolTimestamp;
+  amountEffective: AmountString;
+  amountRaw: AmountString;
+}
+
+```
+```typescript
+export interface TransactionRefund extends TransactionCommon {
+  type: TransactionType.Refund;
+  refundedTransactionId: string;
+  info: OrderShortInfo;
+  /**
+   * Amount pending to be picked up
+   */
+  refundPending: AmountString | undefined;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+}
+
+```
+```typescript
+// Enum value:
+// TransactionType.Refund = "refund"
+
+```
+```typescript
+export interface TransactionTip extends TransactionCommon {
+  type: TransactionType.Tip;
+  amountRaw: AmountString;
+  /**
+   * More information about the merchant
+   */
+  amountEffective: AmountString;
+  merchantBaseUrl: string;
+}
+
+```
+```typescript
+// Enum value:
+// TransactionType.Tip = "tip"
+
+```
+```typescript
+export interface TransactionRefresh extends TransactionCommon {
+  type: TransactionType.Refresh;
+  exchangeBaseUrl: string;
+  amountRaw: AmountString;
+  amountEffective: AmountString;
+}
+
+```
+```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;
+  /**
+   * Effective amount that is being deposited
+   */
+  amountEffective: 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.
+   */
+  talerUri: string;
+}
+
+```
+```typescript
+// Enum value:
+// TransactionType.PeerPullCredit = "peer-pull-credit"
+
+```
+```typescript
+export interface PeerInfoShort {
+  expiration: TalerProtocolTimestamp | undefined;
+  summary: 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
+// Enum value:
+// TransactionType.PeerPullDebit = "peer-pull-debit"
+
+```
+```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
+// Enum value:
+// TransactionType.PeerPushCredit = "peer-push-credit"
+
+```
+```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.
+   */
+  talerUri: string;
+}
+
+```
+```typescript
+// Enum value:
+// TransactionType.PeerPushDebit = "peer-push-debit"
+
+```
+
+(deletetransactionop)=
+### DeleteTransactionOp
+```typescript
+/**
+ * Delete a transaction locally in the wallet.
+ */
+export type DeleteTransactionOp = {
+  request: DeleteTransactionRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface DeleteTransactionRequest {
+  transactionId: string;
+}
+
+```
+
+(retrytransactionop)=
+### RetryTransactionOp
+```typescript
+/**
+ * Immediately retry a transaction.
+ */
+export type RetryTransactionOp = {
+  request: RetryTransactionRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface RetryTransactionRequest {
+  transactionId: string;
+}
+
+```
+
+(getwithdrawaldetailsforamountop)=
+### GetWithdrawalDetailsForAmountOp
+```typescript
+// group: Withdrawals
+/**
+ * Get details for withdrawing a particular amount (manual withdrawal).
+ */
+export type GetWithdrawalDetailsForAmountOp = {
+  request: GetWithdrawalDetailsForAmountRequest;
+  response: ManualWithdrawalDetails;
+};
+
+```
+```typescript
+export interface GetWithdrawalDetailsForAmountRequest {
+  exchangeBaseUrl: string;
+  amount: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface ManualWithdrawalDetails {
+  /**
+   * Did the user accept the current version of the exchange's
+   * terms of service?
+   */
+  tosAccepted: boolean;
+  /**
+   * Amount that the user will transfer to the exchange.
+   */
+  amountRaw: AmountString;
+  /**
+   * Amount that will be added to the user's wallet balance.
+   */
+  amountEffective: AmountString;
+  /**
+   * Ways to pay the exchange.
+   */
+  paytoUris: string[];
+}
+
+```
+
+(getwithdrawaldetailsforuriop)=
+### GetWithdrawalDetailsForUriOp
+```typescript
+/**
+ * Get details for withdrawing via a particular taler:// URI.
+ */
+export type GetWithdrawalDetailsForUriOp = {
+  request: GetWithdrawalDetailsForUriRequest;
+  response: WithdrawUriInfoResponse;
+};
+
+```
+```typescript
+export interface GetWithdrawalDetailsForUriRequest {
+  talerWithdrawUri: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface WithdrawUriInfoResponse {
+  amount: AmountString;
+  defaultExchangeBaseUrl?: string;
+  possibleExchanges: ExchangeListItem[];
+}
+
+```
+
+(acceptbankintegratedwithdrawalop)=
+### AcceptBankIntegratedWithdrawalOp
+```typescript
+/**
+ * Accept a bank-integrated withdrawal.
+ */
+export type AcceptBankIntegratedWithdrawalOp = {
+  request: AcceptBankIntegratedWithdrawalRequest;
+  response: AcceptWithdrawalResponse;
+};
+
+```
+```typescript
+export interface AcceptBankIntegratedWithdrawalRequest {
+  talerWithdrawUri: string;
+  exchangeBaseUrl: string;
+  forcedDenomSel?: ForcedDenomSel;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptWithdrawalResponse {
+  reservePub: string;
+  confirmTransferUrl?: string;
+  transactionId: string;
+}
+
+```
+
+(acceptmanualwithdrawalop)=
+### AcceptManualWithdrawalOp
+```typescript
+/**
+ * Create a manual withdrawal.
+ */
+export type AcceptManualWithdrawalOp = {
+  request: AcceptManualWithdrawalRequest;
+  response: AcceptManualWithdrawalResult;
+};
+
+```
+```typescript
+export interface AcceptManualWithdrawalRequest {
+  exchangeBaseUrl: string;
+  amount: string;
+  restrictAge?: number;
+}
+
+```
+```typescript
+export interface AcceptManualWithdrawalResult {
+  /**
+   * Payto URIs that can be used to fund the withdrawal.
+   */
+  exchangePaytoUris: string[];
+  /**
+   * Public key of the newly created reserve.
+   */
+  reservePub: string;
+  transactionId: string;
+}
+
+```
+
+(preparepayforuriop)=
+### PreparePayForUriOp
+```typescript
+// group: Merchant Payments
+/**
+ * Prepare to make a payment
+ */
+export type PreparePayForUriOp = {
+  op: WalletApiOperation.PreparePayForUri;
+  request: PreparePayRequest;
+  response: PreparePayResult;
+};
+
+```
+```typescript
+// Enum value:
+// WalletApiOperation.PreparePayForUri = "preparePayForUri"
+
+```
+```typescript
+export interface PreparePayRequest {
+  talerPayUri: string;
+}
+
+```
+```typescript
+/**
+ * Result of a prepare pay operation.
+ */
+export declare type PreparePayResult =
+  | PreparePayResultInsufficientBalance
+  | PreparePayResultAlreadyConfirmed
+  | PreparePayResultPaymentPossible;
+
+```
+```typescript
+export interface PreparePayResultInsufficientBalance {
+  status: PreparePayResultType.InsufficientBalance;
+  proposalId: string;
+  contractTerms: ContractTerms;
+  amountRaw: string;
+  noncePriv: string;
+}
+
+```
+```typescript
+export interface PreparePayResultAlreadyConfirmed {
+  status: PreparePayResultType.AlreadyConfirmed;
+  contractTerms: ContractTerms;
+  paid: boolean;
+  amountRaw: string;
+  amountEffective: string;
+  contractTermsHash: string;
+  proposalId: string;
+}
+
+```
+```typescript
+// Enum value:
+// PreparePayResultType.AlreadyConfirmed = "already-confirmed"
+
+```
+```typescript
+/**
+ * Payment is possible.
+ */
+export interface PreparePayResultPaymentPossible {
+  status: PreparePayResultType.PaymentPossible;
+  proposalId: string;
+  contractTerms: ContractTerms;
+  contractTermsHash: string;
+  amountRaw: string;
+  amountEffective: string;
+  noncePriv: string;
+}
+
+```
+```typescript
+// Enum value:
+// PreparePayResultType.PaymentPossible = "payment-possible"
+
+```
+
+(confirmpayop)=
+### ConfirmPayOp
+```typescript
+/**
+ * Confirm a payment that was previously prepared with
+ * {@link PreparePayForUriOp}
+ */
+export type ConfirmPayOp = {
+  op: WalletApiOperation.ConfirmPay;
+  request: ConfirmPayRequest;
+  response: ConfirmPayResult;
+};
+
+```
+```typescript
+// Enum value:
+// WalletApiOperation.ConfirmPay = "confirmPay"
+
+```
+```typescript
+export interface ConfirmPayRequest {
+  proposalId: string;
+  sessionId?: string;
+  forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export declare type ConfirmPayResult =
+  | ConfirmPayResultDone
+  | ConfirmPayResultPending;
+
+```
+```typescript
+/**
+ * Result for confirmPay
+ */
+export interface ConfirmPayResultDone {
+  type: ConfirmPayResultType.Done;
+  contractTerms: ContractTerms;
+  transactionId: string;
+}
+
+```
+```typescript
+// Enum value:
+// ConfirmPayResultType.Done = "done"
+
+```
+```typescript
+export interface ConfirmPayResultPending {
+  type: ConfirmPayResultType.Pending;
+  transactionId: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+
+(abortpaywithrefundop)=
+### AbortPayWithRefundOp
+```typescript
+/**
+ * Abort a pending payment with a refund.
+ */
+export type AbortPayWithRefundOp = {
+  request: AbortPayWithRefundRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AbortPayWithRefundRequest {
+  proposalId: string;
+}
+
+```
+
+(applyrefundop)=
+### ApplyRefundOp
+```typescript
+/**
+ * Check for a refund based on a taler://refund URI.
+ */
+export type ApplyRefundOp = {
+  request: ApplyRefundRequest;
+  response: ApplyRefundResponse;
+};
+
+```
+```typescript
+export interface ApplyRefundRequest {
+  talerRefundUri: string;
+}
+
+```
+```typescript
+export interface ApplyRefundResponse {
+  contractTermsHash: string;
+  transactionId: string;
+  proposalId: string;
+  amountEffectivePaid: AmountString;
+  amountRefundGranted: AmountString;
+  amountRefundGone: AmountString;
+  pendingAtExchange: boolean;
+  info: OrderShortInfo;
+}
+
+```
+
+(preparetipop)=
+### PrepareTipOp
+```typescript
+// group: Tipping
+/**
+ * Query and store information about a tip.
+ */
+export type PrepareTipOp = {
+  request: PrepareTipRequest;
+  response: PrepareTipResult;
+};
+
+```
+```typescript
+export interface PrepareTipRequest {
+  talerTipUri: string;
+}
+
+```
+```typescript
+export interface PrepareTipResult {
+  /**
+   * Unique ID for the tip assigned by the wallet.
+   * Typically different from the merchant-generated tip ID.
+   */
+  walletTipId: string;
+  /**
+   * Has the tip already been accepted?
+   */
+  accepted: boolean;
+  /**
+   * Amount that the merchant gave.
+   */
+  tipAmountRaw: AmountString;
+  /**
+   * Amount that arrived at the wallet.
+   * Might be lower than the raw amount due to fees.
+   */
+  tipAmountEffective: AmountString;
+  /**
+   * Base URL of the merchant backend giving then tip.
+   */
+  merchantBaseUrl: string;
+  /**
+   * Base URL of the exchange that is used to withdraw the tip.
+   * Determined by the merchant, the wallet/user has no choice here.
+   */
+  exchangeBaseUrl: string;
+  /**
+   * Time when the tip will expire.  After it expired, it can't be picked
+   * up anymore.
+   */
+  expirationTimestamp: TalerProtocolTimestamp;
+}
+
+```
+
+(accepttipop)=
+### AcceptTipOp
+```typescript
+/**
+ * Accept a tip.
+ */
+export type AcceptTipOp = {
+  request: AcceptTipRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AcceptTipRequest {
+  walletTipId: string;
+}
+
+```
+
+(listexchangesop)=
+### ListExchangesOp
+```typescript
+// group: Exchange Management
+/**
+ * List exchanges known to the wallet.
+ */
+export type ListExchangesOp = {
+  request: {};
+  response: ExchangesListResponse;
+};
+
+```
+```typescript
+export interface ExchangesListResponse {
+  exchanges: ExchangeListItem[];
+}
+
+```
+
+(addexchangeop)=
+### AddExchangeOp
+```typescript
+/**
+ * Add / force-update an exchange.
+ */
+export type AddExchangeOp = {
+  request: AddExchangeRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AddExchangeRequest {
+  exchangeBaseUrl: string;
+  forceUpdate?: boolean;
+}
+
+```
+
+(setexchangetosacceptedop)=
+### SetExchangeTosAcceptedOp
+```typescript
+/**
+ * Accept a particular version of the exchange terms of service.
+ */
+export type SetExchangeTosAcceptedOp = {
+  request: AcceptExchangeTosRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AcceptExchangeTosRequest {
+  exchangeBaseUrl: string;
+  etag: string | undefined;
+}
+
+```
+
+(getexchangetosop)=
+### GetExchangeTosOp
+```typescript
+/**
+ * Get the current terms of a service of an exchange.
+ */
+export type GetExchangeTosOp = {
+  request: GetExchangeTosRequest;
+  response: GetExchangeTosResult;
+};
+
+```
+```typescript
+export interface GetExchangeTosRequest {
+  exchangeBaseUrl: string;
+  acceptedFormat?: 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;
+}
+
+```
+
+(listcurrenciesop)=
+### ListCurrenciesOp
+```typescript
+/**
+ * List currencies known to the wallet.
+ */
+export type ListCurrenciesOp = {
+  request: {};
+  response: WalletCurrencyInfo;
+};
+
+```
+```typescript
+export interface WalletCurrencyInfo {
+  trustedAuditors: {
+    currency: string;
+    auditorPub: string;
+    auditorBaseUrl: string;
+  }[];
+  trustedExchanges: {
+    currency: string;
+    exchangeMasterPub: string;
+    exchangeBaseUrl: string;
+  }[];
+}
+
+```
+
+(createdepositgroupop)=
+### CreateDepositGroupOp
+```typescript
+// group: Deposits
+/**
+ * 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 = {
+  request: CreateDepositGroupRequest;
+  response: CreateDepositGroupResponse;
+};
+
+```
+```typescript
+export interface CreateDepositGroupRequest {
+  depositPaytoUri: string;
+  amount: AmountString;
+}
+
+```
+```typescript
+export interface CreateDepositGroupResponse {
+  depositGroupId: string;
+  transactionId: string;
+}
+
+```
+
+(trackdepositgroupop)=
+### TrackDepositGroupOp
+```typescript
+/**
+ * Track the status of a deposit group by querying the exchange.
+ */
+export type TrackDepositGroupOp = {
+  request: TrackDepositGroupRequest;
+  response: TrackDepositGroupResponse;
+};
+
+```
+```typescript
+export interface TrackDepositGroupRequest {
+  depositGroupId: string;
+}
+
+```
+```typescript
+export interface TrackDepositGroupResponse {
+  responses: {
+    status: number;
+    body: any;
+  }[];
+}
+
+```
+
+(exportbackuprecoveryop)=
+### ExportBackupRecoveryOp
+```typescript
+// group: Backups
+/**
+ * Export the recovery information for the wallet.
+ */
+export type ExportBackupRecoveryOp = {
+  request: {};
+  response: BackupRecovery;
+};
+
+```
+
+(importbackuprecoveryop)=
+### ImportBackupRecoveryOp
+```typescript
+/**
+ * Import recovery information into the wallet.
+ */
+export type ImportBackupRecoveryOp = {
+  request: RecoveryLoadRequest;
+  response: {};
+};
+
+```
+```typescript
+/**
+ * Load recovery information into the wallet.
+ */
+export interface RecoveryLoadRequest {
+  recovery: BackupRecovery;
+  strategy?: RecoveryMergeStrategy;
+}
+
+```
+```typescript
+/**
+ * Strategy for loading recovery information.
+ */
+export declare enum RecoveryMergeStrategy {
+  /**
+   * Keep the local wallet root key, import and take over providers.
+   */
+  Ours = "ours",
+  /**
+   * Migrate to the wallet root key from the recovery information.
+   */
+  Theirs = "theirs",
+}
+
+```
+
+(runbackupcycleop)=
+### RunBackupCycleOp
+```typescript
+/**
+ * Manually make and upload a backup.
+ */
+export type RunBackupCycleOp = {
+  request: {};
+  response: {};
+};
+
+```
+
+(addbackupproviderop)=
+### AddBackupProviderOp
+```typescript
+/**
+ * Add a new backup provider.
+ */
+export type AddBackupProviderOp = {
+  request: AddBackupProviderRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AddBackupProviderRequest {
+  backupProviderBaseUrl: string;
+  name: string;
+  /**
+   * Activate the provider.  Should only be done after
+   * the user has reviewed the provider.
+   */
+  activate?: boolean;
+}
+
+```
+
+(getbackupinfoop)=
+### GetBackupInfoOp
+```typescript
+/**
+ * Get some useful stats about the backup state.
+ */
+export type GetBackupInfoOp = {
+  request: {};
+  response: BackupInfo;
+};
+
+```
+```typescript
+export interface BackupInfo {
+  walletRootPub: string;
+  deviceId: string;
+  providers: ProviderInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about one provider.
+ *
+ * We don't store the account key here,
+ * as that's derived from the wallet root key.
+ */
+export interface ProviderInfo {
+  active: boolean;
+  syncProviderBaseUrl: string;
+  name: string;
+  terms?: BackupProviderTerms;
+  /**
+   * Last communication issue with the provider.
+   */
+  lastError?: TalerErrorDetail;
+  lastSuccessfulBackupTimestamp?: TalerProtocolTimestamp;
+  lastAttemptedBackupTimestamp?: TalerProtocolTimestamp;
+  paymentProposalIds: string[];
+  backupProblem?: BackupProblem;
+  paymentStatus: ProviderPaymentStatus;
+}
+
+```
+```typescript
+export interface BackupProviderTerms {
+  supportedProtocolVersion: string;
+  annualFee: AmountString;
+  storageLimitInMegabytes: number;
+}
+
+```
+```typescript
+export type BackupProblem =
+  | BackupUnreadableProblem
+  | BackupConflictingDeviceProblem;
+
+```
+```typescript
+export interface BackupUnreadableProblem {
+  type: "backup-unreadable";
+}
+
+```
+```typescript
+export interface BackupConflictingDeviceProblem {
+  type: "backup-conflicting-device";
+  otherDeviceId: string;
+  myDeviceId: string;
+  backupTimestamp: AbsoluteTime;
+}
+
+```
+```typescript
+export type ProviderPaymentStatus =
+  | ProviderPaymentTermsChanged
+  | ProviderPaymentPaid
+  | ProviderPaymentInsufficientBalance
+  | ProviderPaymentUnpaid
+  | ProviderPaymentPending;
+
+```
+```typescript
+export interface ProviderPaymentTermsChanged {
+  type: ProviderPaymentType.TermsChanged;
+  paidUntil: AbsoluteTime;
+  oldTerms: BackupProviderTerms;
+  newTerms: BackupProviderTerms;
+}
+
+```
+```typescript
+// Enum value:
+// ProviderPaymentType.TermsChanged = "terms-changed"
+
+```
+```typescript
+export interface ProviderPaymentPaid {
+  type: ProviderPaymentType.Paid;
+  paidUntil: AbsoluteTime;
+}
+
+```
+```typescript
+// Enum value:
+// ProviderPaymentType.Paid = "paid"
+
+```
+```typescript
+export interface ProviderPaymentInsufficientBalance {
+  type: ProviderPaymentType.InsufficientBalance;
+}
+
+```
+```typescript
+export interface ProviderPaymentUnpaid {
+  type: ProviderPaymentType.Unpaid;
+}
+
+```
+```typescript
+// Enum value:
+// ProviderPaymentType.Unpaid = "unpaid"
+
+```
+```typescript
+export interface ProviderPaymentPending {
+  type: ProviderPaymentType.Pending;
+}
+
+```
+
+(setwalletdeviceidop)=
+### SetWalletDeviceIdOp
+```typescript
+/**
+ * Set the internal device ID of the wallet, used to
+ * identify whether a different/new wallet is accessing
+ * the backup of another wallet.
+ */
+export type SetWalletDeviceIdOp = {
+  request: SetWalletDeviceIdRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface SetWalletDeviceIdRequest {
+  /**
+   * New wallet device ID to set.
+   */
+  walletDeviceId: string;
+}
+
+```
+
+(exportbackupplainop)=
+### ExportBackupPlainOp
+```typescript
+/**
+ * Export a backup JSON, mostly useful for testing.
+ */
+export type ExportBackupPlainOp = {
+  request: {};
+  response: WalletBackupContentV1;
+};
+
+```
+
+(initiatepeerpushpaymentop)=
+### InitiatePeerPushPaymentOp
+```typescript
+// group: Peer Payments
+/**
+ * Initiate an outgoing peer push payment.
+ */
+export type InitiatePeerPushPaymentOp = {
+  request: InitiatePeerPushPaymentRequest;
+  response: InitiatePeerPushPaymentResponse;
+};
+
+```
+```typescript
+export interface InitiatePeerPushPaymentRequest {
+  amount: AmountString;
+  partialContractTerms: any;
+}
+
+```
+```typescript
+export interface InitiatePeerPushPaymentResponse {
+  exchangeBaseUrl: string;
+  pursePub: string;
+  mergePriv: string;
+  contractPriv: string;
+  talerUri: string;
+  transactionId: string;
+}
+
+```
+
+(checkpeerpushpaymentop)=
+### CheckPeerPushPaymentOp
+```typescript
+/**
+ * Check an incoming peer push payment.
+ */
+export type CheckPeerPushPaymentOp = {
+  request: CheckPeerPushPaymentRequest;
+  response: CheckPeerPushPaymentResponse;
+};
+
+```
+```typescript
+export interface CheckPeerPushPaymentRequest {
+  talerUri: string;
+}
+
+```
+```typescript
+export interface CheckPeerPushPaymentResponse {
+  contractTerms: any;
+  amount: AmountString;
+  peerPushPaymentIncomingId: string;
+}
+
+```
+
+(acceptpeerpushpaymentop)=
+### AcceptPeerPushPaymentOp
+```typescript
+/**
+ * Accept an incoming peer push payment.
+ */
+export type AcceptPeerPushPaymentOp = {
+  request: AcceptPeerPushPaymentRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AcceptPeerPushPaymentRequest {
+  /**
+   * Transparent identifier of the incoming peer push payment.
+   */
+  peerPushPaymentIncomingId: string;
+}
+
+```
+
+(initiatepeerpullpaymentop)=
+### InitiatePeerPullPaymentOp
+```typescript
+/**
+ * Initiate an outgoing peer pull payment.
+ */
+export type InitiatePeerPullPaymentOp = {
+  request: InitiatePeerPullPaymentRequest;
+  response: InitiatePeerPullPaymentResponse;
+};
+
+```
+```typescript
+export interface InitiatePeerPullPaymentRequest {
+  /**
+   * FIXME: Make this optional?
+   */
+  exchangeBaseUrl: string;
+  amount: AmountString;
+  partialContractTerms: any;
+}
+
+```
+```typescript
+export interface InitiatePeerPullPaymentResponse {
+  /**
+   * Taler URI for the other party to make the payment
+   * that was requested.
+   */
+  talerUri: string;
+  transactionId: string;
+}
+
+```
+
+(checkpeerpullpaymentop)=
+### CheckPeerPullPaymentOp
+```typescript
+/**
+ * Prepare for an incoming peer pull payment.
+ */
+export type CheckPeerPullPaymentOp = {
+  request: CheckPeerPullPaymentRequest;
+  response: CheckPeerPullPaymentResponse;
+};
+
+```
+```typescript
+export interface CheckPeerPullPaymentRequest {
+  talerUri: string;
+}
+
+```
+```typescript
+export interface CheckPeerPullPaymentResponse {
+  contractTerms: any;
+  amount: AmountString;
+  peerPullPaymentIncomingId: string;
+}
+
+```
+
+(acceptpeerpullpaymentop)=
+### AcceptPeerPullPaymentOp
+```typescript
+/**
+ * Accept an incoming peer pull payment.
+ */
+export type AcceptPeerPullPaymentOp = {
+  request: AcceptPeerPullPaymentRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface AcceptPeerPullPaymentRequest {
+  /**
+   * Transparent identifier of the incoming peer pull payment.
+   */
+  peerPullPaymentIncomingId: string;
+}
+
+```
+
+(exportdbop)=
+### ExportDbOp
+```typescript
+// group: Database Management
+/**
+ * Exoport the wallet database's contents to JSON.
+ */
+export type ExportDbOp = {
+  request: {};
+  response: any;
+};
+
+```
+
+(cleardbop)=
+### ClearDbOp
+```typescript
+/**
+ * Dangerously clear the whole wallet database.
+ */
+export type ClearDbOp = {
+  request: {};
+  response: {};
+};
+
+```
+
+(recycleop)=
+### RecycleOp
+```typescript
+/**
+ * Export a backup, clear the database and re-import it.
+ */
+export type RecycleOp = {
+  request: {};
+  response: {};
+};
+
+```
+
+(runintegrationtestop)=
+### RunIntegrationTestOp
+```typescript
+// group: Testing and Debugging
+/**
+ * Run a simple integration test on a test deployment
+ * of the exchange and merchant.
+ */
+export type RunIntegrationTestOp = {
+  request: IntegrationTestArgs;
+  response: {};
+};
+
+```
+```typescript
+export interface IntegrationTestArgs {
+  exchangeBaseUrl: string;
+  bankBaseUrl: string;
+  bankAccessApiBaseUrl?: string;
+  merchantBaseUrl: string;
+  merchantAuthToken?: string;
+  amountToWithdraw: string;
+  amountToSpend: string;
+}
+
+```
+
+(withdrawtestbalanceop)=
+### WithdrawTestBalanceOp
+```typescript
+/**
+ * Make withdrawal on a test deployment of the exchange
+ * and merchant.
+ */
+export type WithdrawTestBalanceOp = {
+  request: WithdrawTestBalanceRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface WithdrawTestBalanceRequest {
+  amount: string;
+  bankBaseUrl: string;
+  /**
+   * Bank access API base URL.  Defaults to the bankBaseUrl.
+   */
+  bankAccessApiBaseUrl?: string;
+  exchangeBaseUrl: string;
+  forcedDenomSel?: ForcedDenomSel;
+}
+
+```
+
+(withdrawtestkudosop)=
+### WithdrawTestkudosOp
+```typescript
+/**
+ * Make a withdrawal of testkudos on test.taler.net.
+ */
+export type WithdrawTestkudosOp = {
+  op: WalletApiOperation.WithdrawTestkudos;
+  request: {};
+  response: {};
+};
+
+```
+```typescript
+// Enum value:
+// WalletApiOperation.WithdrawTestkudos = "withdrawTestkudos"
+
+```
+
+(testpayop)=
+### TestPayOp
+```typescript
+/**
+ * Make a test payment using a test deployment of
+ * the exchange and merchant.
+ */
+export type TestPayOp = {
+  request: TestPayArgs;
+  response: TestPayResult;
+};
+
+```
+```typescript
+export interface TestPayArgs {
+  merchantBaseUrl: string;
+  merchantAuthToken?: string;
+  amount: string;
+  summary: string;
+  forcedCoinSel?: ForcedCoinSel;
+}
+
+```
+```typescript
+export interface TestPayResult {
+  payCoinSelection: PayCoinSelection;
+}
+
+```
+```typescript
+/**
+ * Result of selecting coins, contains the exchange, and selected
+ * coins with their denomination.
+ */
+export interface PayCoinSelection {
+  /**
+   * Amount requested by the merchant.
+   */
+  paymentAmount: AmountJson;
+  /**
+   * Public keys of the coins that were selected.
+   */
+  coinPubs: string[];
+  /**
+   * Amount that each coin contributes.
+   */
+  coinContributions: AmountJson[];
+  /**
+   * How much of the wire fees is the customer paying?
+   */
+  customerWireFees: AmountJson;
+  /**
+   * How much of the deposit fees is the customer paying?
+   */
+  customerDepositFees: 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;
+}
+
+```
+
+(withdrawfakebankop)=
+### WithdrawFakebankOp
+```typescript
+/**
+ * Make a withdrawal from a fakebank, i.e.
+ * a bank where test users can be registered freely
+ * and testing APIs are available.
+ */
+export type WithdrawFakebankOp = {
+  op: WalletApiOperation.WithdrawFakebank;
+  request: WithdrawFakebankRequest;
+  response: {};
+};
+
+```
+```typescript
+// Enum value:
+// WalletApiOperation.WithdrawFakebank = "withdrawFakebank"
+
+```
+```typescript
+export interface WithdrawFakebankRequest {
+  amount: AmountString;
+  exchange: string;
+  bank: string;
+}
+
+```
+
+(getpendingtasksop)=
+### GetPendingTasksOp
+```typescript
+/**
+ * Get wallet-internal pending tasks.
+ */
+export type GetPendingTasksOp = {
+  request: {};
+  response: PendingTasksResponse;
+};
+
+```
+```typescript
+/**
+ * Response returned from the pending operations API.
+ */
+export interface PendingOperationsResponse {
+  /**
+   * List of pending operations.
+   */
+  pendingOperations: PendingTaskInfo[];
+}
+
+```
+```typescript
+/**
+ * Information about a pending operation.
+ */
+export type PendingTaskInfo = PendingTaskInfoCommon &
+  (
+    | PendingExchangeUpdateTask
+    | PendingExchangeCheckRefreshTask
+    | PendingPayTask
+    | PendingProposalDownloadTask
+    | PendingRefreshTask
+    | PendingRefundQueryTask
+    | PendingTipPickupTask
+    | PendingWithdrawTask
+    | PendingRecoupTask
+    | PendingDepositTask
+    | PendingBackupTask
+  );
+
+```
+```typescript
+/**
+ * Fields that are present in every pending operation.
+ */
+export interface PendingTaskInfoCommon {
+  /**
+   * Type of the pending operation.
+   */
+  type: PendingTaskType;
+  /**
+   * Unique identifier for the pending task.
+   */
+  id: string;
+  /**
+   * Set to true if the operation indicates that something is really in progress,
+   * as opposed to some regular scheduled operation that can be tried later.
+   */
+  givesLifeness: boolean;
+  /**
+   * Timestamp when the pending operation should be executed next.
+   */
+  timestampDue: AbsoluteTime;
+  /**
+   * Retry info.  Currently used to stop the wallet after any operation
+   * exceeds a number of retries.
+   */
+  retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+export enum PendingTaskType {
+  ExchangeUpdate = "exchange-update",
+  ExchangeCheckRefresh = "exchange-check-refresh",
+  Pay = "pay",
+  ProposalDownload = "proposal-download",
+  Refresh = "refresh",
+  Recoup = "recoup",
+  RefundQuery = "refund-query",
+  TipPickup = "tip-pickup",
+  Withdraw = "withdraw",
+  Deposit = "deposit",
+  Backup = "backup",
+}
+
+```
+```typescript
+export interface RetryInfo {
+  firstTry: AbsoluteTime;
+  nextRetry: AbsoluteTime;
+  retryCounter: number;
+}
+
+```
+```typescript
+export interface RetryPolicy {
+  readonly backoffDelta: Duration;
+  readonly backoffBase: number;
+  readonly maxTimeout: Duration;
+}
+
+```
+```typescript
+/**
+ * The wallet is currently updating information about an exchange.
+ */
+export interface PendingExchangeUpdateTask {
+  type: PendingTaskType.ExchangeUpdate;
+  exchangeBaseUrl: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.ExchangeUpdate = "exchange-update"
+
+```
+```typescript
+/**
+ * The wallet should check whether coins from this exchange
+ * need to be auto-refreshed.
+ */
+export interface PendingExchangeCheckRefreshTask {
+  type: PendingTaskType.ExchangeCheckRefresh;
+  exchangeBaseUrl: string;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.ExchangeCheckRefresh = "exchange-check-refresh"
+
+```
+```typescript
+/**
+ * The wallet is signing coins and then sending them to
+ * the merchant.
+ */
+export interface PendingPayTask {
+  type: PendingTaskType.Pay;
+  proposalId: string;
+  isReplay: boolean;
+  retryInfo?: RetryInfo;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.Pay = "pay"
+
+```
+```typescript
+/**
+ * Status of downloading signed contract terms from a merchant.
+ */
+export interface PendingProposalDownloadTask {
+  type: PendingTaskType.ProposalDownload;
+  merchantBaseUrl: string;
+  proposalTimestamp: TalerProtocolTimestamp;
+  proposalId: string;
+  orderId: string;
+  lastError?: TalerErrorDetail;
+  retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.ProposalDownload = "proposal-download"
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingRefreshTask {
+  type: PendingTaskType.Refresh;
+  lastError?: TalerErrorDetail;
+  refreshGroupId: string;
+  finishedPerCoin: boolean[];
+  retryInfo?: RetryInfo;
+}
+
+```
+```typescript
+/**
+ * The wallet is querying the merchant about whether any refund
+ * permissions are available for a purchase.
+ */
+export interface PendingRefundQueryTask {
+  type: PendingTaskType.RefundQuery;
+  proposalId: string;
+  retryInfo?: RetryInfo;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.RefundQuery = "refund-query"
+
+```
+```typescript
+/**
+ * The wallet is picking up a tip that the user has accepted.
+ */
+export interface PendingTipPickupTask {
+  type: PendingTaskType.TipPickup;
+  tipId: string;
+  merchantBaseUrl: string;
+  merchantTipId: string;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.TipPickup = "tip-pickup"
+
+```
+```typescript
+/**
+ * Status of an ongoing withdrawal operation.
+ */
+export interface PendingWithdrawTask {
+  type: PendingTaskType.Withdraw;
+  lastError: TalerErrorDetail | undefined;
+  retryInfo?: RetryInfo;
+  withdrawalGroupId: string;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.Withdraw = "withdraw"
+
+```
+```typescript
+export interface PendingRecoupTask {
+  type: PendingTaskType.Recoup;
+  recoupGroupId: string;
+  retryInfo?: RetryInfo;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.Recoup = "recoup"
+
+```
+```typescript
+/**
+ * Status of an ongoing deposit operation.
+ */
+export interface PendingDepositTask {
+  type: PendingTaskType.Deposit;
+  lastError: TalerErrorDetail | undefined;
+  retryInfo: RetryInfo | undefined;
+  depositGroupId: string;
+}
+
+```
+```typescript
+export interface PendingBackupTask {
+  type: PendingTaskType.Backup;
+  backupProviderBaseUrl: string;
+  lastError: TalerErrorDetail | undefined;
+}
+
+```
+```typescript
+// Enum value:
+// PendingTaskType.Backup = "backup"
+
+```
+
+(dumpcoinsop)=
+### DumpCoinsOp
+```typescript
+/**
+ * Dump all coins of the wallet in a simple JSON format.
+ */
+export type DumpCoinsOp = {
+  request: {};
+  response: CoinDumpJson;
+};
+
+```
+```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.
+     */
+    denom_pub: DenominationPubKey;
+    /**
+     * Hash of denom_pub.
+     */
+    denom_pub_hash: string;
+    /**
+     * Value of the denomination (without any fees).
+     */
+    denom_value: string;
+    /**
+     * Public key of the coin.
+     */
+    coin_pub: string;
+    /**
+     * Base URL of the exchange for the coin.
+     */
+    exchange_base_url: string;
+    /**
+     * Remaining value on the coin, to the knowledge of
+     * the wallet.
+     */
+    remaining_value: string;
+    /**
+     * Public key of the parent coin.
+     * Only present if this coin was obtained via refreshing.
+     */
+    refresh_parent_coin_pub: string | undefined;
+    /**
+     * Public key of the reserve for this coin.
+     * Only present if this coin was obtained via refreshing.
+     */
+    withdrawal_reserve_pub: string | undefined;
+    /**
+     * Is the coin suspended?
+     * Suspended coins are not considered for payments.
+     */
+    coin_suspended: boolean;
+    /**
+     * Information about the age restriction
+     */
+    ageCommitmentProof: AgeCommitmentProof | undefined;
+  }>;
+}
+
+```
+```typescript
+interface Array<T> extends RelativeIndexable<T> {}
+
+```
+
+(setcoinsuspendedop)=
+### SetCoinSuspendedOp
+```typescript
+/**
+ * Set a coin as (un-)suspended.
+ * Suspended coins won't be used for payments.
+ */
+export type SetCoinSuspendedOp = {
+  request: SetCoinSuspendedRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface SetCoinSuspendedRequest {
+  coinPub: string;
+  suspended: boolean;
+}
+
+```
+
+(forcerefreshop)=
+### ForceRefreshOp
+```typescript
+/**
+ * Force a refresh on coins where it would not
+ * be necessary.
+ */
+export type ForceRefreshOp = {
+  request: ForceRefreshRequest;
+  response: {};
+};
+
+```
+```typescript
+export interface ForceRefreshRequest {
+  coinPubList: string[];
+}
+
+```
+
+## Common Declarations
+```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;
+  /**
+   * List of products that are part of the order
+   */
+  products: Product[] | undefined;
+  /**
+   * Time indicating when the order should be delivered.
+   * May be overwritten by individual products.
+   */
+  delivery_date?: TalerProtocolTimestamp;
+  /**
+   * Delivery location for (all!) products.
+   */
+  delivery_location?: Location;
+  /**
+   * 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;
+  jurisdiction?: Location;
+  address?: Location;
+  logo?: string;
+  website?: string;
+  email?: string;
+}
+```
+```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 interface InternationalizedString {
+  [lang_tag: string]: string;
+}
+```
+```typescript
+export interface Product {
+  product_id?: string;
+  description: string;
+  description_i18n?: {
+    [lang_tag: string]: string;
+  };
+  quantity?: number;
+  unit?: string;
+  price?: AmountString;
+  image?: string;
+  taxes?: Tax[];
+  delivery_date?: TalerProtocolTimestamp;
+}
+```
+```typescript
+export interface Tax {
+  name: string;
+  tax: AmountString;
+}
+```
+```typescript
+export interface TalerProtocolTimestamp {
+  readonly t_s: number | "never";
+}
+```
+```typescript
+// Enum value:
+// PendingTaskType.Refresh = "refresh"
+```
+```typescript
+// Enum value:
+// PendingTaskType.Deposit = "deposit"
+```
+```typescript
+export interface ExchangeListItem {
+  exchangeBaseUrl: string;
+  currency: string;
+  paytoUris: string[];
+  tos: ExchangeTos;
+}
+```
+```typescript
+export interface ExchangeTos {
+  acceptedVersion?: string;
+  currentVersion?: string;
+  contentType?: string;
+  content?: string;
+}
+```
+```typescript
+export interface ForcedDenomSel {
+  denoms: {
+    value: AmountString;
+    count: number;
+  }[];
+}
+```
+```typescript
+// Enum value:
+// ProviderPaymentType.InsufficientBalance = "insufficient-balance"
+```
+```typescript
+/**
+ * Contract terms from a merchant.
+ */
+export interface ContractTerms {
+  /**
+   * Hash of the merchant's wire details.
+   */
+  h_wire: string;
+  /**
+   * Hash of the merchant's wire details.
+   */
+  auto_refund?: TalerProtocolDuration;
+  /**
+   * Wire method the merchant wants to use.
+   */
+  wire_method: string;
+  /**
+   * Human-readable short summary of the contract.
+   */
+  summary: string;
+  summary_i18n?: InternationalizedString;
+  /**
+   * Nonce used to ensure freshness.
+   */
+  nonce: string;
+  /**
+   * Total amount payable.
+   */
+  amount: string;
+  /**
+   * Auditors accepted by the merchant.
+   */
+  auditors: AuditorHandle[];
+  /**
+   * Deadline to pay for the contract.
+   */
+  pay_deadline: TalerProtocolTimestamp;
+  /**
+   * Maximum deposit fee covered by the merchant.
+   */
+  max_fee: string;
+  /**
+   * Information about the merchant.
+   */
+  merchant: MerchantInfo;
+  /**
+   * Public key of the merchant.
+   */
+  merchant_pub: string;
+  /**
+   * Time indicating when the order should be delivered.
+   * May be overwritten by individual products.
+   */
+  delivery_date?: TalerProtocolTimestamp;
+  /**
+   * Delivery location for (all!) products.
+   */
+  delivery_location?: Location;
+  /**
+   * List of accepted exchanges.
+   */
+  exchanges: ExchangeHandle[];
+  /**
+   * Products that are sold in this contract.
+   */
+  products?: Product[];
+  /**
+   * Deadline for refunds.
+   */
+  refund_deadline: TalerProtocolTimestamp;
+  /**
+   * Deadline for the wire transfer.
+   */
+  wire_transfer_deadline: TalerProtocolTimestamp;
+  /**
+   * Time when the contract was generated by the merchant.
+   */
+  timestamp: TalerProtocolTimestamp;
+  /**
+   * Order id to uniquely identify the purchase within
+   * one merchant instance.
+   */
+  order_id: string;
+  /**
+   * Base URL of the merchant's backend.
+   */
+  merchant_base_url: string;
+  /**
+   * Fulfillment URL to view the product or
+   * delivery status.
+   */
+  fulfillment_url?: string;
+  /**
+   * URL meant to share the shopping cart.
+   */
+  public_reorder_url?: string;
+  /**
+   * Plain text fulfillment message in the merchant's default language.
+   */
+  fulfillment_message?: string;
+  /**
+   * Internationalized fulfillment messages.
+   */
+  fulfillment_message_i18n?: InternationalizedString;
+  /**
+   * Share of the wire fee that must be settled with one payment.
+   */
+  wire_fee_amortization?: number;
+  /**
+   * Maximum wire fee that the merchant agrees to pay for.
+   */
+  max_wire_fee?: string;
+  minimum_age?: number;
+  /**
+   * Extra data, interpreted by the mechant only.
+   */
+  extra?: any;
+}
+```
+```typescript
+export interface TalerProtocolDuration {
+  readonly d_us: number | "forever";
+}
+```
+```typescript
+export interface AuditorHandle {
+  /**
+   * Official name of the auditor.
+   */
+  name: string;
+  /**
+   * Master public signing key of the auditor.
+   */
+  auditor_pub: string;
+  /**
+   * Base URL of the auditor.
+   */
+  url: string;
+}
+```
+```typescript
+/**
+ * Information about an exchange as stored inside a
+ * merchant's contract terms.
+ */
+export interface ExchangeHandle {
+  /**
+   * Master public signing key of the exchange.
+   */
+  master_pub: string;
+  /**
+   * Base URL of the exchange.
+   */
+  url: string;
+}
+```
+```typescript
+/**
+ * Forced coin selection for deposits/payments.
+ */
+export interface ForcedCoinSel {
+  coins: {
+    value: AmountString;
+    contribution: AmountString;
+  }[];
+}
+```
+```typescript
+// Enum value:
+// ProviderPaymentType.Pending = "pending"
+```
+```typescript
+export interface TalerErrorDetail {
+  code: TalerErrorCode;
+  hint?: string;
+  [x: string]: unknown;
+}
+```
+```typescript
+export interface BackupRecovery {
+  walletRootPriv: string;
+  providers: {
+    url: string;
+  }[];
+}
+```
+```typescript
+export interface AbsoluteTime {
+  /**
+   * Timestamp in milliseconds.
+   */
+  readonly t_ms: number | "never";
+}
+```
+```typescript
+export interface Duration {
+  /**
+   * Duration in milliseconds.
+   */
+  readonly d_ms: number | "forever";
+}
+```
diff --git a/extract-tsdefs/package.json b/extract-tsdefs/package.json
new file mode 100644
index 00000000..cf3ba343
--- /dev/null
+++ b/extract-tsdefs/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "extract-tsdefs",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "compile": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "GPL-3.0",
+  "devDependencies": {
+    "@types/node": "^18.8.1",
+    "@types/prettier": "^2.7.1",
+    "prettier": "^2.7.1",
+    "typescript": "^4.8.4"
+  }
+}
diff --git a/extract-tsdefs/pnpm-lock.yaml b/extract-tsdefs/pnpm-lock.yaml
new file mode 100644
index 00000000..6d064c10
--- /dev/null
+++ b/extract-tsdefs/pnpm-lock.yaml
@@ -0,0 +1,41 @@
+lockfileVersion: '6.1'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+devDependencies:
+  '@types/node':
+    specifier: ^18.8.1
+    version: 18.8.1
+  '@types/prettier':
+    specifier: ^2.7.1
+    version: 2.7.1
+  prettier:
+    specifier: ^2.7.1
+    version: 2.7.1
+  typescript:
+    specifier: ^4.8.4
+    version: 4.8.4
+
+packages:
+
+  /@types/node@18.8.1:
+    resolution: {integrity: sha512-vuYaNuEIbOYLTLUAJh50ezEbvxrD43iby+lpUA2aa148Nh5kX/AVO/9m1Ahmbux2iU5uxJTNF9g2Y+31uml7RQ==}
+    dev: true
+
+  /@types/prettier@2.7.1:
+    resolution: {integrity: sha512-ri0UmynRRvZiiUJdiz38MmIblKK+oH30MztdBVR95dv/Ubw6neWSb8u1XpRb72L4qsZOhz+L+z9JD40SJmfWow==}
+    dev: true
+
+  /prettier@2.7.1:
+    resolution: {integrity: sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+    dev: true
+
+  /typescript@4.8.4:
+    resolution: {integrity: sha512-QCh+85mCy+h0IGff8r5XWzOVSbBO+KfeYrMQh7NJ58QujwcE22u+NUSmUxqF+un70P9GXKxa2HCNiTTMJknyjQ==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true
diff --git a/extract-tsdefs/tsconfig.json b/extract-tsdefs/tsconfig.json
new file mode 100644
index 00000000..83ee9e28
--- /dev/null
+++ b/extract-tsdefs/tsconfig.json
@@ -0,0 +1,103 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}