@01.software/sdk 0.49.0 → 0.56.1

package/dist/server.js

@@ -97,6 +97,7 @@ var COMMERCE_ERROR_CODES = [
   "payment_session_not_cancelable",
   "payment_session_conflict",
   "provider_identity_mismatch",
+  "managed_refund_attestation_forbidden",
   "payment_method_unavailable",
   "provider_unavailable",
   "lock_timeout",
@@ -639,11 +640,11 @@ function parseRetryAfter(response) {
     permitsAutomaticRetry: seconds <= MAX_AUTOMATIC_RETRY_AFTER_SECONDS
   };
 }
-function mapResponseToError(status, parsed, details, requestId, retryAfter, errorFamily) {
+function mapResponseToError(status, parsed, details, requestId, retryAfter, canonicalCommerceError) {
   const errorDetails = {
     ...details,
     ...parsed.errors && { errors: parsed.errors },
-    ...errorFamily !== "commerce" && parsed.body && { body: parsed.body }
+    ...!canonicalCommerceError && parsed.body && { body: parsed.body }
   };
   const suggestion = getParsedErrorSuggestion(status, parsed);
   const finalize = (error) => {
@@ -651,7 +652,7 @@ function mapResponseToError(status, parsed, details, requestId, retryAfter, erro
     if (retryAfter !== void 0) {
       Object.assign(withRequestId, { retryAfter });
     }
-    return errorFamily === "commerce" ? enhanceCommerceError(withRequestId, parsed.body, requestId) : enhanceNonCommerceError(withRequestId, parsed.reason);
+    return canonicalCommerceError ? enhanceCommerceError(withRequestId, parsed.body, requestId) : enhanceNonCommerceError(withRequestId, parsed.reason);
   };
   if (status === 400 || status === 422) {
     return finalize(
@@ -757,6 +758,7 @@ async function httpFetch(url, options) {
     retry,
     onUnauthorized,
     errorFamily,
+    typedCommerceErrorReasons,
     ...requestInit
   } = options || {};
   const baseUrl = resolveApiUrl(apiUrl);
@@ -810,7 +812,8 @@ async function httpFetch(url, options) {
       });
       if (!response.ok) {
         const parsed = await parseErrorBody(response);
-        const commerceEnvelope = errorFamily === "commerce" ? parseCommerceErrorEnvelope(parsed.body, requestId) : void 0;
+        const canonicalCommerceError = errorFamily === "commerce" || typeof parsed.reason === "string" && typedCommerceErrorReasons?.includes(parsed.reason) === true;
+        const commerceEnvelope = canonicalCommerceError ? parseCommerceErrorEnvelope(parsed.body, requestId) : void 0;
         if (isUsageLimitExceededResponse(response)) {
           const limit = parseInt(
             response.headers.get("X-Usage-Limit") || "0",
@@ -838,7 +841,7 @@ async function httpFetch(url, options) {
             ),
             requestId
           );
-          throw errorFamily === "commerce" ? enhanceCommerceError(usageError, parsed.body, requestId) : enhanceNonCommerceError(usageError, parsed.reason);
+          throw canonicalCommerceError ? enhanceCommerceError(usageError, parsed.body, requestId) : enhanceNonCommerceError(usageError, parsed.reason);
         }
         if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && (commerceEnvelope?.reason ?? parsed.reason) === "token_expired") {
           hasRetried401 = true;
@@ -863,7 +866,7 @@ async function httpFetch(url, options) {
           details,
           requestId,
           retryAfter.seconds,
-          errorFamily
+          canonicalCommerceError
         );
         const method2 = (requestInit.method || "GET").toUpperCase();
         const isTerminal = error instanceof RateLimitError || error instanceof UsageLimitError;
@@ -1041,15 +1044,15 @@ var HttpClient = class {
       throw err;
     }
   }
-  buildUrl(endpoint2, options) {
-    if (!options) return endpoint2;
+  buildUrl(endpoint, options) {
+    if (!options) return endpoint;
     const { fallbackLocale, ...rest } = options;
     const queryOptions = fallbackLocale === void 0 ? rest : {
       ...rest,
       "fallback-locale": fallbackLocale === false ? "none" : fallbackLocale
     };
     const queryString = stringify(queryOptions, { addQueryPrefix: true });
-    return queryString ? `${endpoint2}${queryString}` : endpoint2;
+    return queryString ? `${endpoint}${queryString}` : endpoint;
   }
   assertJsonResponse(response) {
     const contentType = response.headers.get("content-type");
@@ -1240,16 +1243,16 @@ var CollectionQueryBuilder = class {
    * @returns Payload CMS mutation response with doc and message
    */
   async create(data, options) {
-    const endpoint2 = `/api/${String(this.collection)}`;
+    const endpoint = `/api/${String(this.collection)}`;
     if (options?.file) {
       return this.api.requestCreateWithFile(
-        endpoint2,
+        endpoint,
         data,
         options.file,
         options.filename
       );
     }
-    return this.api.requestCreate(endpoint2, data);
+    return this.api.requestCreate(endpoint, data);
   }
   /**
    * Update a document by ID
@@ -1257,16 +1260,16 @@ var CollectionQueryBuilder = class {
    * @returns Payload CMS mutation response with doc and message
    */
   async update(id, data, options) {
-    const endpoint2 = `/api/${String(this.collection)}/${String(id)}`;
+    const endpoint = `/api/${String(this.collection)}/${String(id)}`;
     if (options?.file) {
       return this.api.requestUpdateWithFile(
-        endpoint2,
+        endpoint,
         data,
         options.file,
         options.filename
       );
     }
-    return this.api.requestUpdate(endpoint2, data);
+    return this.api.requestUpdate(endpoint, data);
   }
   /**
    * Count documents
@@ -1362,8 +1365,8 @@ var CollectionClient = class extends HttpClient {
    * Find documents (list query)
    * GET /api/{collection}
    */
-  async requestFind(endpoint2, options) {
-    const url = this.buildUrl(endpoint2, options);
+  async requestFind(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
@@ -1374,8 +1377,8 @@ var CollectionClient = class extends HttpClient {
    * Find-like response from a custom endpoint
    * POST /api/...custom-endpoint
    */
-  async requestFindEndpoint(endpoint2, data) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestFindEndpoint(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: data ? JSON.stringify(data) : void 0
@@ -1385,8 +1388,8 @@ var CollectionClient = class extends HttpClient {
   /**
    * Find-like response from a cacheable GET custom endpoint.
    */
-  async requestFindEndpointGet(endpoint2) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestFindEndpointGet(endpoint) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "GET"
     });
@@ -1396,8 +1399,8 @@ var CollectionClient = class extends HttpClient {
    * Find document by ID
    * GET /api/{collection}/{id}
    */
-  async requestFindById(endpoint2, options) {
-    const url = this.buildUrl(endpoint2, options);
+  async requestFindById(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
@@ -1408,8 +1411,8 @@ var CollectionClient = class extends HttpClient {
    * Create document
    * POST /api/{collection}
    */
-  async requestCreate(endpoint2, data) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestCreate(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: data ? JSON.stringify(data) : void 0
@@ -1420,8 +1423,8 @@ var CollectionClient = class extends HttpClient {
    * Update document
    * PATCH /api/{collection}/{id}
    */
-  async requestUpdate(endpoint2, data) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestUpdate(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: data ? JSON.stringify(data) : void 0
@@ -1432,8 +1435,8 @@ var CollectionClient = class extends HttpClient {
    * Count documents
    * GET /api/{collection}/count
    */
-  async requestCount(endpoint2, options) {
-    const url = this.buildUrl(endpoint2, options);
+  async requestCount(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
@@ -1444,8 +1447,8 @@ var CollectionClient = class extends HttpClient {
    * Update multiple documents (bulk update)
    * PATCH /api/{collection}
    */
-  async requestUpdateMany(endpoint2, data) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestUpdateMany(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: JSON.stringify(data)
@@ -1456,8 +1459,8 @@ var CollectionClient = class extends HttpClient {
    * Delete document
    * DELETE /api/{collection}/{id}
    */
-  async requestDelete(endpoint2, options) {
-    const url = this.buildUrl(endpoint2, options);
+  async requestDelete(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "DELETE"
@@ -1468,8 +1471,8 @@ var CollectionClient = class extends HttpClient {
    * Delete multiple documents (bulk delete)
    * DELETE /api/{collection}
    */
-  async requestDeleteMany(endpoint2, data) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestDeleteMany(endpoint, data) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "DELETE",
       body: JSON.stringify(data)
@@ -1480,8 +1483,8 @@ var CollectionClient = class extends HttpClient {
    * Create document with file upload
    * POST /api/{collection} (multipart/form-data)
    */
-  async requestCreateWithFile(endpoint2, data, file, filename) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestCreateWithFile(endpoint, data, file, filename) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: buildPayloadFormData(data, file, filename)
@@ -1492,8 +1495,8 @@ var CollectionClient = class extends HttpClient {
    * Update document with file upload
    * PATCH /api/{collection}/{id} (multipart/form-data)
    */
-  async requestUpdateWithFile(endpoint2, data, file, filename) {
-    const response = await this.fetchWithTracking(endpoint2, {
+  async requestUpdateWithFile(endpoint, data, file, filename) {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: buildPayloadFormData(data, file, filename)
@@ -1508,7 +1511,7 @@ var ServerCollectionClient = class extends CollectionClient {
 };
 
 // src/core/api/parse-response.ts
-async function parseApiResponse(response, endpoint2, options = {}) {
+async function parseApiResponse(response, endpoint, options = {}) {
   if (response.status === 204 || response.headers.get("content-length") === "0") {
     return void 0;
   }
@@ -1517,7 +1520,7 @@ async function parseApiResponse(response, endpoint2, options = {}) {
     parsed = await response.json();
   } catch {
     throw createApiError(
-      `Invalid JSON response from ${endpoint2}`,
+      `Invalid JSON response from ${endpoint}`,
       response.status,
       void 0,
       "Server returned an invalid response.",
@@ -1567,6 +1570,7 @@ async function parseApiResponse(response, endpoint2, 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 operation = (collection, method, path, errorFamily) => Object.freeze({
   [operationBrand]: true,
   collection,
@@ -1575,6 +1579,10 @@ var operation = (collection, method, path, errorFamily) => Object.freeze({
   ...errorFamily && { errorFamily }
 });
 var strictCommerceOperation = (collection, method, path) => operation(collection, method, path, "commerce");
+var selectiveCommerceOperation = (collection, method, path, typedCommerceErrorReasons) => Object.freeze({
+  ...operation(collection, method, path),
+  typedCommerceErrorReasons: Object.freeze([...typedCommerceErrorReasons])
+});
 var COMMERCE_ENDPOINT_OPERATIONS = {
   products: {
     detail: operation("products", "get", "/detail"),
@@ -1606,7 +1614,12 @@ var COMMERCE_ENDPOINT_OPERATIONS = {
     confirmPayment: operation("orders", "post", "/confirm-payment"),
     byPayment: operation("orders", "get", "/by-payment"),
     cancel: operation("orders", "post", "/cancel"),
-    resolveCancelRefund: operation("orders", "post", "/resolve-cancel-refund"),
+    resolveCancelRefund: selectiveCommerceOperation(
+      "orders",
+      "post",
+      "/resolve-cancel-refund",
+      ["managed_refund_attestation_forbidden"]
+    ),
     checkout: strictCommerceOperation("orders", "post", "/checkout"),
     createFulfillment: operation("orders", "post", "/create-fulfillment"),
     updateFulfillment: operation("orders", "post", "/update-fulfillment")
@@ -1615,6 +1628,11 @@ var COMMERCE_ENDPOINT_OPERATIONS = {
     detail: strictCommerceOperation("checkouts", "post", "/detail"),
     query: strictCommerceOperation("checkouts", "post", "/query")
   },
+  draftOrders: {
+    calculate: operation("draft-orders", "post", "/:id/calculate"),
+    complete: operation("draft-orders", "post", "/:id/complete"),
+    finalize: operation("draft-orders", "post", "/:id/finalize")
+  },
   transactions: {
     update: operation("transactions", "post", "/update")
   },
@@ -1677,6 +1695,16 @@ var COMMERCE_ENDPOINT_OPERATIONS = {
         "payment-sessions",
         "post",
         "/server/confirm"
+      ),
+      findPortOne: strictCommerceOperation(
+        "payment-sessions",
+        "post",
+        "/server/portone/find"
+      ),
+      reconcilePortOne: strictCommerceOperation(
+        "payment-sessions",
+        "post",
+        "/server/portone/reconcile"
       )
     },
     custom: {
@@ -1696,12 +1724,34 @@ var COMMERCE_ENDPOINT_OPERATIONS = {
     validate: operation("discounts", "post", "/validate")
   }
 };
+var portOneStandardActionCapabilityOperations = /* @__PURE__ */ new Set([
+  COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.create,
+  COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.retrieve,
+  COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.server.create,
+  COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.server.retrieve
+]);
 var MEMBERSHIP_ENDPOINT_OPERATIONS = {
   subscribe: operation(null, "post", "/memberships/subscribe"),
   cancel: operation(null, "post", "/memberships/:id/cancel"),
-  me: operation(null, "get", "/memberships/me")
+  me: operation(null, "get", "/memberships/me"),
+  chargeResult: operation(null, "post", "/memberships/:id/charge-result"),
+  refundResult: operation(null, "post", "/memberships/:id/refund-result"),
+  revoke: operation(null, "post", "/memberships/:id/revoke")
+};
+var CUSTOMER_GROUP_ENDPOINT_OPERATIONS = {
+  members: operation("customer-groups", "get", "/:id/members"),
+  grant: operation("customer-groups", "post", "/:id/members/grant"),
+  revoke: operation("customer-groups", "post", "/:id/members/revoke")
+};
+var EMBEDDED_ADMIN_ENDPOINT_OPERATIONS = {
+  show: operation("tenants", "get", "/embedded-admin-app"),
+  configure: operation("tenants", "patch", "/embedded-admin-app"),
+  disable: operation("tenants", "delete", "/embedded-admin-app")
 };
 var EVENTS_ENDPOINT_OPERATIONS = {
+  events: {
+    convertSchedule: operation("events", "post", "/:id/schedule")
+  },
   occurrences: {
     range: operation("event-occurrences", "get", "/range"),
     admissionAvailability: operation(
@@ -1742,46 +1792,54 @@ function resolveOperationMethod(descriptor) {
 }
 
 // src/core/api/endpoints.ts
-var endpoint = (method, path) => ({ method, path });
 var sharedEndpoint = (descriptor) => descriptor;
-function resolveOperationMethod2(descriptor) {
-  return "collection" in descriptor ? resolveOperationMethod(descriptor) : descriptor.method;
-}
 function resolveOperationErrorFamily(descriptor) {
-  return "collection" in descriptor ? descriptor.errorFamily : void 0;
+  return descriptor.errorFamily;
 }
-function resolveOperationPath2(descriptor, options) {
-  if ("collection" in descriptor) {
-    return resolveOperationPath(descriptor, options);
-  }
-  const query = options?.query?.toString().replace(/^\?/, "");
-  return query ? `${descriptor.path}?${query}` : descriptor.path;
+function resolveOperationTypedCommerceErrorReasons(descriptor) {
+  return descriptor.typedCommerceErrorReasons;
 }
 var COMMERCE_ENDPOINTS = {
   products: {
-    detail: endpoint("GET", "/api/products/detail"),
-    detailCatalog: endpoint("GET", "/api/products/detail/catalog"),
-    listingGroups: endpoint("GET", "/api/products/listing-groups"),
-    listingGroupsCatalog: endpoint(
-      "GET",
-      "/api/products/listing-groups/catalog"
+    detail: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.products.detail),
+    detailCatalog: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.detailCatalog
+    ),
+    listingGroups: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.listingGroups
+    ),
+    listingGroupsCatalog: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsCatalog
+    ),
+    // The manifest keeps the GET read and the POST body-query apart; this
+    // semantic name has always resolved to the GET one.
+    listingGroupsQuery: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQueryGet
+    ),
+    listingGroupsQueryCatalog: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQueryCatalog
+    ),
+    stockCheck: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.stockCheck
     ),
-    listingGroupsQuery: endpoint("GET", "/api/products/listing-groups/query"),
-    listingGroupsQueryCatalog: endpoint(
-      "GET",
-      "/api/products/listing-groups/query/catalog"
+    stockSnapshot: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.products.stockSnapshot
     ),
-    stockCheck: endpoint("POST", "/api/products/stock-check"),
-    stockSnapshot: endpoint("GET", "/api/products/stock"),
-    upsert: endpoint("POST", "/api/products/upsert")
+    upsert: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.products.upsert)
   },
   orders: {
-    update: endpoint("POST", "/api/orders/update"),
-    byPayment: endpoint("GET", "/api/orders/by-payment"),
-    cancel: endpoint("POST", "/api/orders/cancel"),
-    resolveCancelRefund: endpoint("POST", "/api/orders/resolve-cancel-refund"),
-    createFulfillment: endpoint("POST", "/api/orders/create-fulfillment"),
-    updateFulfillment: endpoint("POST", "/api/orders/update-fulfillment")
+    update: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.orders.update),
+    byPayment: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.orders.byPayment),
+    cancel: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.orders.cancel),
+    resolveCancelRefund: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.orders.resolveCancelRefund
+    ),
+    createFulfillment: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.orders.createFulfillment
+    ),
+    updateFulfillment: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.orders.updateFulfillment
+    )
   },
   checkouts: {
     create: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.orders.checkout),
@@ -1793,18 +1851,21 @@ var COMMERCE_ENDPOINTS = {
     }
   },
   returns: {
-    create: endpoint("POST", "/api/returns/create"),
-    update: endpoint("POST", "/api/returns/update"),
-    returnRefund: endpoint("POST", "/api/returns/return-refund")
+    create: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.returns.create),
+    update: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.returns.update),
+    returnRefund: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.returns.returnRefund
+    )
   },
   fulfillmentOrders: {
-    prepare: endpoint(
-      "POST",
-      "/api/fulfillment-orders/prepare-fulfillment-order"
+    prepare: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.fulfillmentOrders.prepare
     )
   },
   fulfillments: {
-    bulkImport: endpoint("POST", "/api/fulfillments/bulk-import")
+    bulkImport: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.fulfillments.bulkImport
+    )
   },
   carts: {
     create: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.create),
@@ -1869,42 +1930,21 @@ var COMMERCE_ENDPOINTS = {
       ),
       confirm: sharedEndpoint(
         COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.server.confirm
+      ),
+      findPortOne: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.server.findPortOne
+      ),
+      reconcilePortOne: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.server.reconcilePortOne
       )
     }
   },
   shippingPolicies: {
-    calculate: endpoint("POST", "/api/shipping-policies/calculate")
+    calculate: sharedEndpoint(
+      COMMERCE_ENDPOINT_OPERATIONS.shippingPolicies.calculate
+    )
   }
 };
-function isCommerceEndpointDescriptor(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return typeof candidate.method === "string" && typeof candidate.path === "string";
-}
-function flattenEndpointPaths(value) {
-  if (isCommerceEndpointDescriptor(value)) return [resolveOperationPath2(value)];
-  if (!value || typeof value !== "object") return [];
-  return Object.values(value).flatMap((entry) => flattenEndpointPaths(entry));
-}
-function flattenEndpointDescriptors(value) {
-  if (isCommerceEndpointDescriptor(value)) return [value];
-  if (!value || typeof value !== "object") return [];
-  return Object.values(value).flatMap(
-    (entry) => flattenEndpointDescriptors(entry)
-  );
-}
-var COMMERCE_ENDPOINT_PATHS = flattenEndpointPaths(COMMERCE_ENDPOINTS);
-var COMMERCE_ENDPOINT_DESCRIPTORS = flattenEndpointDescriptors(COMMERCE_ENDPOINTS);
-var MEMBERSHIP_ENDPOINTS = {
-  subscribe: "/api/memberships/subscribe",
-  cancel: (id) => `/api/memberships/${id}/cancel`,
-  me: "/api/memberships/me"
-};
-var MEMBERSHIP_ENDPOINT_PATHS = [
-  MEMBERSHIP_ENDPOINTS.subscribe,
-  MEMBERSHIP_ENDPOINTS.cancel(":id"),
-  MEMBERSHIP_ENDPOINTS.me
-];
 
 // src/core/api/customer-scoped-api.ts
 var CustomerScopedTransport = class {
@@ -1925,10 +1965,10 @@ var CustomerScopedTransport = class {
     this.onUnauthorized = options.onUnauthorized;
     this.onRequestId = options.onRequestId;
   }
-  async request(endpoint2, options) {
+  async request(endpoint, options) {
     const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
     try {
-      const response = await httpFetch(endpoint2, {
+      const response = await httpFetch(endpoint, {
         method: options.method,
         apiUrl: this.apiUrl,
         publishableKey: this.publishableKey,
@@ -1942,7 +1982,7 @@ var CustomerScopedTransport = class {
         ...options.errorFamily && { errorFamily: options.errorFamily }
       });
       this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint2, {
+      return parseApiResponse(response, endpoint, {
         errorFamily: options.errorFamily
       });
     } catch (err) {
@@ -1956,12 +1996,12 @@ var CustomerScopedApi = class {
   constructor(apiName, options) {
     this.transport = new CustomerScopedTransport(apiName, options);
   }
-  requestEndpoint(endpoint2, body, options) {
-    return this.transport.request(resolveOperationPath2(endpoint2, options), {
-      method: resolveOperationMethod2(endpoint2),
+  requestEndpoint(endpoint, body, options) {
+    return this.transport.request(resolveOperationPath(endpoint, options), {
+      method: resolveOperationMethod(endpoint),
       body,
       headers: options?.headers,
-      errorFamily: resolveOperationErrorFamily(endpoint2)
+      errorFamily: resolveOperationErrorFamily(endpoint)
     });
   }
 };
@@ -1969,8 +2009,8 @@ var RawCustomerScopedApi = class {
   constructor(apiName, options) {
     this.transport = new CustomerScopedTransport(apiName, options);
   }
-  request(endpoint2, options) {
-    return this.transport.request(endpoint2, options);
+  request(endpoint, options) {
+    return this.transport.request(endpoint, options);
   }
 };
 
@@ -2045,11 +2085,11 @@ var CommunityClient = class extends RawCustomerScopedApi {
     if (params.page !== void 0) urlParams.set("page", String(params.page));
     return `/api/comments/public?${urlParams.toString()}`;
   }
-  async execute(endpoint2, method, body) {
-    return this.request(endpoint2, { method, body });
+  async execute(endpoint, method, body) {
+    return this.request(endpoint, { method, body });
   }
-  async executeDoc(endpoint2, method, body) {
-    const response = await this.execute(endpoint2, method, body);
+  async executeDoc(endpoint, method, body) {
+    const response = await this.execute(endpoint, method, body);
     return unwrapPayloadDoc(response);
   }
   createPost(params) {
@@ -2328,20 +2368,23 @@ var ServerApiTransport = class {
     this.apiUrl = options.apiUrl;
     this.onRequestId = options.onRequestId;
   }
-  async request(endpoint2, body, options) {
+  async request(endpoint, body, options) {
     const method = options?.method ?? "POST";
     try {
-      const response = await httpFetch(endpoint2, {
+      const response = await httpFetch(endpoint, {
         method,
         apiUrl: this.apiUrl,
         publishableKey: this.publishableKey,
         secretKey: this.secretKey,
         ...body !== void 0 && { body: JSON.stringify(body) },
         ...options?.headers && { headers: options.headers },
-        ...options?.errorFamily && { errorFamily: options.errorFamily }
+        ...options?.errorFamily && { errorFamily: options.errorFamily },
+        ...options?.typedCommerceErrorReasons && {
+          typedCommerceErrorReasons: options.typedCommerceErrorReasons
+        }
       });
       this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint2, {
+      return parseApiResponse(response, endpoint, {
         errorFamily: options?.errorFamily
       });
     } catch (err) {
@@ -2355,14 +2398,15 @@ var BaseApi = class {
   constructor(apiName, options) {
     this.transport = new ServerApiTransport(apiName, options);
   }
-  requestEndpoint(endpoint2, body, options) {
+  requestEndpoint(endpoint, body, options) {
     return this.transport.request(
-      resolveOperationPath2(endpoint2, options),
+      resolveOperationPath(endpoint, options),
       body,
       {
-        method: resolveOperationMethod2(endpoint2),
+        method: resolveOperationMethod(endpoint),
         headers: options?.headers,
-        errorFamily: resolveOperationErrorFamily(endpoint2)
+        errorFamily: resolveOperationErrorFamily(endpoint),
+        typedCommerceErrorReasons: resolveOperationTypedCommerceErrorReasons(endpoint)
       }
     );
   }
@@ -2379,8 +2423,8 @@ var RawBaseApi = class {
     this.apiUrl = options.apiUrl;
     this.onRequestId = options.onRequestId;
   }
-  request(endpoint2, body, options) {
-    return this.transport.request(endpoint2, body, options);
+  request(endpoint, body, options) {
+    return this.transport.request(endpoint, body, options);
   }
 };
 
@@ -2419,7 +2463,10 @@ var MAX_COMMERCE_CAPABILITY_LENGTH = 512;
 var MAX_CART_DISCOUNT_CODE_LENGTH = 128;
 var CHECKOUT_STATUSES = ["open", "placed", "abandoned"];
 var ABANDONED_REASONS = ["expired", "customer", "operator"];
-var PAYMENT_PROVIDERS = ["toss", "portone"];
+function managedPaymentProviders(providers) {
+  return providers;
+}
+var PAYMENT_PROVIDERS = managedPaymentProviders(["toss", "portone"]);
 var PAYMENT_PROVIDER_STATUSES = [
   "requires_payment_method",
   "requires_action",
@@ -2441,6 +2488,18 @@ var PAYMENT_FAILURE_REASONS = [
   "provider_terminal_failure",
   "unknown_provider_terminal_failure"
 ];
+var PAYMENT_RECONCILIATION_REASONS = [
+  "provider_outcome_unknown",
+  "local_commit_ambiguous",
+  "amount_mismatch",
+  "currency_mismatch",
+  "excess_capture_pending_order",
+  "inventory_unavailable",
+  "admission_unavailable",
+  "excess_capture",
+  "late_capture",
+  "cross_checkout_duplicate"
+];
 var CART_WARNING_CODES = [
   "DISCOUNT_CODE_NOT_HONOURED",
   "DISCOUNT_CURRENTLY_INACTIVE",
@@ -2467,6 +2526,26 @@ function invalidCanonicalResponse(resource, details) {
 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];
+    throw createApiError(
+      `Canonical ${resource} response provider mismatch: expected ${expected}, received ${actual}.`,
+      502,
+      { resource, path: "$.provider", expected, actual },
+      `The server applied the cancellation to a ${actual} PaymentSession, but this SDK method expects ${expected}.`,
+      `Re-invoke ${method} with the same idempotencyKey; do not create a new key.`
+    );
+  }
+  invalidCanonicalResponse(resource, {
+    path: "$.provider",
+    expected,
+    actual
+  });
+}
 function record(value, resource, path) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     fail(resource, path, "object");
@@ -2502,6 +2581,9 @@ function nullableString(value, resource, path) {
     fail(resource, path, "string or null");
   }
 }
+function nullableNonEmptyString(value, resource, path) {
+  if (value !== null) string(value, resource, path);
+}
 function nonBlankString(value, resource, path) {
   const parsed = string(value, resource, path);
   if (parsed.trim().length === 0) {
@@ -3022,8 +3104,8 @@ function validateCheckoutItem(value, resource, path) {
   validateReference(item.product, resource, `${path}.product`);
   validateReference(item.variant, resource, `${path}.variant`);
   string(item.productTitle, resource, `${path}.productTitle`);
-  nullableString(item.variantTitle, resource, `${path}.variantTitle`);
-  nullableString(item.sku, resource, `${path}.sku`);
+  nullableNonEmptyString(item.variantTitle, resource, `${path}.variantTitle`);
+  nullableNonEmptyString(item.sku, resource, `${path}.sku`);
   validateAdmissions(item.admissions, resource, `${path}.admissions`);
   cartLineQuantity(item.quantity, resource, `${path}.quantity`);
   const unitPrice = safeMinor(
@@ -3391,6 +3473,141 @@ function validateRetrievedCustomPaymentSession(value) {
   nullableResourceId(session.orderId, resource, "$.orderId");
   return value;
 }
+function validatePortOnePaymentCurrentState(value, resource, path) {
+  const current = record(value, resource, path);
+  exact(
+    current,
+    ["paymentSession", "checkout", "order", "money"],
+    [],
+    resource,
+    path
+  );
+  const session = record(
+    current.paymentSession,
+    resource,
+    `${path}.paymentSession`
+  );
+  exact(
+    session,
+    [
+      "id",
+      "provider",
+      "providerStatus",
+      "finalizationStatus",
+      "sessionRole",
+      "reconciliation"
+    ],
+    [],
+    resource,
+    `${path}.paymentSession`
+  );
+  boundedString(
+    session.id,
+    MAX_COMMERCE_RESOURCE_ID_LENGTH,
+    resource,
+    `${path}.paymentSession.id`
+  );
+  if (session.provider !== "portone") {
+    fail(resource, `${path}.paymentSession.provider`, "portone");
+  }
+  enumValue(
+    session.providerStatus,
+    PAYMENT_PROVIDER_STATUSES,
+    resource,
+    `${path}.paymentSession.providerStatus`
+  );
+  enumValue(
+    session.finalizationStatus,
+    ["not_ready", "pending", "committed"],
+    resource,
+    `${path}.paymentSession.finalizationStatus`
+  );
+  enumValue(
+    session.sessionRole,
+    ["active", "canonical_candidate", "canonical", "residual", "historical"],
+    resource,
+    `${path}.paymentSession.sessionRole`
+  );
+  const reconciliation = record(
+    session.reconciliation,
+    resource,
+    `${path}.paymentSession.reconciliation`
+  );
+  if (reconciliation.status === "none") {
+    validateNoReconciliation(
+      reconciliation,
+      resource,
+      `${path}.paymentSession.reconciliation`
+    );
+  } else {
+    validateRequiredReconciliation(
+      reconciliation,
+      PAYMENT_RECONCILIATION_REASONS,
+      resource,
+      `${path}.paymentSession.reconciliation`
+    );
+  }
+  const checkout = record(current.checkout, resource, `${path}.checkout`);
+  exact(checkout, ["id"], [], resource, `${path}.checkout`);
+  boundedString(
+    checkout.id,
+    MAX_COMMERCE_RESOURCE_ID_LENGTH,
+    resource,
+    `${path}.checkout.id`
+  );
+  if (current.order !== null) {
+    const order = record(current.order, resource, `${path}.order`);
+    exact(order, ["id", "orderNumber"], [], resource, `${path}.order`);
+    boundedString(
+      order.id,
+      MAX_COMMERCE_RESOURCE_ID_LENGTH,
+      resource,
+      `${path}.order.id`
+    );
+    nonBlankString(order.orderNumber, resource, `${path}.order.orderNumber`);
+  }
+  validateMoney(current.money, resource, `${path}.money`);
+}
+function validatePortOnePaymentFacadeResult(value, mutating) {
+  const resource = mutating ? "PortOne payment reconciliation result" : "PortOne payment find result";
+  const result = record(value, resource, "$");
+  boolean(result.found, resource, "$.found");
+  if (result.found === false) {
+    exact(
+      result,
+      mutating ? ["found", "disposition"] : ["found"],
+      [],
+      resource,
+      "$"
+    );
+    if (mutating && result.disposition !== "requires_attention") {
+      fail(resource, "$.disposition", "requires_attention");
+    }
+    return value;
+  }
+  exact(
+    result,
+    mutating ? ["found", "disposition", "current"] : ["found", "current"],
+    [],
+    resource,
+    "$"
+  );
+  if (mutating) {
+    enumValue(
+      result.disposition,
+      [
+        "applied",
+        "observed",
+        "recovered_after_ambiguous_result",
+        "requires_attention"
+      ],
+      resource,
+      "$.disposition"
+    );
+  }
+  validatePortOnePaymentCurrentState(result.current, resource, "$.current");
+  return value;
+}
 function validateConfirmCustomPaymentSessionResponse(value) {
   const resource = "custom PaymentSession confirmation";
   const result = record(value, resource, "$");
@@ -3445,11 +3662,21 @@ function validateNextAction(value, provider, resource, path) {
   const action = record(value, resource, path);
   if (provider === "portone") {
     if (action.type === "portone_sdk") {
+      const hasCancelable = "cancelable" in action;
+      const hasRetryPolicy = "retryPolicy" in action;
+      if (hasCancelable !== hasRetryPolicy) {
+        fail(
+          resource,
+          path,
+          "exact released action or exact negotiated capability action"
+        );
+      }
       exact(
         action,
         [
           "type",
           "version",
+          ...hasCancelable ? ["cancelable", "retryPolicy"] : [],
           "storeId",
           "channelKey",
           "paymentId",
@@ -3464,6 +3691,11 @@ function validateNextAction(value, provider, resource, path) {
         path
       );
       if (action.version !== "v2") fail(resource, `${path}.version`, "v2");
+      if (hasCancelable && action.cancelable !== false)
+        fail(resource, `${path}.cancelable`, "false");
+      if (hasRetryPolicy && action.retryPolicy !== "same_action_only") {
+        fail(resource, `${path}.retryPolicy`, "same_action_only");
+      }
       for (const key of ["storeId", "channelKey"]) {
         boundedString(action[key], 255, resource, `${path}.${key}`);
       }
@@ -3510,6 +3742,10 @@ function validateNextAction(value, provider, resource, path) {
           "HTTPS or loopback URL without embedded credentials"
         );
       }
+      if (!hasCancelable) {
+        action.cancelable = false;
+        action.retryPolicy = "same_action_only";
+      }
       return;
     }
     exact(action, ["type", "checkoutUrl"], [], resource, path);
@@ -3586,7 +3822,7 @@ function validateNextAction(value, provider, resource, path) {
   if (action.customerEmail !== void 0)
     validateCustomer({ email: action.customerEmail }, resource, path);
 }
-function validatePublicPaymentSession(value, expectedProvider) {
+function validatePublicPaymentSession(value, expectedProvider, operation2) {
   const resource = "PaymentSession";
   const session = record(value, resource, "$");
   const provider = enumValue(
@@ -3595,9 +3831,6 @@ function validatePublicPaymentSession(value, expectedProvider) {
     resource,
     "$.provider"
   );
-  if (expectedProvider !== void 0 && provider !== expectedProvider) {
-    fail(resource, "$.provider", expectedProvider);
-  }
   const status = enumValue(
     session.providerStatus,
     PAYMENT_PROVIDER_STATUSES,
@@ -3801,6 +4034,16 @@ function validatePublicPaymentSession(value, expectedProvider) {
       "$.cancellationReason"
     );
   }
+  if (expectedProvider !== void 0 && provider !== expectedProvider) {
+    if (operation2 === "cancel" && status !== "canceling" && status !== "canceled") {
+      fail(
+        resource,
+        "$.providerStatus",
+        "canceling or canceled after a successful cancellation"
+      );
+    }
+    providerMismatch(resource, expectedProvider, provider, operation2);
+  }
   return value;
 }
 
@@ -3827,8 +4070,8 @@ var CartApi = class extends CustomerScopedApi {
   endpoint(key) {
     return this.serverTransport ? COMMERCE_ENDPOINTS.carts.server[key] : COMMERCE_ENDPOINTS.carts[key];
   }
-  execute(endpoint2, body, idempotencyKey) {
-    return this.requestEndpoint(endpoint2, body, {
+  execute(endpoint, body, idempotencyKey) {
+    return this.requestEndpoint(endpoint, body, {
       ...idempotencyKey && {
         headers: { "X-Idempotency-Key": idempotencyKey }
       }
@@ -3845,26 +4088,26 @@ var CartApi = class extends CustomerScopedApi {
     );
   }
   mine(params = {}) {
-    const endpoint2 = this.endpoint("mine");
-    return this.execute(endpoint2, params).then(
+    const endpoint = this.endpoint("mine");
+    return this.execute(endpoint, params).then(
       (value) => validateCartMineResult(value)
     );
   }
   merge(params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
-    const endpoint2 = this.endpoint("merge");
-    return this.execute(endpoint2, body, idempotencyKey).then(
+    const endpoint = this.endpoint("merge");
+    return this.execute(endpoint, body, idempotencyKey).then(
       (value) => validateCartMergeResult(value)
     );
   }
   addItem(params) {
     return this.mutate(this.endpoint("addItem"), params);
   }
-  mutate(endpoint2, params) {
+  mutate(endpoint, params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
-    return this.execute(endpoint2, body, idempotencyKey).then(
+    return this.execute(endpoint, body, idempotencyKey).then(
       (value) => validateCartMutationResult(value)
     );
   }
@@ -5273,8 +5516,8 @@ var CheckoutApi = class extends CustomerScopedApi {
   constructor(options) {
     super("CheckoutApi", { ...options, requiresCredential: false });
   }
-  post(endpoint2, body, idempotencyKey) {
-    return this.requestEndpoint(endpoint2, body, {
+  post(endpoint, body, idempotencyKey) {
+    return this.requestEndpoint(endpoint, body, {
       ...idempotencyKey && {
         headers: { "X-Idempotency-Key": idempotencyKey }
       }
@@ -5341,15 +5584,23 @@ var PaymentSessionApi = class extends CustomerScopedApi {
     super("PaymentSessionApi", { ...options, requiresCredential: false });
     this.serverTransport = Boolean(options.secretKey);
   }
-  post(endpoint2, body, idempotencyKey) {
-    return this.requestEndpoint(endpoint2, body, {
-      ...idempotencyKey && {
-        headers: { "X-Idempotency-Key": idempotencyKey }
+  post(endpoint, body, idempotencyKey, negotiateStandardActionCapabilities = false) {
+    const headers = {
+      ...idempotencyKey && { "X-Idempotency-Key": idempotencyKey },
+      ...negotiateStandardActionCapabilities && {
+        Accept: PORTONE_STANDARD_ACTION_CAPABILITIES_MEDIA_TYPE
       }
+    };
+    return this.requestEndpoint(endpoint, body, {
+      ...Object.keys(headers).length > 0 && { headers }
     });
   }
-  async paymentSession(result, expectedProvider) {
-    return validatePublicPaymentSession(await result, expectedProvider);
+  async paymentSession(result, expectedProvider, operation2) {
+    return validatePublicPaymentSession(
+      await result,
+      expectedProvider,
+      operation2
+    );
   }
   create(params) {
     const { idempotencyKey, ...body } = params;
@@ -5370,41 +5621,44 @@ var PaymentSessionApi = class extends CustomerScopedApi {
       this.post(
         this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.create : COMMERCE_ENDPOINTS.paymentSessions.create,
         body,
-        idempotencyKey
+        idempotencyKey,
+        body.providerOptions.profile === "standard_v2"
       ),
       "portone"
     );
   }
   retrieve(params) {
-    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.retrieve : COMMERCE_ENDPOINTS.paymentSessions.retrieve;
+    const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.retrieve : COMMERCE_ENDPOINTS.paymentSessions.retrieve;
     return this.paymentSession(
-      this.post(endpoint2, params),
+      this.post(endpoint, params),
       "toss"
     );
   }
   retrievePortOne(params) {
-    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.retrieve : COMMERCE_ENDPOINTS.paymentSessions.retrieve;
+    const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.retrieve : COMMERCE_ENDPOINTS.paymentSessions.retrieve;
     return this.paymentSession(
-      this.post(endpoint2, params),
+      this.post(endpoint, params, void 0, true),
       "portone"
     );
   }
   cancel(params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
-    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
+    const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
     return this.paymentSession(
-      this.post(endpoint2, body, idempotencyKey),
-      "toss"
+      this.post(endpoint, body, idempotencyKey),
+      "toss",
+      "cancel"
     );
   }
   cancelPortOne(params) {
     const { idempotencyKey, ...body } = params;
     assertCommerceIdempotencyKey(idempotencyKey);
-    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
+    const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
     return this.paymentSession(
-      this.post(endpoint2, body, idempotencyKey),
-      "portone"
+      this.post(endpoint, body, idempotencyKey),
+      "portone",
+      "cancel"
     );
   }
   confirm(params) {
@@ -5420,6 +5674,34 @@ var PaymentSessionApi = class extends CustomerScopedApi {
     );
   }
 };
+var PortOnePaymentReconciliationApi = class extends BaseApi {
+  constructor(options) {
+    super("PortOnePaymentReconciliationApi", options);
+  }
+  async find(params) {
+    const result = await this.requestEndpoint(
+      COMMERCE_ENDPOINTS.paymentSessions.server.findPortOne,
+      params
+    );
+    return validatePortOnePaymentFacadeResult(
+      result,
+      false
+    );
+  }
+  async reconcile(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    const result = await this.requestEndpoint(
+      COMMERCE_ENDPOINTS.paymentSessions.server.reconcilePortOne,
+      body,
+      { headers: { "X-Idempotency-Key": idempotencyKey } }
+    );
+    return validatePortOnePaymentFacadeResult(
+      result,
+      true
+    );
+  }
+};
 var CustomPaymentSessionApi = class extends BaseApi {
   constructor(options) {
     super("CustomPaymentSessionApi", options);
@@ -5549,6 +5831,9 @@ var ServerCommerceClient = class {
     const orderApi = new OrderApi(serverOptions);
     const checkoutApi = new CheckoutApi(serverOptions);
     const paymentSessionApi = new PaymentSessionApi(serverOptions);
+    const portOneReconciliationApi = new PortOnePaymentReconciliationApi(
+      serverOptions
+    );
     const customPaymentSessionApi = new CustomPaymentSessionApi(serverOptions);
     this.product = {
       stockCheck: productApi.stockCheck.bind(productApi),
@@ -5599,6 +5884,10 @@ var ServerCommerceClient = class {
       cancel: (params) => paymentSessionApi.cancel(params),
       cancelPortOne: (params) => paymentSessionApi.cancelPortOne(params),
       confirm: paymentSessionApi.confirm.bind(paymentSessionApi),
+      findPortOne: portOneReconciliationApi.find.bind(portOneReconciliationApi),
+      reconcilePortOne: portOneReconciliationApi.reconcile.bind(
+        portOneReconciliationApi
+      ),
       custom: {
         create: customPaymentSessionApi.create.bind(customPaymentSessionApi),
         retrieve: customPaymentSessionApi.retrieve.bind(
@@ -5680,11 +5969,11 @@ var EventsClient = class {
       { useCustomerAuth: false }
     );
   }
-  async execute(endpoint2, method, body, options = {}) {
+  async execute(endpoint, method, body, options = {}) {
     const useCustomerAuth = options.useCustomerAuth === true;
     const token = useCustomerAuth ? typeof this.customerToken === "function" ? this.customerToken() : this.customerToken : void 0;
     try {
-      const response = await httpFetch(endpoint2, {
+      const response = await httpFetch(endpoint, {
         method,
         apiUrl: this.apiUrl,
         publishableKey: this.publishableKey,
@@ -5693,7 +5982,7 @@ var EventsClient = class {
         ...body !== void 0 && { body: JSON.stringify(body) }
       });
       this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint2);
+      return parseApiResponse(response, endpoint);
     } catch (err) {
       const id = err instanceof SDKError ? err.requestId ?? null : null;
       this.onRequestId?.(id);
@@ -5795,13 +6084,14 @@ var MarketDiscovery = class {
 };
 
 // src/core/api/tenant-introspection-api.ts
+var TENANT_CONTEXT_PATH = "/api/tenants/context";
 var TenantIntrospectionApi = class extends RawBaseApi {
   constructor(options) {
     super("TenantIntrospectionApi", options);
   }
   context(params = {}) {
-    const endpoint2 = params.includeCounts ? "/api/tenants/context?counts=true" : "/api/tenants/context";
-    return this.request(endpoint2, void 0, {
+    const endpoint = params.includeCounts ? `${TENANT_CONTEXT_PATH}?counts=true` : TENANT_CONTEXT_PATH;
+    return this.request(endpoint, void 0, {
       method: "GET"
     });
   }
@@ -5829,9 +6119,10 @@ var MembershipApi = class extends BaseApi {
     super("MembershipApi", options);
   }
   /**
-   * Record a delegated first-charge and activate a membership.
-   * The storefront collected the payment; this endpoint deduplicates by
-   * `subscribeIntentKey` and records the already-paid charge.
+   * Prepare a delegated first charge for a paid Membership, or immediately
+   * start a trial. For a paid response, charge through the tenant PSP with
+   * `firstCharge.idempotencyKey`, then post the existing signed charge result
+   * to activate the membership.
    *
    * `subscribeIntentKey` is used as the HTTP idempotency key so the call is
    * safely retryable.
@@ -5860,6 +6151,39 @@ var MembershipApi = class extends BaseApi {
   }
 };
 
+// src/core/api/customer-group-api.ts
+var CustomerGroupApi = class extends BaseApi {
+  constructor(options) {
+    super("CustomerGroupApi", options);
+  }
+  listMembers(params) {
+    const query = new URLSearchParams();
+    if (params.page !== void 0) query.set("page", String(params.page));
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    return this.requestEndpoint(
+      CUSTOMER_GROUP_ENDPOINT_OPERATIONS.members,
+      void 0,
+      { pathParams: { id: params.groupId }, query }
+    );
+  }
+  grantMember(params) {
+    const { groupId, ...body } = params;
+    return this.requestEndpoint(
+      CUSTOMER_GROUP_ENDPOINT_OPERATIONS.grant,
+      body,
+      { pathParams: { id: groupId } }
+    );
+  }
+  revokeMember(params) {
+    const { groupId, ...body } = params;
+    return this.requestEndpoint(
+      CUSTOMER_GROUP_ENDPOINT_OPERATIONS.revoke,
+      body,
+      { pathParams: { id: groupId } }
+    );
+  }
+};
+
 // src/core/client/client.server.ts
 var ServerClient = class _ServerClient {
   constructor(options) {
@@ -5899,6 +6223,7 @@ var ServerClient = class _ServerClient {
       subscribe: membershipApi.subscribe.bind(membershipApi),
       cancel: membershipApi.cancel.bind(membershipApi)
     };
+    this.customerGroups = new CustomerGroupApi(serverOptions);
     const tenantIntrospectionApi = new TenantIntrospectionApi(serverOptions);
     this.tenant = {
       context: tenantIntrospectionApi.context.bind(tenantIntrospectionApi),
@@ -5967,12 +6292,14 @@ function createServerClient(options) {
 export {
   CollectionClient,
   CommunityClient,
+  CustomerGroupApi,
   EventsClient,
   ModerationApi,
   ServerClient,
   ServerCollectionClient,
   ServerCommerceClient,
   ServerPreviewClient,
+  TENANT_CONTEXT_PATH,
   TenantIntrospectionApi,
   createServerClient,
   isApiError,