@code-collective/booking-widget 1.0.7 → 1.0.9

package/src/lib/api.ts

@@ -18,9 +18,70 @@ import { dateKey } from './utils';
 // Lets a caller distinguish "the server said no, and specifically why" (e.g. 402 - not paid yet, retryable
 // while Peach's webhook is still in flight) from any other failure, without parsing the message string.
 export class ApiError extends Error {
-  constructor(public readonly status: number) {
+  constructor(
+    public readonly status: number,
+    public readonly body?: unknown,
+  ) {
     super(`API error ${status}`);
   }
+
+  // The server's own machine-readable reason, where it sends one. Several distinct failures share a status -
+  // a price that moved and a malformed request are both 400 - and only this tells them apart.
+  get code(): string | undefined {
+    return typeof this.body === 'object' && this.body !== null && 'error' in this.body
+      ? String((this.body as { error: unknown }).error)
+      : undefined;
+  }
+}
+
+// The price of an item changed between the widget displaying it and the item being added, and the amount the
+// customer agreed to is no longer one the server will accept. Recoverable, but only by showing the customer
+// the new price - see PRICE_MISMATCH handling in TicketConfigurator/EditBookingView.
+export function isPriceMismatch(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 400 && e.code === 'PRICE_MISMATCH';
+}
+
+// The cart token the widget holds no longer names a live cart - it expired (idle or absolute) or was never
+// valid. Every cart route answers this the same way, and the only recovery is a fresh cart.
+export function isInvalidCart(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 401;
+}
+
+// The cart is past the point of being modified or extended - a payment is in flight for it or already done
+// (CheckoutCartEndpoints.CartLockedResult). Unlike the other 409s the API sends, this one carries no code.
+export function isCartLocked(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 409 && e.code === undefined;
+}
+
+// extendCart was refused because the cart's one clock has already run out. Only ever answered while a payment
+// is in flight - anywhere else an expired cart is a plain 401 - because such a cart still validates so its
+// charge can be confirmed, yet its time is up. Not a 401 on purpose: the widget must not drop the cart while
+// a charge may be landing, but tear the attempt down through abandonPayment (Peach's real status permitting).
+export function isCartExpired(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 409 && e.code === 'CART_EXPIRED';
+}
+
+// abandonPayment was refused because Peach's webhook already settled this attempt - most likely as paid. The
+// shopper's money is against the cart, so the right move is to confirm it, not to report it expired.
+export function isPaymentSettled(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 409 && e.code === 'PAYMENT_SETTLED';
+}
+
+// abandonPayment was refused because Peach still has this attempt in flight (a 3-D Secure check or similar has
+// not reached a final outcome). Not paid yet, but a charge may still land, so the cart must not be reopened -
+// wait for the outcome instead. Peach times a pending attempt out within about 30 minutes, after which
+// abandoning may be accepted again.
+export function isPaymentPending(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 409 && e.code === 'PAYMENT_PENDING';
+}
+
+// confirmCart was refused because Peach's webhook already landed with a decline (or other non-success
+// outcome) for this attempt - there is no charge to confirm and waiting longer will not change that. Distinct
+// from the plain 402 confirmCart otherwise answers with (not paid yet, keep retrying while the webhook is
+// still in flight): without this, a declined card retries the same way a slow-but-live one does, and only
+// ever surfaces as "still confirming", never as the decline it actually was.
+export function isPaymentFailed(e: unknown): e is ApiError {
+  return e instanceof ApiError && e.status === 409 && e.code === 'PAYMENT_FAILED';
 }
 
 export interface BookingApi {
@@ -51,6 +112,15 @@ export interface BookingApi {
   removeCartItem(itemId: string): Promise<void>;
   payCart(contact: OctoContact): Promise<CheckoutCartPaymentInitiationDto>;
   confirmCart(): Promise<CheckoutCartConfirmResultDto>;
+  // Slides the cart's idle window out to a full window from now, clamped at its absolute ceiling, and
+  // re-extends the OCTO holds behind it. There is no refusal to handle: a cart already at its ceiling comes
+  // back with the deadline it already had (see isAtExpiryCeiling). Returns the cart with its new expiry so the
+  // countdown resumes from the server's numbers rather than a local guess.
+  extendCart(): Promise<CheckoutCartDetailDto>;
+  // Reports a specific Peach attempt dead without an outcome so the server reopens the cart for a new one -
+  // used by CheckoutModal itself, which knows the checkoutId Peach's own callback fired for. See
+  // isPaymentSettled for the one refusal that changes what the caller does next.
+  abandonPayment(checkoutId: string): Promise<void>;
 }
 
 export class ApiClient implements BookingApi {
@@ -78,7 +148,7 @@ export class ApiClient implements BookingApi {
 
   private unwrap<T>(result: { data?: T; error?: unknown; response: Response }): T {
     if (result.data === undefined) {
-      throw new ApiError(result.response.status);
+      throw new ApiError(result.response.status, result.error);
     }
     return result.data;
   }
@@ -210,4 +280,21 @@ export class ApiClient implements BookingApi {
       await this.client.POST('/v1/checkout/cart/confirm'),
     );
   }
+
+  async extendCart(): Promise<CheckoutCartDetailDto> {
+    return this.unwrap(
+      await this.client.POST('/v1/checkout/cart/extend'),
+    );
+  }
+
+  async abandonPayment(checkoutId: string): Promise<void> {
+    const result = await this.client.POST('/v1/checkout/cart/abandon-payment', {
+      body: { checkoutId },
+    });
+    // 204 on success, so there is no data to unwrap - same shape as removeCartItem. The error body is kept:
+    // the 409s here carry a code the caller branches on (see isPaymentSettled).
+    if (result.response.status >= 400) {
+      throw new ApiError(result.response.status, result.error);
+    }
+  }
 }

package/src/lib/cart-expiry.ts

@@ -0,0 +1,46 @@
+import type { CheckoutCartDetailDto } from './client-types';
+
+// Whether the "are you still there?" prompt - and with it the shopper's ability to extend the cart - is
+// offered at all. Switched off for now: the cart gets one flat window (CheckoutCartService.IdleDuration,
+// 20 minutes), the countdown shows on every step, and at 0:00 the shopper sees "Your cart has expired" and
+// starts again. The prompt, the extend call and everything the server does for them stay in place behind
+// this flag so a later change can turn them back on without rebuilding any of it. CartExpiryGuard takes it
+// as a prop defaulting to this, so tests can exercise the prompt with it on.
+export const EXTENSION_ENABLED = false;
+
+// How long before the deadline the page-wide "are you still shopping?" prompt appears, when it is enabled at
+// all (EXTENSION_ENABLED above). The one source of truth for the lead time - the guard's prompt reads it from
+// here. Three minutes against the server's 20-minute idle window (CheckoutCartService.IdleDuration) would put
+// the prompt at 17 minutes on a fresh cart, with the cart expiring at 20 if it went unanswered.
+export const EXPIRY_WARNING_MS = 3 * 60 * 1000;
+
+export function formatRemaining(ms: number): string {
+  const clamped = Math.max(0, ms);
+  const mins = Math.floor(clamped / 60000);
+  const secs = Math.floor((clamped % 60000) / 1000);
+  return `${String(mins).padStart(2, '0')}:${String(secs).padStart(2, '0')}`;
+}
+
+// The cart's own clock: one standard idle window that only answering the "still there?" prompt slides forward
+// (adding or editing an item deliberately do not, and paying only holds it to a floor so the card form always
+// has time for card entry - CheckoutCartService.PaymentWindowFloor), clamped at the absolute ceiling from
+// creation (see CheckoutCartService's own remarks). idleExpiresAt is therefore always the sooner of the two.
+export function cartDeadline(cart: CheckoutCartDetailDto): Date {
+  return new Date(instant(cart.idleExpiresAt));
+}
+
+// Whether the idle window has been slid as far as the absolute ceiling allows, so answering the prompt again
+// cannot buy any more time. Derived from the two instants the cart already carries rather than from a failed
+// request: the server has no refusal to report, it simply hands back the same deadline.
+export function isAtExpiryCeiling(cart: CheckoutCartDetailDto): boolean {
+  return instant(cart.idleExpiresAt) >= instant(cart.absoluteExpiresAt);
+}
+
+// The latest instant a Date can hold - "no deadline". The API always sends idleExpiresAt; the generated type
+// only marks it optional because of its nullability defaults, so this is a type-level fallback, not a case the
+// server produces.
+const NoDeadline = 8.64e15;
+
+function instant(iso: string | null | undefined): number {
+  return iso ? new Date(iso).getTime() : NoDeadline;
+}

package/src/lib/cart-manager.ts

@@ -1,8 +1,19 @@
 import type { CheckoutCartResult } from './client-types';
 import type { BookingApi } from './api';
+import { forgetPaymentAttempt } from './payment-attempt';
 
 const STORAGE_KEY = 'morii-checkout-cart';
 
+// sessionStorage, not localStorage: the cart token is a full pay/confirm capability, and the widget ships as
+// a shadow:none custom element, so it runs in the *merchant's* top-level origin - its web storage is shared
+// with every other script on that page. sessionStorage narrows the exposure to the one tab and clears it when
+// that tab closes (it still survives reloads and same-tab navigation, so the cart-survives-reload behaviour is
+// unchanged), rather than persisting the token across all tabs indefinitely. The token is additionally bound
+// to this origin server-side (see CheckoutCart.OriginAtIssue), so it cannot be lifted and replayed from
+// another site; what remains - a hostile script on the merchant's own page - is inherent to shadow:none
+// embedding and can only be fully closed by isolating the widget in its own iframe origin.
+const storage: Storage | null = typeof sessionStorage !== 'undefined' ? sessionStorage : null;
+
 interface StoredCart {
   cartToken: string;
   absoluteExpiresAt: string;
@@ -40,11 +51,16 @@ export class CartManager {
   // ensureCart to mint a fresh one after the server refuses an operation on the cart it was given.
   reset(): void {
     this.cart = null;
+    // Also cleared on the api - loadFromStorage sets it there, so leaving it behind would keep sending the
+    // dropped cart's token on every subsequent request.
+    this.api.cartToken = '';
     try {
-      localStorage.removeItem(STORAGE_KEY);
+      storage?.removeItem(STORAGE_KEY);
     } catch {
-      // localStorage unavailable (e.g. iframe sandbox)
+      // storage unavailable (e.g. iframe sandbox, or a browser blocking site data)
     }
+    // A Peach attempt only ever belongs to the cart it was started for.
+    forgetPaymentAttempt();
   }
 
   private isExpired(): boolean {
@@ -59,20 +75,21 @@ export class CartManager {
       absoluteExpiresAt: this.cart.absoluteExpiresAt ?? '',
     };
     try {
-      localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+      storage?.setItem(STORAGE_KEY, JSON.stringify(stored));
     } catch {
-      // localStorage unavailable (e.g. iframe sandbox)
+      // storage unavailable (e.g. iframe sandbox, or a browser blocking site data)
     }
   }
 
   private loadFromStorage(): void {
     try {
-      const raw = localStorage.getItem(STORAGE_KEY);
+      const raw = storage?.getItem(STORAGE_KEY);
       if (!raw) return;
 
       const stored: StoredCart = JSON.parse(raw);
       if (new Date(stored.absoluteExpiresAt).getTime() <= Date.now()) {
-        localStorage.removeItem(STORAGE_KEY);
+        storage?.removeItem(STORAGE_KEY);
+        forgetPaymentAttempt();
         return;
       }
 

package/src/lib/client-types.ts

@@ -29,6 +29,12 @@ export interface PaymentStatus {
   outcome: PaymentOutcome;
   resultCode?: string;
   resultDescription?: string;
+  // Only meaningful for outcome 'failed'. A card that was actually charged - which is every 'failed' this
+  // gateway produces once confirmation itself is what failed, not the payment - must never be offered a
+  // "try again" that re-opens the card form, since the shopper would be charged a second time for a booking
+  // that already has their money against it. Defaults true (the ordinary declined/expired/errored case,
+  // where nothing was charged and retrying is exactly correct) so existing callers need not set it.
+  retryPayment?: boolean;
 }
 
 export interface CartItem {

package/src/lib/elements/bw-cart.svelte

@@ -3,6 +3,7 @@
 <script lang="ts">
   import CartOverview from '../CartOverview.svelte';
   import type { CartOverviewDisplay } from '../config';
+  import { onWidgetMessage } from '../messages';
   import { getSharedServices } from './shared';
 
   let {
@@ -19,21 +20,11 @@
     host.dispatchEvent(new CustomEvent(name, { detail, bubbles: true, composed: true }));
   }
 
-  function handleMessage(e: MessageEvent) {
-    let d: Record<string, unknown>;
-    try { d = typeof e.data === 'string' ? JSON.parse(e.data) : e.data; }
-    catch { return; }
-    if (!d?.type) return;
-
+  $effect(() => onWidgetMessage((d) => {
     if (d.type === 'modal:open') {
       dispatch('bw:checkout', {});
     }
-  }
-
-  $effect(() => {
-    window.addEventListener('message', handleMessage);
-    return () => window.removeEventListener('message', handleMessage);
-  });
+  }));
 </script>
 
 {#if ready}

package/src/lib/elements/bw-checkout.svelte

@@ -3,6 +3,7 @@
 <script lang="ts">
   import Checkout from '../Checkout.svelte';
   import { resolveWizardPages, resolveEditPages } from '../config';
+  import { onWidgetMessage } from '../messages';
   import { getSharedServices } from './shared';
 
   let {
@@ -17,7 +18,7 @@
   let isModal = $derived(isModalAttr !== undefined);
   let showModal = $state(false);
 
-  const { api, ready: readyPromise } = getSharedServices();
+  const { api, cartManager, ready: readyPromise } = getSharedServices();
 
   let ready = $state(false);
   readyPromise.then(() => { ready = true; });
@@ -34,30 +35,22 @@
   export function open() { showModal = true; }
   export function close() { showModal = false; dispatch('bw:close', {}); }
 
-  function handleMessage(e: MessageEvent) {
-    let d: Record<string, unknown>;
-    try { d = typeof e.data === 'string' ? JSON.parse(e.data) : e.data; }
-    catch { return; }
-    if (!d?.type) return;
-
+  $effect(() => onWidgetMessage((d) => {
     if (d.type === 'modal:close') {
       if (isModal) showModal = false;
       dispatch('bw:close', {});
     }
     if (d.type === 'order:complete') {
-      if (isModal) showModal = false;
+      // Deliberately does not close the modal - order:complete only reports that the order is confirmed
+      // (for host analytics/cart-clearing), not that the shopper has finished looking at the result screen.
+      // The modal stays open until they dismiss it themselves, which sends modal:close separately.
       dispatch('bw:order-confirmed', {
         cartToken: d.cartToken ?? '',
         value: d.value ?? 0,
         currency: d.currency ?? 'ZAR',
       });
     }
-  }
-
-  $effect(() => {
-    window.addEventListener('message', handleMessage);
-    return () => window.removeEventListener('message', handleMessage);
-  });
+  }));
 
   // Listen for a custom 'bw:open' event so register.ts can trigger it
   $effect(() => {
@@ -74,12 +67,12 @@
     <div class="bw-modal-overlay" onclick={() => close()}>
       <!-- svelte-ignore a11y_click_events_have_key_events a11y_no_static_element_interactions -->
       <div class="bw-modal-inner" onclick={(e) => e.stopPropagation()}>
-        <Checkout {api} {wizardPages} {editPages} {autoSelectSingleTimeSlot} />
+        <Checkout {api} {cartManager} {wizardPages} {editPages} {autoSelectSingleTimeSlot} />
       </div>
     </div>
   {/if}
 {:else if ready}
-  <Checkout {api} {wizardPages} {editPages} {autoSelectSingleTimeSlot} />
+  <Checkout {api} {cartManager} {wizardPages} {editPages} {autoSelectSingleTimeSlot} />
 {:else}
   <div class="loading-center"><div class="spinner"></div></div>
 {/if}

package/src/lib/elements/bw-configurator.svelte

@@ -3,7 +3,7 @@
 <script lang="ts">
   import TicketConfigurator from '../TicketConfigurator.svelte';
   import { resolveWizardPages } from '../config';
-  import { postMessage } from '../messages';
+  import { onWidgetMessage, postMessage } from '../messages';
   import { getSharedServices } from './shared';
 
   let {
@@ -26,12 +26,7 @@
   }
 
   // Forward postMessage events as CustomEvents
-  function handleMessage(e: MessageEvent) {
-    let d: Record<string, unknown>;
-    try { d = typeof e.data === 'string' ? JSON.parse(e.data) : e.data; }
-    catch { return; }
-    if (!d?.type) return;
-
+  $effect(() => onWidgetMessage((d) => {
     if (d.type === 'cart:change') {
       dispatch('bw:cart-change', {
         itemCount: d.itemCount ?? 0,
@@ -39,12 +34,7 @@
         totalFormatted: d.totalFormatted ?? '',
       });
     }
-  }
-
-  $effect(() => {
-    window.addEventListener('message', handleMessage);
-    return () => window.removeEventListener('message', handleMessage);
-  });
+  }));
 
   const onCancel = cancelable !== undefined
     ? () => { postMessage({ type: 'modal:close' }); dispatch('bw:cancel', {}); }

package/src/lib/elements/register.ts

@@ -4,6 +4,9 @@ import { ApiClient } from '../api';
 import { SessionManager } from '../session-manager';
 import { CartManager } from '../cart-manager';
 import { defaultApiBaseUrl } from './env';
+import { onWidgetMessage } from '../messages';
+import { mount } from 'svelte';
+import CartExpiryGuard from '../CartExpiryGuard.svelte';
 
 // Bootstrap shared services BEFORE element imports trigger connectedCallback.
 // Elements read from window.__bwServices instead of importing shared.ts,
@@ -17,6 +20,30 @@ sessionManager.startBackgroundRefresh();
 const ready = sessionManager.ensureSession(checkoutKey).then(() => {});
 (window as any).__bwServices = { api, cartManager, ready };
 
+function whenDomReady(fn: () => void) {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', fn, { once: true });
+  } else {
+    fn();
+  }
+}
+
+// Mounted once, directly on <body> - not inside any <bw-*> element's own tree, so the "still shopping?"
+// warning and the expiry it can lead to work regardless of which combination of elements (if any include
+// <bw-checkout> at all) the merchant actually placed on this page. Session readiness is irrelevant to it -
+// cart operations only need the cart token, never the session token - so it does not wait on `ready`.
+//
+// Deferred to DOMContentLoaded rather than run inline: a <script> placed in <head> without defer/type=module
+// runs before <body> exists at all, and document.body would be null here. An exception at module level would
+// also skip the cart:updated forwarding and autoWire below, not just the expiry guard.
+function mountExpiryGuard() {
+  const guardHost = document.createElement('div');
+  guardHost.dataset.bwExpiryGuard = '';
+  document.body.appendChild(guardHost);
+  mount(CartExpiryGuard, { target: guardHost, props: { api, cartManager } });
+}
+whenDomReady(mountExpiryGuard);
+
 import './bw-configurator.svelte';
 import './bw-cart.svelte';
 import './bw-checkout.svelte';
@@ -26,13 +53,13 @@ import './bw-checkout.svelte';
 // cart TicketConfigurator/CheckoutModal already fetch for their own posting - see those files' own comments -
 // so a consumer can build a custom cart summary (item count, remaining time, item details) without calling
 // the checkout API directly.
-window.addEventListener('message', (e) => {
-  let d: Record<string, unknown>;
-  try { d = typeof e.data === 'string' ? JSON.parse(e.data) : e.data; }
-  catch { return; }
-  if (d?.type === 'cart:updated' && 'cart' in d) {
+onWidgetMessage((d) => {
+  if (d.type === 'cart:updated' && 'cart' in d) {
     window.dispatchEvent(new CustomEvent('bw:cart-updated', { detail: { cart: d.cart } }));
   }
+  if (d.type === 'cart:expired') {
+    window.dispatchEvent(new CustomEvent('bw:cart-expired'));
+  }
 });
 
 interface BwOptions {
@@ -166,8 +193,4 @@ function autoWire() {
   });
 }
 
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', autoWire);
-} else {
-  autoWire();
-}
+whenDomReady(autoWire);

package/src/lib/generated-types.ts

@@ -125,6 +125,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/checkout/cart/extend": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Extend checkout cart */
+        post: operations["ExtendCheckoutCart_v1"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/checkout/cart/abandon-payment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Abandon checkout cart payment */
+        post: operations["AbandonCheckoutCartPayment_v1"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/checkout/supplier": {
         parameters: {
             query?: never;
@@ -210,6 +244,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/webhooks/peach": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["ReceivePeachWebhook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -228,9 +278,6 @@ export interface components {
             notes?: string | null;
             /** Format: int32 */
             amount?: number;
-            currencyCode?: string | null;
-            /** Format: int32 */
-            currencyPrecision?: number;
         };
         CheckoutAvailabilityCalendarDto: {
             /**
@@ -311,6 +358,9 @@ export interface components {
              */
             localDate?: string;
         };
+        CheckoutCartAbandonPaymentDto: {
+            checkoutId?: string | null;
+        };
         CheckoutCartConfirmItemResultDto: {
             /** Format: uuid */
             bookingUuid?: string;
@@ -373,6 +423,7 @@ export interface components {
         CheckoutCartPaymentInitiationDto: {
             checkoutId?: string | null;
             redirectUrl?: string | null;
+            entityId?: string | null;
         };
         CheckoutCartResult: {
             cartToken?: string | null;
@@ -392,6 +443,18 @@ export interface components {
              */
             absoluteExpiresAt?: string;
         };
+        CheckoutFaqDto: {
+            question: string | null;
+            answer: string | null;
+        };
+        CheckoutMediaDto: {
+            src: string | null;
+            type: string | null;
+            rel: string | null;
+            title?: string | null;
+            caption?: string | null;
+            copyright?: string | null;
+        };
         CheckoutOpeningHoursDto: {
             from: string | null;
             to: string | null;
@@ -428,7 +491,14 @@ export interface components {
             id: string | null;
             internalName: string | null;
             title?: string | null;
+            shortDescription?: string | null;
             description?: string | null;
+            media?: components["schemas"]["CheckoutMediaDto"][] | null;
+            /** Format: int32 */
+            durationMinutesFrom?: number | null;
+            /** Format: int32 */
+            durationMinutesTo?: number | null;
+            faqs?: components["schemas"]["CheckoutFaqDto"][] | null;
             options: components["schemas"]["CheckoutOptionDto"][] | null;
         };
         CheckoutSessionDto: {
@@ -715,6 +785,48 @@ export interface operations {
             };
         };
     };
+    ExtendCheckoutCart_v1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CheckoutCartDetailDto"];
+                };
+            };
+        };
+    };
+    AbandonCheckoutCartPayment_v1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CheckoutCartAbandonPaymentDto"];
+            };
+        };
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     CheckoutGetSupplier_v1: {
         parameters: {
             query?: never;
@@ -825,4 +937,22 @@ export interface operations {
             };
         };
     };
+    ReceivePeachWebhook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
 }