@01.software/sdk 0.51.0 → 0.65.0

package/dist/server.js

@@ -1005,6 +1005,49 @@ function stockSnapshotSearchParams(params) {
 }
 
 // src/core/collection/http-client.ts
+function validateWhere(where) {
+  if (where === void 0) return false;
+  let hasNull = false;
+  function visit(value, depth, key) {
+    if (depth > 10) {
+      throw createValidationError(
+        "Collection where must not exceed nesting depth 10."
+      );
+    }
+    if (value === null && (key === "equals" || key === "not_equals")) {
+      hasNull = true;
+      return;
+    }
+    if (value == null) {
+      throw createValidationError(
+        "Collection where must not contain null or undefined values."
+      );
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        throw createValidationError(
+          "Collection where must not contain empty arrays, including and/or."
+        );
+      }
+      if (value.length > 1e3) {
+        throw createValidationError(
+          "Collection where arrays must not contain more than 1000 elements."
+        );
+      }
+      for (const item of value) visit(item, depth + 1);
+    } else if (typeof value === "object" && !(value instanceof Date)) {
+      const values = Object.entries(value);
+      if (values.length === 0) {
+        throw createValidationError(
+          "Collection where must not contain empty condition objects."
+        );
+      }
+      for (const [key2, item] of values) visit(item, depth + 1, key2);
+    }
+  }
+  visit(where, 0);
+  return hasNull;
+}
 var HttpClient = class {
   constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, apiUrl) {
     this.publishableKey = requirePublishableKeyForSecret(
@@ -1051,7 +1094,8 @@ var HttpClient = class {
       ...rest,
       "fallback-locale": fallbackLocale === false ? "none" : fallbackLocale
     };
-    const queryString = stringify(queryOptions, { addQueryPrefix: true });
+    const encodedOptions = validateWhere(queryOptions.where) ? { ...queryOptions, where: JSON.stringify(queryOptions.where) } : queryOptions;
+    const queryString = stringify(encodedOptions, { addQueryPrefix: true });
     return queryString ? `${endpoint}${queryString}` : endpoint;
   }
   assertJsonResponse(response) {
@@ -1448,10 +1492,11 @@ var CollectionClient = class extends HttpClient {
    * PATCH /api/{collection}
    */
   async requestUpdateMany(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
+    const url = this.buildUrl(endpoint, { where: data.where });
+    const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "PATCH",
-      body: JSON.stringify(data)
+      body: JSON.stringify(data.data)
     });
     return this.parseFindResponse(response);
   }
@@ -1472,10 +1517,10 @@ var CollectionClient = class extends HttpClient {
    * DELETE /api/{collection}
    */
   async requestDeleteMany(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
+    const url = this.buildUrl(endpoint, { where: data.where });
+    const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
-      method: "DELETE",
-      body: JSON.stringify(data)
+      method: "DELETE"
     });
     return this.parseFindResponse(response);
   }
@@ -1628,6 +1673,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")
   },
@@ -1727,8 +1777,51 @@ var portOneStandardActionCapabilityOperations = /* @__PURE__ */ new Set([
 ]);
 var MEMBERSHIP_ENDPOINT_OPERATIONS = {
   subscribe: operation(null, "post", "/memberships/subscribe"),
+  billingCustody: operation(null, "post", "/memberships/billing-custody"),
   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 EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS = {
+  claim: operation(null, "post", "/external-effect-claims/claim"),
+  get: operation(null, "post", "/external-effect-claims/get"),
+  arm: operation(null, "post", "/external-effect-claims/arm"),
+  release: operation(null, "post", "/external-effect-claims/release"),
+  report: operation(null, "post", "/external-effect-claims/report"),
+  recovery: operation(null, "post", "/external-effect-claims/recovery")
+};
+var INSTALLATION_CREDENTIAL_ENDPOINT_OPERATIONS = {
+  create: operation(null, "post", "/installation-credentials/create"),
+  get: operation(null, "post", "/installation-credentials/get"),
+  replace: operation(null, "post", "/installation-credentials/replace"),
+  dispose: operation(null, "post", "/installation-credentials/dispose")
+};
+var EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS = {
+  connect: operation("customers", "post", "/external-links/connect"),
+  get: operation("customers", "post", "/external-links/get"),
+  list: operation("customers", "post", "/external-links/list"),
+  unlink: operation("customers", "post", "/external-links/unlink"),
+  capturePreviousState: operation(
+    "customers",
+    "post",
+    "/external-links/capture-previous-state"
+  ),
+  clearPreviousState: operation(
+    "customers",
+    "post",
+    "/external-links/clear-previous-state"
+  )
+};
+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 CUSTOMER_AUTH_ENDPOINT_OPERATIONS = {
+  revokeRefresh: operation("customers", "post", "/revoke-refresh"),
+  withdraw: operation("customers", "post", "/withdraw")
 };
 var EMBEDDED_ADMIN_ENDPOINT_OPERATIONS = {
   show: operation("tenants", "get", "/embedded-admin-app"),
@@ -1753,6 +1846,14 @@ var COMMUNITY_ENDPOINT_OPERATIONS = {
     detail: operation("posts", "get", "/detail")
   }
 };
+var GALLERY_ENDPOINT_OPERATIONS = {
+  items: {
+    storefront: operation("gallery-items", "get", "/storefront")
+  }
+};
+var VIDEO_ENDPOINT_OPERATIONS = {
+  playback: operation("videos", "post", "/:id/playback")
+};
 function resolveOperationTemplate(descriptor) {
   return descriptor.collection ? `/api/${descriptor.collection}${descriptor.path}` : `/api${descriptor.path}`;
 }
@@ -2450,7 +2551,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",
@@ -2510,6 +2614,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");
@@ -3786,7 +3910,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(
@@ -3795,9 +3919,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,
@@ -4001,6 +4122,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;
 }
 
@@ -5552,8 +5683,12 @@ var PaymentSessionApi = class extends CustomerScopedApi {
       ...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;
@@ -5600,7 +5735,8 @@ var PaymentSessionApi = class extends CustomerScopedApi {
     const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
     return this.paymentSession(
       this.post(endpoint, body, idempotencyKey),
-      "toss"
+      "toss",
+      "cancel"
     );
   }
   cancelPortOne(params) {
@@ -5609,7 +5745,8 @@ var PaymentSessionApi = class extends CustomerScopedApi {
     const endpoint = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
     return this.paymentSession(
       this.post(endpoint, body, idempotencyKey),
-      "portone"
+      "portone",
+      "cancel"
     );
   }
   confirm(params) {
@@ -5995,6 +6132,42 @@ function appendValues(params, key, value) {
   }
 }
 
+// src/core/video/video-playback-client.ts
+var VideoPlaybackClient = class {
+  constructor(options) {
+    this.options = options;
+    if (typeof window !== "undefined") {
+      throw new TypeError("VideoPlaybackClient requires a server environment");
+    }
+  }
+  async playback(videoId) {
+    if (!videoId) throw new TypeError("videoId is required");
+    const endpoint = resolveOperationPath(VIDEO_ENDPOINT_OPERATIONS.playback, {
+      pathParams: { id: videoId }
+    });
+    try {
+      const response = await httpFetch(endpoint, {
+        method: resolveOperationMethod(VIDEO_ENDPOINT_OPERATIONS.playback),
+        apiUrl: this.options.apiUrl,
+        publishableKey: this.options.publishableKey,
+        secretKey: this.options.secretKey
+      });
+      this.options.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      const result = await parseApiResponse(response, endpoint);
+      const base = resolveApiUrl(this.options.apiUrl);
+      return {
+        streamUrl: new URL(result.streamPath, base).toString(),
+        mode: result.mode
+      };
+    } catch (error) {
+      this.options.onRequestId?.(
+        error instanceof SDKError ? error.requestId ?? null : null
+      );
+      throw error;
+    }
+  }
+};
+
 // src/core/market/market-discovery.ts
 function toMarketDTO(row) {
   return {
@@ -6065,14 +6238,34 @@ var TenantIntrospectionApi = class extends RawBaseApi {
 };
 
 // src/core/api/membership-api.ts
+async function custodySignature(body, secret, timestamp2, deliveryId) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(`${timestamp2}.${deliveryId}.billing-custody.v1:${body}`)
+  );
+  return Array.from(
+    new Uint8Array(signature),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
 var MembershipApi = class extends BaseApi {
   constructor(options) {
     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.
@@ -6099,6 +6292,334 @@ var MembershipApi = class extends BaseApi {
       { pathParams: { id } }
     );
   }
+  /**
+   * Store/read only app-encrypted billing ciphertext for the Membership's
+   * method. The tenant server receives the non-secret restore generation from
+   * its platform operator's integration configuration; it is not discovered
+   * from an unauthenticated endpoint.
+   */
+  async billingCustody(params) {
+    const { webhookSecret, ...input } = params;
+    const body = {
+      kind: "billing-custody.v1",
+      ...input
+    };
+    const timestamp2 = Date.now().toString();
+    const deliveryId = crypto.randomUUID();
+    const signature = await custodySignature(
+      JSON.stringify(body),
+      webhookSecret,
+      timestamp2,
+      deliveryId
+    );
+    return this.requestEndpoint(
+      MEMBERSHIP_ENDPOINT_OPERATIONS.billingCustody,
+      body,
+      {
+        headers: {
+          "x-membership-signature": signature,
+          "x-membership-timestamp": timestamp2,
+          "x-membership-delivery-id": deliveryId
+        }
+      }
+    );
+  }
+};
+
+// 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/api/external-effect-claims-api.ts
+var errorReasons = /* @__PURE__ */ new Set([
+  "invalid_evidence",
+  "denied",
+  "conflict",
+  "lease_lost",
+  "unknown",
+  "quota_exceeded",
+  "forbidden",
+  "authority_unavailable",
+  "internal_error"
+]);
+function getExternalEffectClaimErrorReason(error) {
+  const reason = getSDKErrorReason(error);
+  return errorReasons.has(reason) ? reason : void 0;
+}
+var states = /* @__PURE__ */ new Set([
+  "pre_dispatch_claimed",
+  "armed_unknown",
+  "reported_effect",
+  "reported_no_effect",
+  "reconciliation_required",
+  "reconciled_effect",
+  "reconciled_no_effect",
+  "unresolved_closed"
+]);
+function invalidResponse() {
+  throw createApiError(
+    "Invalid external-effect claim response",
+    200,
+    void 0,
+    "Server returned an invalid response.",
+    "Check the API version and retry after resolving the mismatch."
+  );
+}
+function claimFromResponse(value) {
+  if (!value || typeof value !== "object" || !("claim" in value))
+    invalidResponse();
+  const claim = value.claim;
+  if (!claim || typeof claim !== "object") invalidResponse();
+  const row = claim;
+  if (typeof row.id !== "string" || !states.has(row.state) || row.armedAt !== null && typeof row.armedAt !== "string" || row.firstReportOutcome !== null && row.firstReportOutcome !== "effect" && row.firstReportOutcome !== "no_effect" || row.reportAuthority !== "tenant_supplied_unverified" || typeof row.leaseGranted !== "boolean" || row.leaseToken !== null && typeof row.leaseToken !== "string" || !Number.isSafeInteger(row.leaseGeneration) || row.leaseGranted && row.leaseToken === null || !row.leaseGranted && row.leaseToken !== null)
+    invalidResponse();
+  return {
+    id: row.id,
+    state: row.state,
+    armedAt: row.armedAt,
+    firstReportOutcome: row.firstReportOutcome,
+    reportAuthority: "tenant_supplied_unverified",
+    leaseGranted: row.leaseGranted,
+    leaseToken: row.leaseToken,
+    leaseGeneration: row.leaseGeneration
+  };
+}
+var ExternalEffectClaimsApi = class extends BaseApi {
+  constructor(options) {
+    super("ExternalEffectClaimsApi", options);
+  }
+  async claim(params) {
+    return claimFromResponse(
+      await this.requestEndpoint(
+        EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.claim,
+        params
+      )
+    );
+  }
+  async get(params) {
+    return claimFromResponse(
+      await this.requestEndpoint(
+        EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.get,
+        params
+      )
+    );
+  }
+  async arm(params) {
+    return claimFromResponse(
+      await this.requestEndpoint(
+        EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.arm,
+        params
+      )
+    );
+  }
+  async release(params) {
+    const result = await this.requestEndpoint(
+      EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.release,
+      params
+    );
+    if (!result || typeof result !== "object" || !("released" in result) || result.released !== true)
+      invalidResponse();
+  }
+  async report(params) {
+    return claimFromResponse(
+      await this.requestEndpoint(
+        EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.report,
+        params
+      )
+    );
+  }
+  async recovery(params) {
+    const result = await this.requestEndpoint(
+      EXTERNAL_EFFECT_CLAIM_ENDPOINT_OPERATIONS.recovery,
+      params
+    );
+    if (!result || typeof result !== "object" || !("recorded" in result) || result.recorded !== true)
+      invalidResponse();
+  }
+};
+
+// src/core/api/installation-credentials-api.ts
+function invalidResponse2() {
+  throw createApiError(
+    "Invalid installation credential response",
+    200,
+    void 0,
+    "Server returned an invalid response.",
+    "Check the API version and retry after resolving the mismatch."
+  );
+}
+function snapshot(value) {
+  if (!value || typeof value !== "object") invalidResponse2();
+  const row = value;
+  if (typeof row.installationId !== "string" || typeof row.providerNamespace !== "string" || typeof row.providerAccountId !== "string" || typeof row.ciphertext !== "string" || row.ciphertext.length < 32 || row.ciphertext.length > 8192 || !Number.isSafeInteger(row.version) || row.version < 1)
+    invalidResponse2();
+  return row;
+}
+var InstallationCredentialsApi = class extends BaseApi {
+  constructor(options) {
+    super("InstallationCredentialsApi", options);
+  }
+  create(params) {
+    return this.requestEndpoint(
+      INSTALLATION_CREDENTIAL_ENDPOINT_OPERATIONS.create,
+      params
+    ).then(snapshot);
+  }
+  get(params) {
+    return this.requestEndpoint(
+      INSTALLATION_CREDENTIAL_ENDPOINT_OPERATIONS.get,
+      params
+    ).then(snapshot);
+  }
+  replace(params) {
+    return this.requestEndpoint(
+      INSTALLATION_CREDENTIAL_ENDPOINT_OPERATIONS.replace,
+      params
+    ).then(snapshot);
+  }
+  async dispose(params) {
+    const result = await this.requestEndpoint(
+      INSTALLATION_CREDENTIAL_ENDPOINT_OPERATIONS.dispose,
+      params
+    );
+    if (!result || typeof result !== "object") invalidResponse2();
+    const row = result;
+    if (row.installationId !== params.installationId || !Number.isSafeInteger(row.version) || row.version !== params.expectedVersion + 1 || row.state !== "disposed")
+      invalidResponse2();
+    return row;
+  }
+};
+
+// src/core/api/external-customer-links-api.ts
+function invalidResponse3() {
+  throw createApiError("Invalid external-customer link response", 200);
+}
+var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var isUuid = (value) => typeof value === "string" && (uuid.test(value) || value === "00000000-0000-0000-0000-000000000000" || value.toLowerCase() === "ffffffff-ffff-ffff-ffff-ffffffffffff");
+var isIdentity = (value) => typeof value === "string" && value.length > 0 && value.length <= 256 && value === value.trim() && // eslint-disable-next-line no-control-regex -- Normalized identity forbids C0 controls.
+!/[\u0000-\u001f]/.test(value) && !/[\uD800-\uDFFF]/u.test(value);
+var isDateTime = (value) => {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(
+    value
+  ) || !Number.isFinite(Date.parse(value)))
+    return false;
+  const day = value.slice(0, 10);
+  return (/* @__PURE__ */ new Date(`${day}T00:00:00Z`)).toISOString().startsWith(day);
+};
+function previousStateFromResponse(value) {
+  if (value === null) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    invalidResponse3();
+  const entries = Object.entries(value);
+  if (entries.length > 16 || entries.some(
+    ([key, entry]) => !/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/.test(key) || !(entry === null || typeof entry === "boolean" || typeof entry === "string" && entry.length <= 512 && // eslint-disable-next-line no-control-regex -- PostgreSQL JSON cannot store NUL or lone surrogates.
+    !/[\u0000\uD800-\uDFFF]/u.test(entry) || typeof entry === "number" && Number.isFinite(entry))
+  ))
+    invalidResponse3();
+  const result = Object.fromEntries(entries);
+  if (new TextEncoder().encode(JSON.stringify(result)).length > 2048)
+    invalidResponse3();
+  return result;
+}
+function linkFromResponse(value) {
+  if (!value || typeof value !== "object") invalidResponse3();
+  const row = value;
+  if (!isUuid(row.id) || !isUuid(row.customerId) || !isIdentity(row.namespace) || !isIdentity(row.accountScope) || row.externalCustomerId !== null && !isIdentity(row.externalCustomerId) || !["active", "released", "erased"].includes(row.state) || !isDateTime(row.connectedAt) || row.releasedAt !== null && !isDateTime(row.releasedAt) || !Number.isSafeInteger(row.version) || row.version < 1)
+    invalidResponse3();
+  const previousState = previousStateFromResponse(row.previousState);
+  if (row.state === "erased" ? row.externalCustomerId !== null || previousState !== null : row.externalCustomerId === null)
+    invalidResponse3();
+  return {
+    id: row.id,
+    customerId: row.customerId,
+    namespace: row.namespace,
+    accountScope: row.accountScope,
+    externalCustomerId: row.externalCustomerId,
+    state: row.state,
+    connectedAt: row.connectedAt,
+    releasedAt: row.releasedAt,
+    version: row.version,
+    previousState
+  };
+}
+var ExternalCustomerLinksApi = class extends BaseApi {
+  constructor(options) {
+    super("ExternalCustomerLinksApi", options);
+  }
+  async command(operation2, params) {
+    const result = await this.requestEndpoint(operation2, params);
+    if (!result || typeof result !== "object" || !("link" in result))
+      invalidResponse3();
+    return linkFromResponse(result.link);
+  }
+  connect(params) {
+    return this.command(
+      EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.connect,
+      params
+    );
+  }
+  get(params) {
+    return this.command(EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.get, params);
+  }
+  async list(params) {
+    const result = await this.requestEndpoint(
+      EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.list,
+      params
+    );
+    if (!result || typeof result !== "object" || !("links" in result) || !Array.isArray(result.links) || result.links.length > 100 || !("nextCursor" in result) || result.nextCursor !== null && !isUuid(result.nextCursor))
+      invalidResponse3();
+    return {
+      links: result.links.map(linkFromResponse),
+      nextCursor: result.nextCursor
+    };
+  }
+  unlink(params) {
+    return this.command(
+      EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.unlink,
+      params
+    );
+  }
+  capturePreviousState(params) {
+    return this.command(
+      EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.capturePreviousState,
+      params
+    );
+  }
+  clearPreviousState(params) {
+    return this.command(
+      EXTERNAL_CUSTOMER_LINK_ENDPOINT_OPERATIONS.clearPreviousState,
+      params
+    );
+  }
 };
 
 // src/core/client/client.server.ts
@@ -6135,11 +6656,22 @@ var ServerClient = class _ServerClient {
       onRequestId
     };
     this.commerce = new ServerCommerceClient(serverOptions);
+    this.video = new VideoPlaybackClient({
+      publishableKey: this.config.publishableKey,
+      secretKey: this.config.secretKey,
+      apiUrl: this.config.apiUrl,
+      onRequestId
+    });
     const membershipApi = new MembershipApi(serverOptions);
     this.memberships = {
       subscribe: membershipApi.subscribe.bind(membershipApi),
-      cancel: membershipApi.cancel.bind(membershipApi)
+      cancel: membershipApi.cancel.bind(membershipApi),
+      billingCustody: membershipApi.billingCustody.bind(membershipApi)
     };
+    this.customerGroups = new CustomerGroupApi(serverOptions);
+    this.externalEffectClaims = new ExternalEffectClaimsApi(serverOptions);
+    this.installationCredentials = new InstallationCredentialsApi(serverOptions);
+    this.externalCustomerLinks = new ExternalCustomerLinksApi(serverOptions);
     const tenantIntrospectionApi = new TenantIntrospectionApi(serverOptions);
     this.tenant = {
       context: tenantIntrospectionApi.context.bind(tenantIntrospectionApi),
@@ -6208,7 +6740,11 @@ function createServerClient(options) {
 export {
   CollectionClient,
   CommunityClient,
+  CustomerGroupApi,
   EventsClient,
+  ExternalCustomerLinksApi,
+  ExternalEffectClaimsApi,
+  InstallationCredentialsApi,
   ModerationApi,
   ServerClient,
   ServerCollectionClient,
@@ -6217,6 +6753,7 @@ export {
   TENANT_CONTEXT_PATH,
   TenantIntrospectionApi,
   createServerClient,
+  getExternalEffectClaimErrorReason,
   isApiError,
   isAuthError,
   isCommerceSDKError,