wip #8655: unauthorized not documented

1 files changed, 320 insertions, 136 deletions

diff --git a/packages/taler-util/src/http-client/merchant.ts b/packages/taler-util/src/http-client/merchant.ts
index c223b0a16..e895c7eef 100644
--- a/packages/taler-util/src/http-client/merchant.ts
+++ b/packages/taler-util/src/http-client/merchant.ts
@@ -354,9 +354,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/auth`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -369,6 +369,8 @@ export class TalerMerchantInstanceHttpClient {
         return opEmptySuccess(resp);
       case HttpStatusCode.NoContent: // FIXME: missing in docs
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -385,9 +387,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -397,6 +399,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -411,9 +415,9 @@ export class TalerMerchantInstanceHttpClient {
   async getCurrentInstanceDetails(token: AccessToken) {
     const url = new URL(`private`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -423,6 +427,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForQueryInstancesResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       default:
         return opUnknownFailure(resp, await readTalerErrorResponse(resp));
     }
@@ -431,16 +437,19 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#delete-[-instances-$INSTANCE]-private
    */
-  async deleteCurrentInstance(token: AccessToken | undefined, params: { purge?: boolean } = {}) {
+  async deleteCurrentInstance(
+    token: AccessToken | undefined,
+    params: { purge?: boolean } = {},
+  ) {
     const url = new URL(`private`, this.baseUrl);
 
     if (params.purge) {
       url.searchParams.set("purge", "YES");
     }
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -480,9 +489,9 @@ export class TalerMerchantInstanceHttpClient {
       url.searchParams.set("timeout_ms", String(params.timeout));
     }
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -494,8 +503,14 @@ export class TalerMerchantInstanceHttpClient {
         return opSuccessFromHttp(resp, codecForAccountKycRedirects());
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.BadGateway:
-        return opKnownAlternativeFailure(resp, resp.status, codecForAccountKycRedirects())
+        return opKnownAlternativeFailure(
+          resp,
+          resp.status,
+          codecForAccountKycRedirects(),
+        );
       case HttpStatusCode.ServiceUnavailable:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.GatewayTimeout:
@@ -512,12 +527,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-accounts
    */
-  async addBankAccount(token: AccessToken | undefined, body: TalerMerchantApi.AccountAddDetails) {
+  async addBankAccount(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.AccountAddDetails,
+  ) {
     const url = new URL(`private/accounts`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -528,6 +546,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForAccountAddResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -547,9 +567,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/accounts/${wireAccount}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -559,6 +579,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -574,9 +596,9 @@ export class TalerMerchantInstanceHttpClient {
 
     // addMerchantPaginationParams(url, params);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -586,6 +608,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForAccountsSummaryResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -596,12 +620,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCE]-private-accounts-$H_WIRE
    */
-  async getBankAccountDetails(token: AccessToken | undefined, wireAccount: string) {
+  async getBankAccountDetails(
+    token: AccessToken | undefined,
+    wireAccount: string,
+  ) {
     const url = new URL(`private/accounts/${wireAccount}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -611,6 +638,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForBankAccountEntry());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -624,9 +653,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteBankAccount(token: AccessToken | undefined, wireAccount: string) {
     const url = new URL(`private/accounts/${wireAccount}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -636,6 +665,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -650,12 +681,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-products
    */
-  async addProduct(token: AccessToken | undefined, body: TalerMerchantApi.ProductAddDetail) {
+  async addProduct(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.ProductAddDetail,
+  ) {
     const url = new URL(`private/products`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -666,6 +700,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -683,9 +719,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/products/${productId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -696,6 +732,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -708,14 +746,17 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCE]-private-products
    */
-  async listProducts(token: AccessToken | undefined, params?: PaginationParams) {
+  async listProducts(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`private/products`, this.baseUrl);
 
     addMerchantPaginationParams(url, params);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -725,6 +766,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForInventorySummaryResponse());
+      case HttpStatusCode.Unauthorized:
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -738,9 +781,9 @@ export class TalerMerchantInstanceHttpClient {
   async getProductDetails(token: AccessToken | undefined, productId: string) {
     const url = new URL(`private/products/${productId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -750,6 +793,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForProductDetail());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -760,12 +805,16 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#reserving-inventory
    */
-  async lockProduct(token: AccessToken | undefined, productId: string, body: TalerMerchantApi.LockRequest) {
+  async lockProduct(
+    token: AccessToken | undefined,
+    productId: string,
+    body: TalerMerchantApi.LockRequest,
+  ) {
     const url = new URL(`private/products/${productId}/lock`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -776,6 +825,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Gone:
@@ -791,9 +842,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteProduct(token: AccessToken | undefined, productId: string) {
     const url = new URL(`private/products/${productId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -803,6 +854,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -819,29 +872,36 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-orders
    */
-  async createOrder(token: AccessToken | undefined, body: TalerMerchantApi.PostOrderRequest) {
+  async createOrder(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.PostOrderRequest,
+  ) {
     const url = new URL(`private/orders`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
       body,
       headers,
     });
-    return this.procesOrderCreationResponse(resp)
+    return this.procesOrderCreationResponse(resp);
   }
 
   private async procesOrderCreationResponse(resp: HttpResponse) {
     switch (resp.status) {
       case HttpStatusCode.Ok: {
-        this.cacheEvictor.notifySuccess(TalerMerchantInstanceCacheEviction.CREATE_ORDER)
-        return opSuccessFromHttp(resp, codecForPostOrderResponse())
+        this.cacheEvictor.notifySuccess(
+          TalerMerchantInstanceCacheEviction.CREATE_ORDER,
+        );
+        return opSuccessFromHttp(resp, codecForPostOrderResponse());
       }
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Gone:
@@ -858,7 +918,10 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#inspecting-orders
    */
-  async listOrders(token: AccessToken | undefined, params: TalerMerchantApi.ListOrdersRequestParams = {}) {
+  async listOrders(
+    token: AccessToken | undefined,
+    params: TalerMerchantApi.ListOrdersRequestParams = {},
+  ) {
     const url = new URL(`private/orders`, this.baseUrl);
 
     if (params.date) {
@@ -884,9 +947,9 @@ export class TalerMerchantInstanceHttpClient {
     }
     addMerchantPaginationParams(url, params);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -896,6 +959,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForOrderHistory());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       default:
         return opUnknownFailure(resp, await readTalerErrorResponse(resp));
     }
@@ -921,9 +986,9 @@ export class TalerMerchantInstanceHttpClient {
       url.searchParams.set("timeout_ms", String(params.timeout));
     }
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -938,6 +1003,8 @@ export class TalerMerchantInstanceHttpClient {
         );
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.BadGateway:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.GatewayTimeout:
@@ -954,12 +1021,16 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#private-order-data-cleanup
    */
-  async forgetOrder(token: AccessToken | undefined, orderId: string, body: TalerMerchantApi.ForgetRequest) {
+  async forgetOrder(
+    token: AccessToken | undefined,
+    orderId: string,
+    body: TalerMerchantApi.ForgetRequest,
+  ) {
     const url = new URL(`private/orders/${orderId}/forget`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -972,6 +1043,8 @@ export class TalerMerchantInstanceHttpClient {
         return opEmptySuccess(resp);
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.BadRequest:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
@@ -989,9 +1062,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteOrder(token: AccessToken | undefined, orderId: string) {
     const url = new URL(`private/orders/${orderId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1001,6 +1074,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1017,12 +1092,16 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-orders-$ORDER_ID-refund
    */
-  async addRefund(token: AccessToken | undefined, orderId: string, body: TalerMerchantApi.RefundRequest) {
+  async addRefund(
+    token: AccessToken | undefined,
+    orderId: string,
+    body: TalerMerchantApi.RefundRequest,
+  ) {
     const url = new URL(`private/orders/${orderId}/refund`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1035,6 +1114,8 @@ export class TalerMerchantInstanceHttpClient {
         return opSuccessFromHttp(resp, codecForMerchantRefundResponse());
       case HttpStatusCode.Forbidden:
         return opKnownHttpFailure(resp.status, resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Gone:
@@ -1053,12 +1134,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-transfers
    */
-  async informWireTransfer(token: AccessToken | undefined, body: TalerMerchantApi.TransferInformation) {
+  async informWireTransfer(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.TransferInformation,
+  ) {
     const url = new URL(`private/transfers`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1069,6 +1153,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1101,9 +1187,9 @@ export class TalerMerchantInstanceHttpClient {
     }
     addMerchantPaginationParams(url, params);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1113,6 +1199,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTansferList());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       default:
         return opUnknownFailure(resp, await readTalerErrorResponse(resp));
     }
@@ -1124,9 +1212,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteWireTransfer(token: AccessToken | undefined, transferId: string) {
     const url = new URL(`private/transfers/${transferId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1136,6 +1224,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1152,12 +1242,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-otp-devices
    */
-  async addOtpDevice(token: AccessToken | undefined, body: TalerMerchantApi.OtpDeviceAddDetails) {
+  async addOtpDevice(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.OtpDeviceAddDetails,
+  ) {
     const url = new URL(`private/otp-devices`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1168,6 +1261,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1185,9 +1280,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/otp-devices/${deviceId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -1197,6 +1292,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1209,12 +1306,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCE]-private-otp-devices
    */
-  async listOtpDevices(token: AccessToken | undefined, params?: PaginationParams) {
+  async listOtpDevices(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`private/otp-devices`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1223,6 +1323,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForOtpDeviceSummaryResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1246,9 +1348,9 @@ export class TalerMerchantInstanceHttpClient {
     if (params.price) {
       url.searchParams.set("price", params.price);
     }
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1258,6 +1360,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForOtpDeviceDetails());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1271,9 +1375,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteOtpDevice(token: AccessToken | undefined, deviceId: string) {
     const url = new URL(`private/otp-devices/${deviceId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1282,6 +1386,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1296,12 +1402,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCE]-private-templates
    */
-  async addTemplate(token: AccessToken | undefined, body: TalerMerchantApi.TemplateAddDetails) {
+  async addTemplate(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.TemplateAddDetails,
+  ) {
     const url = new URL(`private/templates`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1311,6 +1420,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1328,9 +1439,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/templates/${templateId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -1340,6 +1451,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1352,12 +1465,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#inspecting-template
    */
-  async listTemplates(token: AccessToken | undefined, params?: PaginationParams) {
+  async listTemplates(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`private/templates`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1366,6 +1482,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTemplateSummaryResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1379,9 +1497,9 @@ export class TalerMerchantInstanceHttpClient {
   async getTemplateDetails(token: AccessToken | undefined, templateId: string) {
     const url = new URL(`private/templates/${templateId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1390,6 +1508,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTemplateDetails());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1403,9 +1523,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteTemplate(token: AccessToken | undefined, templateId: string) {
     const url = new URL(`private/templates/${templateId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1414,6 +1534,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1454,7 +1576,7 @@ export class TalerMerchantInstanceHttpClient {
       body,
     });
 
-    return this.procesOrderCreationResponse(resp)
+    return this.procesOrderCreationResponse(resp);
   }
 
   //
@@ -1464,12 +1586,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCES]-private-webhooks
    */
-  async addWebhook(token: AccessToken | undefined, body: TalerMerchantApi.WebhookAddDetails) {
+  async addWebhook(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.WebhookAddDetails,
+  ) {
     const url = new URL(`private/webhooks`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1480,6 +1605,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1497,9 +1624,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/webhooks/${webhookId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -1510,6 +1637,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
@@ -1522,12 +1651,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCES]-private-webhooks
    */
-  async listWebhooks(token: AccessToken | undefined, params?: PaginationParams) {
+  async listWebhooks(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`private/webhooks`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1537,6 +1669,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opSuccessFromHttp(resp, codecForWebhookSummaryResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1550,9 +1684,9 @@ export class TalerMerchantInstanceHttpClient {
   async getWebhookDetails(token: AccessToken | undefined, webhookId: string) {
     const url = new URL(`private/webhooks/${webhookId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1561,6 +1695,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opSuccessFromHttp(resp, codecForWebhookDetails());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1574,9 +1710,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteWebhook(token: AccessToken | undefined, webhookId: string) {
     const url = new URL(`private/webhooks/${webhookId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1585,6 +1721,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1599,12 +1737,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#post-[-instances-$INSTANCES]-private-tokenfamilies
    */
-  async createTokenFamily(token: AccessToken | undefined, body: TalerMerchantApi.TokenFamilyCreateRequest) {
+  async createTokenFamily(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.TokenFamilyCreateRequest,
+  ) {
     const url = new URL(`private/tokenfamilies`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1615,6 +1756,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1632,9 +1775,9 @@ export class TalerMerchantInstanceHttpClient {
   ) {
     const url = new URL(`private/tokenfamilies/${tokenSlug}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1644,6 +1787,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTokenFamilyDetails());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1654,12 +1799,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCES]-private-tokenfamilies
    */
-  async listTokenFamilies(token: AccessToken | undefined, params?: PaginationParams) {
+  async listTokenFamilies(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`private/tokenfamilies`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1669,6 +1817,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTokenFamiliesList());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1679,12 +1829,15 @@ export class TalerMerchantInstanceHttpClient {
   /**
    * https://docs.taler.net/core/api-merchant.html#get-[-instances-$INSTANCES]-private-tokenfamilies-$TOKEN_FAMILY_SLUG
    */
-  async getTokenFamilyDetails(token: AccessToken | undefined, tokenSlug: string) {
+  async getTokenFamilyDetails(
+    token: AccessToken | undefined,
+    tokenSlug: string,
+  ) {
     const url = new URL(`private/tokenfamilies/${tokenSlug}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1694,6 +1847,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForTokenFamilyDetails());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1707,9 +1862,9 @@ export class TalerMerchantInstanceHttpClient {
   async deleteTokenFamily(token: AccessToken | undefined, tokenSlug: string) {
     const url = new URL(`private/tokenfamilies/${tokenSlug}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1718,6 +1873,8 @@ export class TalerMerchantInstanceHttpClient {
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1734,7 +1891,6 @@ export class TalerMerchantInstanceHttpClient {
   getAuthenticationAPI(): URL {
     return new URL(`private/`, this.baseUrl);
   }
-
 }
 
 export type TalerMerchantManagementResultByMethod<
@@ -1767,12 +1923,15 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
   /**
    * https://docs.taler.net/core/api-merchant.html#post--management-instances
    */
-  async createInstance(token: AccessToken | undefined, body: TalerMerchantApi.InstanceConfigurationMessage) {
+  async createInstance(
+    token: AccessToken | undefined,
+    body: TalerMerchantApi.InstanceConfigurationMessage,
+  ) {
     const url = new URL(`management/instances`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1780,12 +1939,15 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
       headers,
     });
 
-
     switch (resp.status) {
       case HttpStatusCode.NoContent: {
-        this.cacheManagementEvictor.notifySuccess(TalerMerchantManagementCacheEviction.CREATE_INSTANCE)
+        this.cacheManagementEvictor.notifySuccess(
+          TalerMerchantManagementCacheEviction.CREATE_INSTANCE,
+        );
         return opEmptySuccess(resp);
       }
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Conflict:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1801,11 +1963,14 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     instanceId: string,
     body: TalerMerchantApi.InstanceAuthConfigurationMessage,
   ) {
-    const url = new URL(`management/instances/${instanceId}/auth`, this.baseUrl);
+    const url = new URL(
+      `management/instances/${instanceId}/auth`,
+      this.baseUrl,
+    );
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "POST",
@@ -1816,6 +1981,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1833,9 +2000,9 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
   ) {
     const url = new URL(`management/instances/${instanceId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "PATCH",
@@ -1845,6 +2012,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
         return opKnownHttpFailure(resp.status, resp);
       default:
@@ -1855,12 +2024,15 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
   /**
    * https://docs.taler.net/core/api-merchant.html#get--management-instances
    */
-  async listInstances(token: AccessToken | undefined, params?: PaginationParams) {
+  async listInstances(
+    token: AccessToken | undefined,
+    params?: PaginationParams,
+  ) {
     const url = new URL(`management/instances`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1870,6 +2042,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForInstancesResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       default:
         return opUnknownFailure(resp, await readTalerErrorResponse(resp));
     }
@@ -1882,9 +2056,9 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
   async getInstanceDetails(token: AccessToken | undefined, instanceId: string) {
     const url = new URL(`management/instances/${instanceId}`, this.baseUrl);
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1894,6 +2068,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     switch (resp.status) {
       case HttpStatusCode.Ok:
         return opSuccessFromHttp(resp, codecForQueryInstancesResponse());
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       default:
         return opUnknownFailure(resp, await readTalerErrorResponse(resp));
     }
@@ -1902,16 +2078,20 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
   /**
    * https://docs.taler.net/core/api-merchant.html#delete--management-instances-$INSTANCE
    */
-  async deleteInstance(token: AccessToken | undefined, instanceId: string, params: { purge?: boolean } = {}) {
+  async deleteInstance(
+    token: AccessToken | undefined,
+    instanceId: string,
+    params: { purge?: boolean } = {},
+  ) {
     const url = new URL(`management/instances/${instanceId}`, this.baseUrl);
 
     if (params.purge) {
       url.searchParams.set("purge", "YES");
     }
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "DELETE",
@@ -1920,6 +2100,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
     switch (resp.status) {
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.Unauthorized:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.NotFound:
@@ -1951,9 +2133,9 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
       url.searchParams.set("timeout_ms", String(params.timeout));
     }
 
-    const headers: Record<string, string> = {}
+    const headers: Record<string, string> = {};
     if (token) {
-      headers.Authorization = makeBearerTokenAuthHeader(token)
+      headers.Authorization = makeBearerTokenAuthHeader(token);
     }
     const resp = await this.httpLib.fetch(url.href, {
       method: "GET",
@@ -1964,6 +2146,8 @@ export class TalerMerchantManagementHttpClient extends TalerMerchantInstanceHttp
         return opSuccessFromHttp(resp, codecForAccountKycRedirects());
       case HttpStatusCode.NoContent:
         return opEmptySuccess(resp);
+      case HttpStatusCode.Unauthorized: // FIXME: missing in docs
+        return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.BadGateway:
         return opKnownHttpFailure(resp.status, resp);
       case HttpStatusCode.ServiceUnavailable: