@01.software/sdk 0.70.1 → 0.72.1

package/dist/client.js

@@ -85,6 +85,7 @@ var COMMERCE_ERROR_CODES = [
   "cart_not_active",
   "cart_locked",
   "cart_empty",
+  "shipping_address_required",
   "cart_market_unavailable",
   "cart_market_mismatch",
   "checkout_not_open",
@@ -101,6 +102,7 @@ var COMMERCE_ERROR_CODES = [
   "price_changed",
   "pricing_fact_in_use",
   "insufficient_stock",
+  "credit_insufficient",
   "reservation_conflict",
   "stock_lock_unavailable",
   "variant_not_found",
@@ -564,6 +566,8 @@ async function parseErrorBody(response) {
   try {
     const body = await response.json();
     const reason = typeof body.reason === "string" ? body.reason : typeof body.code === "string" ? body.code : void 0;
+    const payloadErrorReason = Array.isArray(body.errors) ? readPayloadErrorReason(body.errors) : void 0;
+    const payloadReasonField = payloadErrorReason !== void 0 ? { payloadErrorReason } : {};
     if (body.errors && Array.isArray(body.errors)) {
       const fieldErrors = [];
       for (const e of body.errors) {
@@ -586,6 +590,7 @@ async function parseErrorBody(response) {
           errorMessage: `HTTP ${response.status}: ${details}`,
           userMessage: details,
           reason,
+          ...payloadReasonField,
           body,
           errors: fieldErrors.length > 0 ? fieldErrors : body.errors
         };
@@ -596,6 +601,7 @@ async function parseErrorBody(response) {
         errorMessage: `HTTP ${response.status}: ${body.error}`,
         userMessage: body.error,
         reason,
+        ...payloadReasonField,
         body
       };
     }
@@ -604,14 +610,23 @@ async function parseErrorBody(response) {
         errorMessage: `HTTP ${response.status}: ${body.message}`,
         userMessage: body.message,
         reason,
+        ...payloadReasonField,
         body
       };
     }
-    return { ...fallback, reason, body };
+    return { ...fallback, reason, ...payloadReasonField, body };
   } catch {
     return fallback;
   }
 }
+function readPayloadErrorReason(errors) {
+  const data = errors[0]?.data;
+  if (!data || typeof data !== "object") return void 0;
+  const { reason, code } = data;
+  if (typeof reason === "string") return reason;
+  if (typeof code === "string") return code;
+  return void 0;
+}
 function getParsedErrorSuggestion(status, parsed) {
   if (status === 403 && parsed.reason === "origin_not_allowed") {
     return "Add the request origin to the tenant Browser API origins, then retry the browser request.";
@@ -657,7 +672,10 @@ function mapResponseToError(status, parsed, details, requestId, retryAfter, cano
     if (retryAfter !== void 0) {
       Object.assign(withRequestId, { retryAfter });
     }
-    return canonicalCommerceError ? enhanceCommerceError(withRequestId, parsed.body, requestId) : enhanceNonCommerceError(withRequestId, parsed.reason);
+    return canonicalCommerceError ? enhanceCommerceError(withRequestId, parsed.body, requestId) : enhanceNonCommerceError(
+      withRequestId,
+      parsed.reason ?? parsed.payloadErrorReason
+    );
   };
   if (status === 400 || status === 422) {
     return finalize(
@@ -1076,6 +1094,7 @@ async function parseApiResponse(response, endpoint, options = {}) {
 // ../../internal/http-contracts/src/index.ts
 var operationBrand = /* @__PURE__ */ Symbol("sdk-http-operation");
 var PORTONE_STANDARD_ACTION_CAPABILITIES_MEDIA_TYPE = "application/vnd.01software.portone-action-capabilities.v1+json";
+var CUSTOMER_CREDIT_FUNDING_MEDIA_TYPE = "application/vnd.01software.credit-funding.v1+json";
 var operation = (collection, method, path, errorFamily) => Object.freeze({
   [operationBrand]: true,
   collection,
@@ -1239,6 +1258,11 @@ var portOneStandardActionCapabilityOperations = /* @__PURE__ */ new Set([
 ]);
 var MEMBERSHIP_ENDPOINT_OPERATIONS = {
   subscribe: operation(null, "post", "/memberships/subscribe"),
+  endSubscribeIntent: operation(
+    null,
+    "post",
+    "/memberships/subscribe-intent/end"
+  ),
   billingCustody: operation(null, "post", "/memberships/billing-custody"),
   cancel: operation(null, "post", "/memberships/:id/cancel"),
   me: operation(null, "get", "/memberships/me"),
@@ -1284,6 +1308,19 @@ var BENEFIT_VOUCHER_ENDPOINT_OPERATIONS = {
   void: operation("customers", "post", "/benefit-vouchers/void"),
   listMine: operation("customers", "get", "/me/benefit-vouchers")
 };
+var CUSTOMER_CREDIT_ENDPOINT_OPERATIONS = {
+  grant: strictCommerceOperation("customers", "post", "/credits/grant"),
+  getGrant: strictCommerceOperation("customers", "post", "/credits/get-grant"),
+  getAccount: strictCommerceOperation("customers", "post", "/credits/account"),
+  revoke: strictCommerceOperation("customers", "post", "/credits/revoke"),
+  mine: strictCommerceOperation("customers", "get", "/me/credits"),
+  history: strictCommerceOperation("customers", "get", "/me/credits/history"),
+  configure: strictCommerceOperation(
+    "customers",
+    "post",
+    "/credits/configuration"
+  )
+};
 var CUSTOMER_GROUP_ENDPOINT_OPERATIONS = {
   members: operation("customer-groups", "get", "/:id/members"),
   grant: operation("customer-groups", "post", "/:id/members/grant"),
@@ -1673,6 +1710,140 @@ var CustomerBenefitVouchersApi = class extends CustomerScopedApi {
   }
 };
 
+// src/core/api/customer-credit-types.ts
+function invalid() {
+  throw createApiError("Invalid customer credit response", 502);
+}
+function object2(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== keys.length || keys.some((key) => !Object.prototype.hasOwnProperty.call(value, key)))
+    invalid();
+  return value;
+}
+function money(value) {
+  return typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value);
+}
+function uuid2(value) {
+  return typeof value === "string" && /^([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i.test(
+    value
+  );
+}
+function time2(value) {
+  if (typeof value !== "string") return false;
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?Z$/.exec(value);
+  if (!match) return false;
+  const [, year, month, day, hour, minute, second = "0"] = match;
+  const y = Number(year), m = Number(month), d = Number(day);
+  const days = [
+    31,
+    y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+  ];
+  return m >= 1 && m <= 12 && d >= 1 && d <= days[m - 1] && Number(hour) < 24 && Number(minute) < 60 && Number(second) < 60;
+}
+var states = ["available", "held", "spent", "expired", "revoked"];
+function balances(value) {
+  const data = object2(value, states);
+  if (states.some((key) => !money(data[key]))) invalid();
+}
+function page(value) {
+  if (value.currency !== "KRW" || !time2(value.evaluatedAt) || !Number.isSafeInteger(value.page) || value.page < 1 || typeof value.hasNextPage !== "boolean")
+    invalid();
+}
+function parseMyCustomerCredits(value) {
+  const data = object2(value, [
+    "currency",
+    "evaluatedAt",
+    "granted",
+    "balances",
+    "buckets",
+    "page",
+    "hasNextPage"
+  ]);
+  page(data);
+  balances(data.balances);
+  if (!money(data.granted) || !Array.isArray(data.buckets) || data.buckets.length > 50)
+    invalid();
+  for (const value2 of data.buckets) {
+    const bucket = object2(value2, [
+      "id",
+      "grantId",
+      "kind",
+      "grantedAt",
+      "expiresAt",
+      "isRevoked",
+      "balances"
+    ]);
+    if (!uuid2(bucket.id) || !uuid2(bucket.grantId) || !["original", "grace"].includes(bucket.kind) || !time2(bucket.grantedAt) || !time2(bucket.expiresAt) || typeof bucket.isRevoked !== "boolean")
+      invalid();
+    balances(bucket.balances);
+  }
+  return value;
+}
+function parseMyCustomerCreditHistory(value) {
+  const data = object2(value, [
+    "currency",
+    "evaluatedAt",
+    "entries",
+    "page",
+    "hasNextPage"
+  ]);
+  page(data);
+  if (!Array.isArray(data.entries) || data.entries.length > 50) invalid();
+  for (const value2 of data.entries) {
+    const entry = object2(value2, [
+      "id",
+      "grantId",
+      "kind",
+      "amount",
+      "fromState",
+      "toState",
+      "createdAt"
+    ]);
+    if (!uuid2(entry.id) || !uuid2(entry.grantId) || !money(entry.amount) || !time2(entry.createdAt) || ![
+      "grant",
+      "reserve",
+      "consume",
+      "release",
+      "restore",
+      "expire",
+      "revoke"
+    ].includes(entry.kind) || entry.fromState !== null && !states.includes(entry.fromState) || entry.toState !== null && !states.includes(entry.toState))
+      invalid();
+  }
+  return value;
+}
+
+// src/core/api/customer-credits-api.ts
+var CustomerCreditsApi = class extends CustomerScopedApi {
+  async mine(params = {}) {
+    const query = new URLSearchParams();
+    if (params.page !== void 0) query.set("page", String(params.page));
+    return parseMyCustomerCredits(
+      await this.requestEndpoint(CUSTOMER_CREDIT_ENDPOINT_OPERATIONS.mine, void 0, {
+        query
+      })
+    );
+  }
+  async history(params = {}) {
+    const query = new URLSearchParams();
+    if (params.page !== void 0) query.set("page", String(params.page));
+    return parseMyCustomerCreditHistory(
+      await this.requestEndpoint(CUSTOMER_CREDIT_ENDPOINT_OPERATIONS.history, void 0, {
+        query
+      })
+    );
+  }
+};
+
 // src/core/collection/http-client.ts
 import { stringify } from "qs-esm";
 function validateWhere(where) {
@@ -2123,11 +2294,11 @@ var CommunityClient = class extends RawCustomerScopedApi {
    * - `rootComment`: comments belonging to a thread rooted at that comment.
    */
   listComments(params) {
-    const { postId, page, limit, rootComment, topLevelOnly, sort } = params;
+    const { postId, page: page2, limit, rootComment, topLevelOnly, sort } = params;
     return this.execute(
       this.buildCommentsListQuery({
         postId,
-        page,
+        page: page2,
         limit,
         rootComment,
         topLevelOnly,
@@ -2138,11 +2309,11 @@ var CommunityClient = class extends RawCustomerScopedApi {
   }
   /** Direct replies to a comment (`where[parent][equals]`). */
   listReplies(params) {
-    const { commentId, page, limit, sort } = params;
+    const { commentId, page: page2, limit, sort } = params;
     return this.execute(
       this.buildCommentsListQuery({
         parentId: commentId,
-        page,
+        page: page2,
         limit,
         sort
       }),
@@ -2399,7 +2570,18 @@ var ABANDONED_REASONS = ["expired", "customer", "operator"];
 function managedPaymentProviders(providers) {
   return providers;
 }
-var PAYMENT_PROVIDERS = managedPaymentProviders(["toss", "portone"]);
+var PAYMENT_PROVIDERS = managedPaymentProviders([
+  "toss",
+  "portone",
+  "stripe"
+]);
+var CANCEL_RECOVERY_METHODS = {
+  toss: "cancel()",
+  portone: "cancelPortOne()",
+  stripe: null
+};
+var STRIPE_RETURN_URL_RAW_CHARACTERS = /^[^\s\u0000-\u001F\u007F\\]+$/;
+var STRIPE_RETURN_URL_AUTHORITY = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/?#@]+(?:[/?#]|$)/;
 var PAYMENT_PROVIDER_STATUSES = [
   "requires_payment_method",
   "requires_action",
@@ -2448,11 +2630,8 @@ function fail(resource, path, expected) {
   invalidCanonicalResponse(resource, { path, expected });
 }
 function providerMismatch(resource, expected, actual, operation2) {
-  if (operation2 === "cancel") {
-    const method = {
-      toss: "cancel()",
-      portone: "cancelPortOne()"
-    }[actual];
+  const method = CANCEL_RECOVERY_METHODS[actual];
+  if (operation2 === "cancel" && method !== null) {
     throw createApiError(
       `Canonical ${resource} response provider mismatch: expected ${expected}, received ${actual}.`,
       502,
@@ -2481,6 +2660,17 @@ function exact(value, required, optional, resource, path) {
   const unexpected = Object.keys(value).find((key) => !allowed.has(key));
   if (unexpected) fail(resource, `${path}.${unexpected}`, "no unknown fields");
 }
+function responseExtensionKeys(value, keys, resource, path) {
+  if (!keys.some((key) => Object.prototype.hasOwnProperty.call(value, key)))
+    return [];
+  enumValue(
+    value.deliveryMethod,
+    ["shipping", "pickup"],
+    resource,
+    `${path}.deliveryMethod`
+  );
+  return [...keys];
+}
 function string(value, resource, path) {
   if (typeof value !== "string" || value.length === 0) {
     fail(resource, path, "non-empty string");
@@ -2820,6 +3010,12 @@ function validatePublicCart(value, resource = "Cart") {
   exact(
     cart,
     [
+      ...responseExtensionKeys(
+        cart,
+        ["deliveryMethod", "shippingMinor", "totalMinor"],
+        resource,
+        "$"
+      ),
       "id",
       "status",
       "revision",
@@ -2890,6 +3086,13 @@ function validatePublicCart(value, resource = "Cart") {
   if (expectedSubtotal - BigInt(discount) < 0n || BigInt(estimatedTotal) !== expectedSubtotal - BigInt(discount)) {
     fail(resource, "$.estimatedTotalMinor", "subtotalMinor - discountMinor");
   }
+  if ("deliveryMethod" in cart) {
+    const shipping = safeMinor(cart.shippingMinor, resource, "$.shippingMinor");
+    const total = safeMinor(cart.totalMinor, resource, "$.totalMinor");
+    if (BigInt(total) !== BigInt(estimatedTotal) + BigInt(shipping)) {
+      fail(resource, "$.totalMinor", "estimatedTotalMinor + shippingMinor");
+    }
+  }
   timestamp(cart.expiresAt, resource, "$.expiresAt");
   timestamp(cart.createdAt, resource, "$.createdAt");
   timestamp(cart.updatedAt, resource, "$.updatedAt");
@@ -3048,6 +3251,12 @@ function validatePublicOrderAt(value, resource, path) {
   exact(
     order,
     [
+      ...responseExtensionKeys(
+        order,
+        ["deliveryMethod", "pickup", "source"],
+        resource,
+        path
+      ),
       "id",
       "orderNumber",
       "amounts",
@@ -3069,6 +3278,37 @@ function validatePublicOrderAt(value, resource, path) {
     resource,
     path
   );
+  if ("deliveryMethod" in order) {
+    enumValue(
+      order.source,
+      ["web", "app", "manual", "api", "import", "in_person"],
+      resource,
+      `${path}.source`
+    );
+    if (order.deliveryMethod === "shipping") {
+      if (order.pickup !== null)
+        fail(resource, `${path}.pickup`, "null for shipping");
+    } else {
+      const pickup = record(order.pickup, resource, `${path}.pickup`);
+      exact(
+        pickup,
+        ["status", "readyAt", "pickedUpAt"],
+        [],
+        resource,
+        `${path}.pickup`
+      );
+      enumValue(
+        pickup.status,
+        ["pending", "ready_for_pickup", "picked_up", "canceled"],
+        resource,
+        `${path}.pickup.status`
+      );
+      for (const key of ["readyAt", "pickedUpAt"]) {
+        if (pickup[key] !== null)
+          timestamp(pickup[key], resource, `${path}.pickup.${key}`);
+      }
+    }
+  }
   string(order.id, resource, `${path}.id`);
   string(order.orderNumber, resource, `${path}.orderNumber`);
   const amounts = record(order.amounts, resource, `${path}.amounts`);
@@ -3389,6 +3629,17 @@ function validateCheckoutCore(value, resource, list, server) {
     "$.status"
   );
   const keys = checkoutVariantKeys(status, checkout.placedVia);
+  keys.required.push(
+    ...responseExtensionKeys(
+      checkout,
+      ["deliveryMethod", "source"],
+      resource,
+      "$"
+    )
+  );
+  if ("deliveryMethod" in checkout)
+    enumValue(checkout.source, ["web", "in_person"], resource, "$.source");
+  keys.optional.push("funding");
   if (list) {
     keys.required = keys.required.filter(
       (key) => !["items", "shippingAddress", "attributes"].includes(key)
@@ -3400,6 +3651,33 @@ function validateCheckoutCore(value, resource, list, server) {
   exact(checkout, keys.required, keys.optional, resource, "$");
   string(checkout.id, resource, "$.id");
   validateCheckoutAmounts(checkout.amounts, resource, "$.amounts");
+  if (Object.prototype.hasOwnProperty.call(checkout, "funding")) {
+    const funding = record(checkout.funding, resource, "$.funding");
+    exact(
+      funding,
+      ["creditAmount", "providerPayableAmount"],
+      [],
+      resource,
+      "$.funding"
+    );
+    const credit = safeMinor(
+      funding.creditAmount,
+      resource,
+      "$.funding.creditAmount"
+    );
+    const provider = safeMinor(
+      funding.providerPayableAmount,
+      resource,
+      "$.funding.providerPayableAmount"
+    );
+    const amounts = checkout.amounts;
+    if (BigInt(credit) + BigInt(provider) !== BigInt(amounts.totalMinor) || credit > 0 && amounts.currency !== "KRW")
+      fail(
+        resource,
+        "$.funding",
+        "exact purchase total split; positive credits require KRW"
+      );
+  }
   if (!list) {
     const items = array(checkout.items, resource, "$.items");
     if (items.length === 0) fail(resource, "$.items", "non-empty array");
@@ -3558,10 +3836,10 @@ function validateCheckoutQueryResult(value) {
   return value;
 }
 function validateMoney(value, resource, path) {
-  const money = record(value, resource, path);
-  exact(money, ["amountMinor", "currency"], [], resource, path);
-  safeMinor(money.amountMinor, resource, `${path}.amountMinor`);
-  currency(money.currency, resource, `${path}.currency`);
+  const money2 = record(value, resource, path);
+  exact(money2, ["amountMinor", "currency"], [], resource, path);
+  safeMinor(money2.amountMinor, resource, `${path}.amountMinor`);
+  currency(money2.currency, resource, `${path}.currency`);
 }
 function validateCaptureEvidence(value, resource, path) {
   const evidence = record(value, resource, path);
@@ -3597,6 +3875,65 @@ function validateRequiredReconciliation(value, allowed, resource, path) {
 }
 function validateNextAction(value, provider, resource, path) {
   const action = record(value, resource, path);
+  if (provider === "stripe") {
+    exact(
+      action,
+      ["type", "clientSecret", "publishableKey", "returnUrl"],
+      [],
+      resource,
+      path
+    );
+    if (action.type !== "stripe_payment_element")
+      fail(resource, `${path}.type`, "stripe_payment_element");
+    const clientSecret = boundedString(
+      action.clientSecret,
+      255,
+      resource,
+      `${path}.clientSecret`
+    );
+    if (!/^pi_[A-Za-z0-9]+_secret_[A-Za-z0-9]+$/.test(clientSecret)) {
+      fail(
+        resource,
+        `${path}.clientSecret`,
+        "Stripe PaymentIntent client secret"
+      );
+    }
+    const publishableKey = boundedString(
+      action.publishableKey,
+      255,
+      resource,
+      `${path}.publishableKey`
+    );
+    if (!/^pk_(?:test|live)_[A-Za-z0-9]+$/.test(publishableKey)) {
+      fail(resource, `${path}.publishableKey`, "Stripe publishable key");
+    }
+    const returnUrl = boundedString(
+      action.returnUrl,
+      2048,
+      resource,
+      `${path}.returnUrl`
+    );
+    if (!STRIPE_RETURN_URL_RAW_CHARACTERS.test(returnUrl) || !STRIPE_RETURN_URL_AUTHORITY.test(returnUrl)) {
+      fail(
+        resource,
+        `${path}.returnUrl`,
+        "HTTPS or loopback URL without embedded credentials"
+      );
+    }
+    try {
+      const parsed = new URL(returnUrl);
+      const loopback = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+      if (!loopback && parsed.protocol !== "https:" || parsed.username || parsed.password)
+        throw new Error("unsafe return URL");
+    } catch {
+      fail(
+        resource,
+        `${path}.returnUrl`,
+        "HTTPS or loopback URL without embedded credentials"
+      );
+    }
+    return;
+  }
   if (provider === "portone") {
     if (action.type === "portone_sdk") {
       const hasCancelable = "cancelable" in action;
@@ -3972,7 +4309,7 @@ function validatePublicPaymentSession(value, expectedProvider, operation2) {
     );
   }
   if (expectedProvider !== void 0 && provider !== expectedProvider) {
-    if (operation2 === "cancel" && status !== "canceling" && status !== "canceled") {
+    if (operation2 === "cancel" && CANCEL_RECOVERY_METHODS[provider] !== null && status !== "canceling" && status !== "canceled") {
       fail(
         resource,
         "$.providerStatus",
@@ -4864,8 +5201,9 @@ var CheckoutApi = class extends CustomerScopedApi {
   }
   post(endpoint, body, idempotencyKey) {
     return this.requestEndpoint(endpoint, body, {
-      ...idempotencyKey && {
-        headers: { "X-Idempotency-Key": idempotencyKey }
+      headers: {
+        Accept: CUSTOMER_CREDIT_FUNDING_MEDIA_TYPE,
+        ...idempotencyKey && { "X-Idempotency-Key": idempotencyKey }
       }
     });
   }
@@ -4875,34 +5213,58 @@ var CheckoutApi = class extends CustomerScopedApi {
   async serverCheckout(result) {
     return validateServerCheckout(await result);
   }
-  async createResult(result) {
-    return validateCreateCheckoutResult(
+  async createResult(result, creditAmount) {
+    const parsed = validateCreateCheckoutResult(
       await result,
       false
     );
+    this.assertRequestedCredit(parsed.checkout, creditAmount);
+    return parsed;
   }
-  async createServerResult(result) {
-    return validateCreateCheckoutResult(
+  async createServerResult(result, creditAmount) {
+    const parsed = validateCreateCheckoutResult(
       await result,
       true
     );
+    this.assertRequestedCredit(parsed.checkout, creditAmount);
+    return parsed;
+  }
+  assertCreditInput(amount) {
+    if (amount !== void 0 && (!Number.isSafeInteger(amount) || amount <= 0))
+      throw createValidationError(
+        "creditAmount must be a positive safe integer."
+      );
+  }
+  assertRequestedCredit(checkout, requested) {
+    if (requested !== void 0 && checkout.funding?.creditAmount !== requested)
+      throw createApiError(
+        "Credit funding was not confirmed by the server.",
+        502,
+        { resource: "Checkout", path: "$.funding" },
+        "The response does not confirm the requested credit funding.",
+        "Retry the same create with the original idempotency key and credit amount, or retrieve the Checkout; never retry without credit."
+      );
   }
   create(params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
+    this.assertCreditInput(body.creditAmount);
     return this.createResult(
-      this.post(COMMERCE_ENDPOINTS.checkouts.create, body, idempotencyKey)
+      this.post(COMMERCE_ENDPOINTS.checkouts.create, body, idempotencyKey),
+      body.creditAmount
     );
   }
   createServer(params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
+    this.assertCreditInput(body.creditAmount);
     return this.createServerResult(
       this.post(
         COMMERCE_ENDPOINTS.checkouts.server.create,
         body,
         idempotencyKey
-      )
+      ),
+      body.creditAmount
     );
   }
   retrieve(params) {
@@ -6564,6 +6926,13 @@ var Client = class _Client {
     this.markets = new MarketDiscovery(
       (options2) => this.collections.from("markets").find(options2)
     );
+    this.credits = new CustomerCreditsApi("CustomerCreditsApi", {
+      publishableKey: this.config.publishableKey,
+      apiUrl: this.config.apiUrl,
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId
+    });
     this.benefitVouchers = new CustomerBenefitVouchersApi(
       "CustomerBenefitVouchersApi",
       {
@@ -6594,7 +6963,8 @@ var Client = class _Client {
       ...this.config,
       customer: this.config.customer?.persist === false ? {
         ...this.config.customer,
-        token: this.customer.auth.getToken() ?? void 0
+        token: this.customer.auth.getToken() ?? void 0,
+        refreshToken: this.customer.auth.getRefreshToken() ?? void 0
       } : this.config.customer,
       market
     });