@cimplify/sdk 0.2.4 → 0.3.0

package/dist/index.js

@@ -1,6 +1,45 @@
 'use strict';
 
 // src/types/common.ts
+var ErrorCode = {
+  // General
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  // Cart
+  CART_EMPTY: "CART_EMPTY",
+  CART_EXPIRED: "CART_EXPIRED",
+  CART_NOT_FOUND: "CART_NOT_FOUND",
+  ITEM_UNAVAILABLE: "ITEM_UNAVAILABLE",
+  VARIANT_NOT_FOUND: "VARIANT_NOT_FOUND",
+  VARIANT_OUT_OF_STOCK: "VARIANT_OUT_OF_STOCK",
+  ADDON_REQUIRED: "ADDON_REQUIRED",
+  ADDON_MAX_EXCEEDED: "ADDON_MAX_EXCEEDED",
+  // Checkout
+  CHECKOUT_VALIDATION_FAILED: "CHECKOUT_VALIDATION_FAILED",
+  DELIVERY_ADDRESS_REQUIRED: "DELIVERY_ADDRESS_REQUIRED",
+  CUSTOMER_INFO_REQUIRED: "CUSTOMER_INFO_REQUIRED",
+  // Payment
+  PAYMENT_FAILED: "PAYMENT_FAILED",
+  PAYMENT_CANCELLED: "PAYMENT_CANCELLED",
+  INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS",
+  CARD_DECLINED: "CARD_DECLINED",
+  INVALID_OTP: "INVALID_OTP",
+  OTP_EXPIRED: "OTP_EXPIRED",
+  AUTHORIZATION_FAILED: "AUTHORIZATION_FAILED",
+  PAYMENT_ACTION_NOT_COMPLETED: "PAYMENT_ACTION_NOT_COMPLETED",
+  // Scheduling
+  SLOT_UNAVAILABLE: "SLOT_UNAVAILABLE",
+  BOOKING_CONFLICT: "BOOKING_CONFLICT",
+  SERVICE_NOT_FOUND: "SERVICE_NOT_FOUND",
+  // Inventory
+  OUT_OF_STOCK: "OUT_OF_STOCK",
+  INSUFFICIENT_QUANTITY: "INSUFFICIENT_QUANTITY"
+};
 var CimplifyError = class extends Error {
   constructor(code, message, retryable = false) {
     super(message);
@@ -8,7 +47,24 @@ var CimplifyError = class extends Error {
     this.retryable = retryable;
     this.name = "CimplifyError";
   }
+  /** User-friendly message safe to display */
+  get userMessage() {
+    return this.message;
+  }
 };
+function isCimplifyError(error) {
+  return error instanceof CimplifyError;
+}
+function isRetryableError(error) {
+  if (isCimplifyError(error)) {
+    return error.retryable;
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("network") || msg.includes("timeout") || msg.includes("fetch");
+  }
+  return false;
+}
 
 // src/catalogue.ts
 var CatalogueQueries = class {
@@ -220,7 +276,91 @@ var CatalogueQueries = class {
   }
 };
 
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function mapResult(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapError(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function flatMap(result, fn) {
+  return result.ok ? fn(result.value) : result;
+}
+function getOrElse(result, defaultFn) {
+  return result.ok ? result.value : defaultFn();
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function toNullable(result) {
+  return result.ok ? result.value : void 0;
+}
+async function fromPromise(promise, mapError2) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function tryCatch(fn, mapError2) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function combine(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function combineObject(results) {
+  const values = {};
+  for (const [key, result] of Object.entries(results)) {
+    if (!result.ok) {
+      return result;
+    }
+    values[key] = result.value;
+  }
+  return ok(values);
+}
+
 // src/cart.ts
+function toCimplifyError(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
 var CartOperations = class {
   constructor(client) {
     this.client = client;
@@ -233,23 +373,25 @@ var CartOperations = class {
    * This is the main method for storefront display.
    */
   async get() {
-    return this.client.query("cart#enriched");
+    return safe(this.client.query("cart#enriched"));
   }
   async getRaw() {
-    return this.client.query("cart");
+    return safe(this.client.query("cart"));
   }
   async getItems() {
-    return this.client.query("cart_items");
+    return safe(this.client.query("cart_items"));
   }
   async getCount() {
-    return this.client.query("cart#count");
+    return safe(this.client.query("cart#count"));
   }
   async getTotal() {
-    return this.client.query("cart#total");
+    return safe(this.client.query("cart#total"));
   }
   async getSummary() {
-    const cart = await this.get();
-    return {
+    const cartResult = await this.get();
+    if (!cartResult.ok) return cartResult;
+    const cart = cartResult.value;
+    return ok({
       item_count: cart.items.length,
       total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
       subtotal: cart.pricing.subtotal,
@@ -257,55 +399,89 @@ var CartOperations = class {
       tax_amount: cart.pricing.tax_amount,
       total: cart.pricing.total_price,
       currency: cart.pricing.currency
-    };
+    });
   }
   // --------------------------------------------------------------------------
   // CART MUTATIONS
   // --------------------------------------------------------------------------
+  /**
+   * Add an item to the cart.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.cart.addItem({
+   *   item_id: "prod_burger",
+   *   quantity: 2,
+   *   variant_id: "var_large",
+   *   add_on_options: ["addon_cheese", "addon_bacon"],
+   * });
+   *
+   * if (!result.ok) {
+   *   switch (result.error.code) {
+   *     case ErrorCode.ITEM_UNAVAILABLE:
+   *       toast.error("Item no longer available");
+   *       break;
+   *     case ErrorCode.VARIANT_OUT_OF_STOCK:
+   *       toast.error("Selected option is out of stock");
+   *       break;
+   *   }
+   * }
+   * ```
+   */
   async addItem(input) {
-    return this.client.call("cart.addItem", input);
+    return safe(this.client.call("cart.addItem", input));
   }
   async updateItem(cartItemId, updates) {
-    return this.client.call("cart.updateItem", {
-      cart_item_id: cartItemId,
-      ...updates
-    });
+    return safe(
+      this.client.call("cart.updateItem", {
+        cart_item_id: cartItemId,
+        ...updates
+      })
+    );
   }
   async updateQuantity(cartItemId, quantity) {
-    return this.client.call("cart.updateItemQuantity", {
-      cart_item_id: cartItemId,
-      quantity
-    });
+    return safe(
+      this.client.call("cart.updateItemQuantity", {
+        cart_item_id: cartItemId,
+        quantity
+      })
+    );
   }
   async removeItem(cartItemId) {
-    return this.client.call("cart.removeItem", {
-      cart_item_id: cartItemId
-    });
+    return safe(
+      this.client.call("cart.removeItem", {
+        cart_item_id: cartItemId
+      })
+    );
   }
   async clear() {
-    return this.client.call("cart.clearCart");
+    return safe(this.client.call("cart.clearCart"));
   }
   // --------------------------------------------------------------------------
   // COUPONS & DISCOUNTS
   // --------------------------------------------------------------------------
   async applyCoupon(code) {
-    return this.client.call("cart.applyCoupon", {
-      coupon_code: code
-    });
+    return safe(
+      this.client.call("cart.applyCoupon", {
+        coupon_code: code
+      })
+    );
   }
   async removeCoupon() {
-    return this.client.call("cart.removeCoupon");
+    return safe(this.client.call("cart.removeCoupon"));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async isEmpty() {
-    const count = await this.getCount();
-    return count === 0;
+    const countResult = await this.getCount();
+    if (!countResult.ok) return countResult;
+    return ok(countResult.value === 0);
   }
   async hasItem(productId, variantId) {
-    const items = await this.getItems();
-    return items.some((item) => {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.some((item) => {
       const matchesProduct = item.item_id === productId;
       if (!variantId) return matchesProduct;
       const config = item.configuration;
@@ -314,10 +490,12 @@ var CartOperations = class {
       }
       return matchesProduct;
     });
+    return ok(found);
   }
   async findItem(productId, variantId) {
-    const items = await this.getItems();
-    return items.find((item) => {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.find((item) => {
       const matchesProduct = item.item_id === productId;
       if (!variantId) return matchesProduct;
       const config = item.configuration;
@@ -326,6 +504,7 @@ var CartOperations = class {
       }
       return matchesProduct;
     });
+    return ok(found);
   }
 };
 
@@ -420,37 +599,88 @@ var DEFAULT_CURRENCY = "GHS";
 var DEFAULT_COUNTRY = "GHA";
 
 // src/checkout.ts
+function toCimplifyError2(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe2(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError2(error));
+  }
+}
 var CheckoutService = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Process checkout with cart data.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.checkout.process({
+   *   cart_id: cart.id,
+   *   customer: { name, email, phone, save_details: true },
+   *   order_type: "pickup",
+   *   payment_method: "mobile_money",
+   *   mobile_money_details: { phone_number, provider: "mtn" },
+   * });
+   *
+   * if (!result.ok) {
+   *   switch (result.error.code) {
+   *     case ErrorCode.CART_EMPTY:
+   *       toast.error("Your cart is empty");
+   *       break;
+   *     case ErrorCode.PAYMENT_FAILED:
+   *       toast.error("Payment failed. Please try again.");
+   *       break;
+   *   }
+   * }
+   * ```
+   */
   async process(data) {
-    return this.client.call(CHECKOUT_MUTATION.PROCESS, {
-      checkout_data: data
-    });
+    return safe2(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: data
+      })
+    );
   }
   async initializePayment(orderId, method) {
-    return this.client.call("order.initializePayment", {
-      order_id: orderId,
-      payment_method: method
-    });
+    return safe2(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
+      })
+    );
   }
   async submitAuthorization(input) {
-    return this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input);
+    return safe2(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    );
   }
   async pollPaymentStatus(orderId) {
-    return this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId);
+    return safe2(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    );
   }
   async updateOrderCustomer(orderId, customer) {
-    return this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
-      order_id: orderId,
-      ...customer
-    });
+    return safe2(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
+    );
   }
   async verifyPayment(orderId) {
-    return this.client.call("order.verifyPayment", {
-      order_id: orderId
-    });
+    return safe2(
+      this.client.call("order.verifyPayment", {
+        order_id: orderId
+      })
+    );
   }
 };
 
@@ -491,117 +721,173 @@ var OrderQueries = class {
 };
 
 // src/link.ts
+function toCimplifyError3(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe3(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError3(error));
+  }
+}
 var LinkService = class {
   constructor(client) {
     this.client = client;
   }
+  // --------------------------------------------------------------------------
+  // AUTHENTICATION
+  // --------------------------------------------------------------------------
   async requestOtp(input) {
-    return this.client.linkPost("/v1/link/auth/request-otp", input);
+    return safe3(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
   async verifyOtp(input) {
-    const response = await this.client.linkPost("/v1/link/auth/verify-otp", input);
-    if (response.session_token) {
-      this.client.setSessionToken(response.session_token);
+    const result = await safe3(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setSessionToken(result.value.session_token);
     }
-    return response;
+    return result;
   }
   async logout() {
-    const result = await this.client.linkPost("/v1/link/auth/logout");
-    this.client.clearSession();
+    const result = await safe3(this.client.linkPost("/v1/link/auth/logout"));
+    if (result.ok) {
+      this.client.clearSession();
+    }
     return result;
   }
+  // --------------------------------------------------------------------------
+  // STATUS & DATA
+  // --------------------------------------------------------------------------
   async checkStatus(contact) {
-    return this.client.call(LINK_MUTATION.CHECK_STATUS, {
-      contact
-    });
+    return safe3(
+      this.client.call(LINK_MUTATION.CHECK_STATUS, {
+        contact
+      })
+    );
   }
   async getLinkData() {
-    return this.client.query(LINK_QUERY.DATA);
+    return safe3(this.client.query(LINK_QUERY.DATA));
   }
   async getAddresses() {
-    return this.client.query(LINK_QUERY.ADDRESSES);
+    return safe3(this.client.query(LINK_QUERY.ADDRESSES));
   }
   async getMobileMoney() {
-    return this.client.query(LINK_QUERY.MOBILE_MONEY);
+    return safe3(this.client.query(LINK_QUERY.MOBILE_MONEY));
   }
   async getPreferences() {
-    return this.client.query(LINK_QUERY.PREFERENCES);
+    return safe3(this.client.query(LINK_QUERY.PREFERENCES));
   }
+  // --------------------------------------------------------------------------
+  // ENROLLMENT
+  // --------------------------------------------------------------------------
   async enroll(data) {
-    return this.client.call(LINK_MUTATION.ENROLL, data);
+    return safe3(this.client.call(LINK_MUTATION.ENROLL, data));
   }
   async enrollAndLinkOrder(data) {
-    return this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data);
+    return safe3(
+      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
+    );
   }
+  // --------------------------------------------------------------------------
+  // PREFERENCES
+  // --------------------------------------------------------------------------
   async updatePreferences(preferences) {
-    return this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences);
+    return safe3(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
   }
+  // --------------------------------------------------------------------------
+  // ADDRESSES
+  // --------------------------------------------------------------------------
   async createAddress(input) {
-    return this.client.call(LINK_MUTATION.CREATE_ADDRESS, input);
+    return safe3(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
   }
   async updateAddress(input) {
-    return this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input);
+    return safe3(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
   }
   async deleteAddress(addressId) {
-    return this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId);
+    return safe3(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
   }
   async setDefaultAddress(addressId) {
-    return this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId);
+    return safe3(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
   }
   async trackAddressUsage(addressId) {
-    return this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
-      address_id: addressId
-    });
+    return safe3(
+      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
+        address_id: addressId
+      })
+    );
   }
+  // --------------------------------------------------------------------------
+  // MOBILE MONEY
+  // --------------------------------------------------------------------------
   async createMobileMoney(input) {
-    return this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input);
+    return safe3(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
   }
   async deleteMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId);
+    return safe3(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
   }
   async setDefaultMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId);
+    return safe3(
+      this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
+    );
   }
   async trackMobileMoneyUsage(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
-      mobile_money_id: mobileMoneyId
-    });
+    return safe3(
+      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
+        mobile_money_id: mobileMoneyId
+      })
+    );
   }
   async verifyMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId);
+    return safe3(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+    );
   }
+  // --------------------------------------------------------------------------
+  // SESSIONS
+  // --------------------------------------------------------------------------
   async getSessions() {
-    return this.client.linkGet("/v1/link/sessions");
+    return safe3(this.client.linkGet("/v1/link/sessions"));
   }
   async revokeSession(sessionId) {
-    return this.client.linkDelete(`/v1/link/sessions/${sessionId}`);
+    return safe3(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
   }
   async revokeAllSessions() {
-    return this.client.linkDelete("/v1/link/sessions");
+    return safe3(this.client.linkDelete("/v1/link/sessions"));
   }
+  // --------------------------------------------------------------------------
+  // REST ALTERNATIVES (for direct API access)
+  // --------------------------------------------------------------------------
   async getAddressesRest() {
-    return this.client.linkGet("/v1/link/addresses");
+    return safe3(this.client.linkGet("/v1/link/addresses"));
   }
   async createAddressRest(input) {
-    return this.client.linkPost("/v1/link/addresses", input);
+    return safe3(this.client.linkPost("/v1/link/addresses", input));
   }
   async deleteAddressRest(addressId) {
-    return this.client.linkDelete(`/v1/link/addresses/${addressId}`);
+    return safe3(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
   }
   async setDefaultAddressRest(addressId) {
-    return this.client.linkPost(`/v1/link/addresses/${addressId}/default`);
+    return safe3(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
   }
   async getMobileMoneyRest() {
-    return this.client.linkGet("/v1/link/mobile-money");
+    return safe3(this.client.linkGet("/v1/link/mobile-money"));
   }
   async createMobileMoneyRest(input) {
-    return this.client.linkPost("/v1/link/mobile-money", input);
+    return safe3(this.client.linkPost("/v1/link/mobile-money", input));
   }
   async deleteMobileMoneyRest(mobileMoneyId) {
-    return this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`);
+    return safe3(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
   }
   async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`);
+    return safe3(
+      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+    );
   }
 };
 
@@ -1744,6 +2030,7 @@ exports.CimplifyClient = CimplifyClient;
 exports.CimplifyError = CimplifyError;
 exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
 exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.ErrorCode = ErrorCode;
 exports.InventoryService = InventoryService;
 exports.LINK_MUTATION = LINK_MUTATION;
 exports.LINK_QUERY = LINK_QUERY;
@@ -1761,25 +2048,41 @@ exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;
 exports.QueryBuilder = QueryBuilder;
 exports.SchedulingService = SchedulingService;
 exports.categorizePaymentError = categorizePaymentError;
+exports.combine = combine;
+exports.combineObject = combineObject;
 exports.createCimplifyClient = createCimplifyClient;
 exports.detectMobileMoneyProvider = detectMobileMoneyProvider;
+exports.err = err;
 exports.extractPriceInfo = extractPriceInfo;
+exports.flatMap = flatMap;
 exports.formatMoney = formatMoney;
 exports.formatNumberCompact = formatNumberCompact;
 exports.formatPrice = formatPrice;
 exports.formatPriceAdjustment = formatPriceAdjustment;
 exports.formatPriceCompact = formatPriceCompact;
 exports.formatProductPrice = formatProductPrice;
+exports.fromPromise = fromPromise;
 exports.getBasePrice = getBasePrice;
 exports.getCurrencySymbol = getCurrencySymbol;
 exports.getDiscountPercentage = getDiscountPercentage;
 exports.getDisplayPrice = getDisplayPrice;
 exports.getMarkupPercentage = getMarkupPercentage;
+exports.getOrElse = getOrElse;
 exports.getProductCurrency = getProductCurrency;
+exports.isCimplifyError = isCimplifyError;
+exports.isErr = isErr;
+exports.isOk = isOk;
 exports.isOnSale = isOnSale;
+exports.isRetryableError = isRetryableError;
+exports.mapError = mapError;
+exports.mapResult = mapResult;
 exports.normalizePaymentResponse = normalizePaymentResponse;
 exports.normalizeStatusResponse = normalizeStatusResponse;
+exports.ok = ok;
 exports.parsePrice = parsePrice;
 exports.parsePricePath = parsePricePath;
 exports.parsedPriceToPriceInfo = parsedPriceToPriceInfo;
 exports.query = query;
+exports.toNullable = toNullable;
+exports.tryCatch = tryCatch;
+exports.unwrap = unwrap;