arky-sdk 0.9.13 → 0.9.16

package/dist/index.js

@@ -6,32 +6,25 @@ var PaymentMethodType = /* @__PURE__ */ ((PaymentMethodType2) => {
 })(PaymentMethodType || {});
 
 // src/utils/orderItems.ts
-function normalizeOrderQuoteItems(items) {
+function sanitizePublicCheckoutItems(items) {
   return items.map((item) => {
-    if ("type" in item) {
-      return item;
-    }
-    if ("product_id" in item) {
-      return { type: "product", ...item };
-    }
-    return { type: "service", ...item };
-  });
-}
-function normalizeOrderCheckoutItems(items) {
-  return items.map((item) => {
-    if ("type" in item) {
-      return item;
-    }
-    if ("product_id" in item) {
-      return { type: "product", ...item };
+    if (item.type === "product") {
+      return {
+        type: "product",
+        ...item.id ? { id: item.id } : {},
+        product_id: item.product_id,
+        variant_id: item.variant_id,
+        quantity: item.quantity
+      };
     }
-    return { type: "service", ...item };
-  });
-}
-function normalizePublicCheckoutItems(items) {
-  return normalizeOrderCheckoutItems(items).map((item) => {
-    const { price: _price, ...publicItem } = item;
-    return publicItem;
+    return {
+      type: "service",
+      ...item.id ? { id: item.id } : {},
+      service_id: item.service_id,
+      provider_id: item.provider_id,
+      slots: item.slots,
+      ...item.forms ? { forms: item.forms } : {}
+    };
   });
 }
 
@@ -56,10 +49,9 @@ var createActionApi = (apiConfig) => ({
   COMMON_ACTION_KEYS,
   async track(params) {
     try {
-      const key = "key" in params && params.key ? params.key : params.type;
       await apiConfig.httpClient.post(
         `/v1/storefront/${apiConfig.storeId}/actions/track`,
-        { key, payload: params.payload }
+        { key: params.key, payload: params.payload }
       );
     } catch {
     }
@@ -67,6 +59,47 @@ var createActionApi = (apiConfig) => ({
 });
 var createStorefrontApi = (apiConfig, updateContactSession) => {
   const base = (storeId = apiConfig.storeId) => `/v1/storefront/${storeId}`;
+  const pendingVerifications = /* @__PURE__ */ new Map();
+  function persistIdentification(result) {
+    const issued = result.token;
+    if (issued?.token) {
+      updateContactSession(() => ({
+        access_token: issued.token,
+        contact: result.contact,
+        store: result.store,
+        market: result.market
+      }));
+    } else {
+      if (result.verification_challenge) {
+        pendingVerifications.set(result.verification_challenge.challenge_id, {
+          store: result.store,
+          market: result.market
+        });
+      }
+      updateContactSession(
+        (current) => current ? {
+          ...current,
+          contact: result.contact,
+          store: result.store,
+          market: result.market
+        } : null
+      );
+    }
+    return result;
+  }
+  async function submitIdentification(path, params, options) {
+    const store_id = apiConfig.storeId;
+    const result = await apiConfig.httpClient.post(
+      `${base(store_id)}/account/${path}`,
+      {
+        store_id,
+        market: params?.market || apiConfig.market || null,
+        email: params?.email
+      },
+      options
+    );
+    return persistIdentification(result);
+  }
   return {
     store: {
       getStore(options) {
@@ -74,7 +107,10 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
       },
       location: {
         getCountries(options) {
-          return apiConfig.httpClient.get(`/v1/platform/countries`, options);
+          return apiConfig.httpClient.get(
+            `/v1/platform/countries`,
+            options
+          );
         },
         getCountry(countryCode, options) {
           return apiConfig.httpClient.get(
@@ -83,18 +119,30 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           );
         },
         list(options) {
-          return apiConfig.httpClient.get(`${base()}/locations`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/locations`,
+            options
+          );
         },
         get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/locations/${id}`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/locations/${id}`,
+            options
+          );
         }
       },
       market: {
         list(options) {
-          return apiConfig.httpClient.get(`${base()}/markets`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/markets`,
+            options
+          );
         },
         get(id, options) {
-          return apiConfig.httpClient.get(`${base()}/markets/${id}`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/markets/${id}`,
+            options
+          );
         }
       }
     },
@@ -102,11 +150,9 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
       collection: {
         get(params, options) {
           const store_id = params.store_id || apiConfig.storeId;
-          if (!params.id) {
-            throw new Error("GetCollectionParams requires id");
-          }
+          const identifier = params.id !== void 0 ? params.id : `${store_id}:${params.key}`;
           return apiConfig.httpClient.get(
-            `${base(store_id)}/collections/${params.id}`,
+            `${base(store_id)}/collections/${identifier}`,
             options
           );
         }
@@ -124,10 +170,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/entries`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/entries`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       },
       form: {
@@ -203,10 +252,13 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/products`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/products`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       },
       cart: {
@@ -215,16 +267,23 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           const { store_id: _store_id, ...payload } = params;
           return apiConfig.httpClient.post(
             `${base(store_id)}/carts/current`,
-            { ...payload, store_id, market: payload.market || apiConfig.market },
+            {
+              ...payload,
+              store_id,
+              market: payload.market || apiConfig.market
+            },
             options
           );
         },
         get(params, options) {
           const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.get(`${base(store_id)}/carts/${params.id}`, {
-            ...options,
-            params: params.token ? { token: params.token } : options?.params
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/carts/${params.id}`,
+            {
+              ...options,
+              params: params.token ? { token: params.token } : options?.params
+            }
+          );
         },
         update(params, options) {
           const { store_id, items, ...payload } = params;
@@ -234,7 +293,7 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             {
               ...payload,
               store_id: target,
-              ...items ? { items: normalizePublicCheckoutItems(items) } : {}
+              ...items ? { items: sanitizePublicCheckoutItems(items) } : {}
             },
             options
           );
@@ -247,7 +306,7 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             {
               ...payload,
               store_id: target,
-              item: normalizePublicCheckoutItems([item])[0]
+              item: sanitizePublicCheckoutItems([item])[0]
             },
             options
           );
@@ -302,18 +361,35 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/orders`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         },
         downloadDigitalAccess(params, options) {
           const store_id = params.store_id || apiConfig.storeId;
           return apiConfig.httpClient.post(
-            `${base(store_id)}/orders/${params.id}/digital-access/${params.grant_id}/download`,
+            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}/download`,
             {},
             options
           );
+        },
+        findDigitalAccess(params, options) {
+          const { order_id, store_id, ...queryParams } = params;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders/${order_id}/digital-access`,
+            { ...options, params: queryParams }
+          );
+        },
+        getDigitalAccess(params, options) {
+          const store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/orders/${params.order_id}/digital-access/${params.grant_id}`,
+            options
+          );
         }
       },
       service: {
@@ -334,17 +410,23 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/services`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/services`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         },
         findProviders(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/service-providers`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/service-providers`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         },
         getAvailability(params, options) {
           const { store_id, ...queryParams } = params;
@@ -373,48 +455,47 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params;
-          return apiConfig.httpClient.get(`${base(store_id)}/providers`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/providers`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
         }
       }
     },
     crm: {
       contact: {
-        async identify(params, options) {
-          const store_id = apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/account/identify`,
-            {
-              store_id,
-              market: params?.market || apiConfig.market || null,
-              email: params?.email,
-              verify: params?.verify ?? false
-            },
-            options
-          );
-          if (result?.token?.token) {
-            updateContactSession(() => ({
-              access_token: result.token.token,
-              contact: result.contact,
-              store: result.store,
-              market: result.market
-            }));
-          }
-          return result;
+        identify(params, options) {
+          return submitIdentification("identify", params, options);
+        },
+        requestCode(params, options) {
+          return submitIdentification("code", params, options);
         },
         async verify(params, options) {
           const store_id = apiConfig.storeId;
           const result = await apiConfig.httpClient.post(
             `${base(store_id)}/account/verify`,
-            { store_id, code: params.code },
+            { store_id, challenge_id: params.challenge_id, code: params.code },
             options
           );
-          if (result?.token) {
+          if (result?.token?.token) {
+            const pending = pendingVerifications.get(params.challenge_id);
+            const identifiedStore = pending?.store || await apiConfig.httpClient.get(base(store_id), options);
             updateContactSession(
-              (prev) => prev ? { ...prev, access_token: result.token } : null
+              (prev) => prev ? {
+                ...prev,
+                access_token: result.token.token,
+                contact: result.contact
+              } : {
+                access_token: result.token.token,
+                contact: result.contact,
+                store: identifiedStore,
+                market: pending?.market || null
+              }
             );
+            pendingVerifications.delete(params.challenge_id);
           }
           return result;
         },
@@ -431,7 +512,10 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
           }
         },
         getMe(options) {
-          return apiConfig.httpClient.get(`${base()}/account/me`, options);
+          return apiConfig.httpClient.get(
+            `${base()}/account/me`,
+            options
+          );
         }
       },
       contactList: {
@@ -444,10 +528,31 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
         },
         find(params, options) {
           const { store_id, ...queryParams } = params || {};
-          return apiConfig.httpClient.get(`${base(store_id)}/contact-lists`, {
-            ...options,
-            params: queryParams
-          });
+          return apiConfig.httpClient.get(
+            `${base(store_id)}/contact-lists`,
+            {
+              ...options,
+              params: queryParams
+            }
+          );
+        },
+        plans: {
+          find(params, options) {
+            const { store_id, contact_list_id, ...queryParams } = params;
+            return apiConfig.httpClient.get(
+              `${base(store_id)}/contact-lists/${contact_list_id}/plans`,
+              { ...options, params: queryParams }
+            );
+          }
+        },
+        memberships: {
+          find(params, options) {
+            const { store_id, ...queryParams } = params || {};
+            return apiConfig.httpClient.get(`${base(store_id)}/contact-lists/memberships`, {
+              ...options,
+              params: queryParams
+            });
+          }
         },
         subscribe(params, options) {
           const { store_id, id, ...payload } = params;
@@ -472,13 +577,31 @@ var createStorefrontApi = (apiConfig, updateContactSession) => {
             options
           );
         },
-        unsubscribe(token, options) {
+        manage(token, options) {
           return apiConfig.httpClient.post(
-            `${base()}/contact-lists/unsubscribe`,
+            `${base()}/contact-lists/manage`,
             { token },
             options
           );
         },
+        unsubscribe(token, options) {
+          const headers = { ...options?.headers };
+          for (const name of Object.keys(headers)) {
+            if (name.toLowerCase() === "content-type") delete headers[name];
+          }
+          return apiConfig.httpClient.post(
+            `${base()}/contact-lists/unsubscribe`,
+            new URLSearchParams({ "List-Unsubscribe": "One-Click" }),
+            {
+              ...options,
+              params: { ...options?.params || {}, token },
+              headers: {
+                ...headers,
+                "Content-Type": "application/x-www-form-urlencoded"
+              }
+            }
+          );
+        },
         confirm(token, options) {
           return apiConfig.httpClient.post(
             `${base()}/contact-lists/confirm`,
@@ -643,27 +766,47 @@ var convertServerErrorToRequestError = (serverError, renameRules) => {
 
 // src/utils/queryParams.ts
 function buildQueryString(params) {
-  const queryParts = [];
-  Object.entries(params).forEach(([key, value]) => {
-    if (value === null || value === void 0) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
-    } else if (typeof value === "string") {
-      queryParts.push(`${key}=${encodeURIComponent(value)}`);
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      queryParts.push(`${key}=${value}`);
-    } else if (typeof value === "object") {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
+  const queryParts = Object.entries(params).flatMap(
+    ([key, value]) => {
+      if (value === null || value === void 0) return [];
+      if (typeof value === "string") {
+        return [`${key}=${encodeURIComponent(value)}`];
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return [`${key}=${value}`];
+      }
+      if (Array.isArray(value) || typeof value === "object") {
+        return [`${key}=${encodeURIComponent(JSON.stringify(value))}`];
+      }
+      return [];
     }
-  });
+  );
   return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
 }
 
 // src/services/createHttpClient.ts
+function requestError(name, message, details = {}) {
+  return Object.assign(new Error(message), { name }, details);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTokenSet(value) {
+  return isRecord(value) && typeof value.access_token === "string" && (value.refresh_token === void 0 || typeof value.refresh_token === "string") && (value.access_expires_at === void 0 || typeof value.access_expires_at === "number");
+}
+function isValidationError(value) {
+  return isRecord(value) && typeof value.field === "string" && typeof value.error === "string";
+}
+function toServerError(value, statusCode) {
+  const payload = isRecord(value) ? value : {};
+  const validationErrors = Array.isArray(payload.validationErrors) ? payload.validationErrors.filter(isValidationError) : [];
+  return {
+    message: typeof payload.message === "string" ? payload.message : "Request failed",
+    error: typeof payload.error === "string" ? payload.error : "REQUEST_FAILED",
+    statusCode: typeof payload.statusCode === "number" ? payload.statusCode : statusCode,
+    validationErrors
+  };
+}
 function createHttpClient(cfg) {
   const { authStorage } = cfg;
   let refreshPromise = null;
@@ -680,32 +823,41 @@ function createHttpClient(cfg) {
       const refresh_token = tokens?.refresh_token;
       if (!refresh_token) {
         authStorage.onForcedLogout();
-        const err = new Error("No refresh token available");
-        err.name = "ApiError";
-        err.statusCode = 401;
-        throw err;
+        throw requestError("ApiError", "No refresh token available", {
+          statusCode: 401
+        });
       }
       const refRes = await fetch(getRefreshEndpoint(), {
         method: "POST",
-        headers: { Accept: "application/json", "Content-Type": "application/json" },
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
         body: JSON.stringify({ refresh_token })
       });
       if (!refRes.ok) {
         authStorage.onForcedLogout();
-        const err = new Error("Token refresh failed");
-        err.name = "ApiError";
-        err.statusCode = 401;
-        throw err;
+        throw requestError("ApiError", "Token refresh failed", {
+          statusCode: 401
+        });
       }
       const data = await refRes.json();
+      if (!isTokenSet(data)) {
+        authStorage.onForcedLogout();
+        throw requestError(
+          "ParseError",
+          "Token refresh returned an invalid response",
+          { statusCode: refRes.status }
+        );
+      }
       authStorage.onTokensRefreshed(data);
     })().finally(() => {
       refreshPromise = null;
     });
     return refreshPromise;
   }
-  async function request(method, path, body, options) {
-    if (options?.transformRequest) {
+  async function request(method, path, body, options, retried = false) {
+    if (!retried && options?.transformRequest) {
       body = options.transformRequest(body);
     }
     const headers = {
@@ -723,23 +875,27 @@ function createHttpClient(cfg) {
       headers["Authorization"] = `Bearer ${tokens.access_token}`;
     }
     const finalPath = options?.params ? path + buildQueryString(options.params) : path;
-    const fetchOpts = { method, headers, signal: options?.signal };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: options?.signal
+    };
     if (!["GET", "DELETE"].includes(method) && body !== void 0) {
-      fetchOpts.body = JSON.stringify(body);
+      fetchOptions.body = body instanceof URLSearchParams ? body.toString() : JSON.stringify(body);
     }
     const fullUrl = `${cfg.baseUrl}${finalPath}`;
     let res;
     let data;
     const startedAt = Date.now();
     try {
-      res = await fetch(fullUrl, fetchOpts);
+      res = await fetch(fullUrl, fetchOptions);
     } catch (error) {
       const aborted = options?.signal?.aborted || error instanceof Error && error.name === "AbortError";
-      const err = new Error(error instanceof Error ? error.message : "Network request failed");
-      err.name = aborted ? "AbortError" : "NetworkError";
-      err.method = method;
-      err.url = fullUrl;
-      err.aborted = aborted;
+      const err = requestError(
+        aborted ? "AbortError" : "NetworkError",
+        error instanceof Error ? error.message : "Network request failed",
+        { method, url: fullUrl, aborted }
+      );
       if (options?.onError && method !== "GET") {
         Promise.resolve(
           options.onError({ error: err, method, url: fullUrl, aborted })
@@ -748,18 +904,9 @@ function createHttpClient(cfg) {
       }
       throw err;
     }
-    if (res.status === 401 && !options?.["_retried"]) {
-      try {
-        await ensureFreshToken();
-        const refreshed = authStorage.getTokens();
-        if (refreshed?.access_token) {
-          headers["Authorization"] = `Bearer ${refreshed.access_token}`;
-          fetchOpts.headers = headers;
-        }
-        return request(method, path, body, { ...options, _retried: true });
-      } catch (refreshError) {
-        throw refreshError;
-      }
+    if (res.status === 401 && !retried) {
+      await ensureFreshToken();
+      return request(method, path, body, options, true);
     }
     try {
       const contentLength = res.headers.get("content-length");
@@ -770,30 +917,35 @@ function createHttpClient(cfg) {
         data = await res.json();
       }
     } catch (error) {
-      const err = new Error("Failed to parse response");
-      err.name = "ParseError";
-      err.method = method;
-      err.url = fullUrl;
-      err.status = res.status;
+      const err = requestError("ParseError", "Failed to parse response", {
+        method,
+        url: fullUrl,
+        statusCode: res.status
+      });
       if (options?.onError && method !== "GET") {
         Promise.resolve(
-          options.onError({ error: err, method, url: fullUrl, status: res.status })
+          options.onError({
+            error: err,
+            method,
+            url: fullUrl,
+            status: res.status
+          })
         ).catch(() => {
         });
       }
       throw err;
     }
     if (!res.ok) {
-      const serverErr = data;
+      const serverErr = toServerError(data, res.status);
       const reqErr = convertServerErrorToRequestError(serverErr);
-      const err = new Error(serverErr.message || "Request failed");
-      err.name = "ApiError";
-      err.statusCode = serverErr.statusCode || res.status;
-      err.validationErrors = reqErr.validationErrors;
-      err.method = method;
-      err.url = fullUrl;
       const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
-      if (requestId) err.requestId = requestId;
+      const err = requestError("ApiError", serverErr.message, {
+        statusCode: serverErr.statusCode,
+        validationErrors: reqErr.validationErrors,
+        method,
+        url: fullUrl,
+        requestId: requestId || void 0
+      });
       if (options?.onError && method !== "GET") {
         Promise.resolve(
           options.onError({
@@ -836,35 +988,73 @@ function createHttpClient(cfg) {
 }
 
 // src/api/account.ts
-var createAccountApi = (apiConfig) => {
-  return {
-    async updateAccount(params, options) {
-      const payload = {};
-      if (params.phone_numbers !== void 0) payload.phone_numbers = params.phone_numbers;
-      if (params.addresses !== void 0) payload.addresses = params.addresses;
-      if (params.api_tokens !== void 0) payload.api_tokens = params.api_tokens;
-      return apiConfig.httpClient.put("/v1/accounts", payload, options);
-    },
-    async deleteAccount(_params, options) {
-      return apiConfig.httpClient.delete("/v1/accounts", options);
-    },
-    async getMe(_params, options) {
-      return apiConfig.httpClient.get("/v1/accounts/me", options);
-    },
-    async searchAccounts(params, options) {
-      return apiConfig.httpClient.get("/v1/accounts/search", {
-        ...options,
-        params: {
-          ...params,
-          store_id: apiConfig.storeId
-        }
-      });
-    }
-  };
-};
+var createAccountApi = (apiConfig) => ({
+  async updateAccount(_params, options) {
+    return apiConfig.httpClient.put(
+      "/v1/accounts",
+      {},
+      options
+    );
+  },
+  async deleteAccount(_params, options) {
+    return apiConfig.httpClient.delete(
+      "/v1/accounts",
+      options
+    );
+  },
+  async getMe(_params, options) {
+    return apiConfig.httpClient.get("/v1/accounts/me", options);
+  },
+  async searchAccounts(params, options) {
+    return apiConfig.httpClient.get(
+      "/v1/accounts/search",
+      { ...options, params }
+    );
+  },
+  async listApiTokens(options) {
+    return apiConfig.httpClient.get(
+      "/v1/accounts/me/api-tokens",
+      options
+    );
+  },
+  async createApiToken(params, options) {
+    return apiConfig.httpClient.post(
+      "/v1/accounts/me/api-tokens",
+      params,
+      options
+    );
+  },
+  async updateApiToken(params, options) {
+    const { id, ...payload } = params;
+    return apiConfig.httpClient.put(
+      `/v1/accounts/me/api-tokens/${id}`,
+      payload,
+      options
+    );
+  },
+  async revokeApiToken(id, options) {
+    return apiConfig.httpClient.delete(
+      `/v1/accounts/me/api-tokens/${id}`,
+      options
+    );
+  },
+  async listSessions(options) {
+    return apiConfig.httpClient.get(
+      "/v1/accounts/me/sessions",
+      options
+    );
+  },
+  async revokeSession(id, options) {
+    return apiConfig.httpClient.delete(
+      `/v1/accounts/me/sessions/${id}`,
+      options
+    );
+  }
+});
 
 // src/api/auth.ts
 var createAuthApi = (apiConfig, updateSession) => {
+  const pendingEmails = /* @__PURE__ */ new Map();
   function applyAuthToken(result, email) {
     const next = {
       access_token: result.access_token,
@@ -876,7 +1066,9 @@ var createAuthApi = (apiConfig, updateSession) => {
   }
   return {
     async code(params, options) {
-      return apiConfig.httpClient.post("/v1/auth/code", params, options);
+      const result = await apiConfig.httpClient.post("/v1/auth/code", params, options);
+      pendingEmails.set(result.challenge_id, params.email);
+      return result;
     },
     async verify(params, options) {
       const result = await apiConfig.httpClient.post(
@@ -885,7 +1077,8 @@ var createAuthApi = (apiConfig, updateSession) => {
         options
       );
       if (result?.access_token) {
-        applyAuthToken(result, params.email);
+        applyAuthToken(result, pendingEmails.get(params.challenge_id));
+        pendingEmails.delete(params.challenge_id);
       }
       return result;
     },
@@ -893,7 +1086,9 @@ var createAuthApi = (apiConfig, updateSession) => {
       return apiConfig.httpClient.post("/v1/auth/refresh", params, options);
     },
     async storeCode(storeId, params, options) {
-      return apiConfig.httpClient.post(`/v1/stores/${storeId}/auth/code`, params, options);
+      const result = await apiConfig.httpClient.post(`/v1/stores/${storeId}/auth/code`, params, options);
+      pendingEmails.set(result.challenge_id, params.email);
+      return result;
     },
     async storeVerify(storeId, params, options) {
       const result = await apiConfig.httpClient.post(
@@ -902,7 +1097,8 @@ var createAuthApi = (apiConfig, updateSession) => {
         options
       );
       if (result?.access_token) {
-        applyAuthToken(result, params.email);
+        applyAuthToken(result, pendingEmails.get(params.challenge_id));
+        pendingEmails.delete(params.challenge_id);
       }
       return result;
     }
@@ -916,23 +1112,10 @@ var createStoreApi = (apiConfig, _updateSession) => {
       return apiConfig.httpClient.post(`/v1/stores`, params, options);
     },
     async updateStore(params, options) {
-      return apiConfig.httpClient.put(
-        `/v1/stores/${params.id}`,
-        params,
-        options
-      );
-    },
-    async deleteStore(params, options) {
-      return apiConfig.httpClient.delete(
-        `/v1/stores/${params.id}`,
-        options
-      );
+      return apiConfig.httpClient.put(`/v1/stores/${params.id}`, params, options);
     },
     async getStore(_params, options) {
-      return apiConfig.httpClient.get(
-        `/v1/stores/${apiConfig.storeId}`,
-        options
-      );
+      return apiConfig.httpClient.get(`/v1/stores/${apiConfig.storeId}`, options);
     },
     async getStores(params, options) {
       return apiConfig.httpClient.get(`/v1/stores`, {
@@ -941,20 +1124,58 @@ var createStoreApi = (apiConfig, _updateSession) => {
       });
     },
     async getSubscriptionPlans(_params, options) {
-      return apiConfig.httpClient.get(
-        "/v1/stores/plans",
+      return apiConfig.httpClient.get("/v1/stores/plans", options);
+    },
+    async createSubscriptionAction(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      const response = await apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/subscription/actions`,
+        payload,
         options
       );
+      if (response.id !== params.action_id) {
+        throw new Error("Subscription response did not match the requested action_id");
+      }
+      return response;
     },
-    async subscribe(params, options) {
-      const { store_id, plan_id, action, success_url, cancel_url } = params;
-      const target_store_id = store_id || apiConfig.storeId;
-      return apiConfig.httpClient.put(
-        `/v1/stores/${target_store_id}/subscribe`,
-        { plan_id, action, success_url, cancel_url },
+    async getSubscription(params = {}, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(`/v1/stores/${store_id}/subscription`, options);
+    },
+    async retrySubscriptionAction(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/subscription/actions/${params.action_id}/retry`,
+        {},
+        options
+      );
+    },
+    async getSubscriptionAction(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(`/v1/stores/${store_id}/subscription/actions/${params.action_id}`, options);
+    },
+    async findSubscriptionActionEffects(params, options) {
+      const { store_id, action_id, ...query } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id || apiConfig.storeId}/subscription/actions/${action_id}/effects`,
+        { ...options, params: query }
+      );
+    },
+    async getSubscriptionActionEffect(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/subscription/actions/${params.action_id}/effects/${params.effect_id}`,
         options
       );
     },
+    async findSubscriptionActions(params = {}, options) {
+      const { store_id, ...query } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id || apiConfig.storeId}/subscription/actions`,
+        { ...options, params: query }
+      );
+    },
     async createPortalSession(params, options) {
       const store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.post(
@@ -965,114 +1186,61 @@ var createStoreApi = (apiConfig, _updateSession) => {
     },
     async addMember(params, options) {
       const { store_id, ...payload } = params;
-      return apiConfig.httpClient.post(
-        `/v1/stores/${store_id || apiConfig.storeId}/members`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.post(`/v1/stores/${store_id || apiConfig.storeId}/members`, payload, options);
     },
     async inviteUser(params, options) {
       const { store_id, ...payload } = params;
-      return apiConfig.httpClient.post(
-        `/v1/stores/${store_id || apiConfig.storeId}/members`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.post(`/v1/stores/${store_id || apiConfig.storeId}/invitation`, payload, options);
+    },
+    async findMembers(params = {}, options) {
+      const { store_id, ...query } = params;
+      return apiConfig.httpClient.get(`/v1/stores/${store_id || apiConfig.storeId}/members`, {
+        ...options,
+        params: query
+      });
+    },
+    async findOwnMemberships(options) {
+      return apiConfig.httpClient.get("/v1/stores/memberships", options);
     },
     async removeMember(params, options) {
       return apiConfig.httpClient.delete(
-        `/v1/stores/${apiConfig.storeId}/members/${params.account_id}`,
+        `/v1/stores/${params.store_id || apiConfig.storeId}/members/${params.account_id}`,
         options
       );
     },
     async testWebhook(params, options) {
-      return apiConfig.httpClient.post(
-        `/v1/stores/${apiConfig.storeId}/webhooks/test`,
-        params,
-        options
-      );
-    },
-    async getStoreMedia(params, options) {
-      const queryParams = {
-        limit: params.limit
-      };
-      if (params.cursor) queryParams.cursor = params.cursor;
-      if (params.ids && params.ids.length > 0)
-        queryParams.ids = JSON.stringify(params.ids);
-      if (params.query) queryParams.query = params.query;
-      if (params.mime_type) queryParams.mime_type = params.mime_type;
-      if (params.sort_field) queryParams.sort_field = params.sort_field;
-      if (params.sort_direction)
-        queryParams.sort_direction = params.sort_direction;
-      return apiConfig.httpClient.get(
-        `/v1/stores/${params.id}/media`,
-        {
-          ...options,
-          params: queryParams
-        }
-      );
+      return apiConfig.httpClient.post(`/v1/stores/${apiConfig.storeId}/webhooks/test`, params, options);
     },
     async listBuildHooks(params, options) {
-      return apiConfig.httpClient.get(
-        `/v1/stores/${params.store_id}/build-hooks`,
-        options
-      );
+      return apiConfig.httpClient.get(`/v1/stores/${params.store_id}/build-hooks`, options);
     },
     async createBuildHook(params, options) {
       const { store_id, ...payload } = params;
-      return apiConfig.httpClient.post(
-        `/v1/stores/${store_id}/build-hooks`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.post(`/v1/stores/${store_id}/build-hooks`, payload, options);
     },
     async updateBuildHook(params, options) {
       const { store_id, id, ...payload } = params;
-      return apiConfig.httpClient.put(
-        `/v1/stores/${store_id}/build-hooks/${id}`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.put(`/v1/stores/${store_id}/build-hooks/${id}`, payload, options);
     },
     async deleteBuildHook(params, options) {
-      return apiConfig.httpClient.delete(
-        `/v1/stores/${params.store_id}/build-hooks/${params.id}`,
-        options
-      );
+      return apiConfig.httpClient.delete(`/v1/stores/${params.store_id}/build-hooks/${params.id}`, options);
     },
-    async getStoreConfig(params, options) {
-      return apiConfig.httpClient.get(
-        `/v1/stores/${params.store_id}/config/${params.type}`,
-        options
-      );
+    async getPaymentConfig(params, options) {
+      return apiConfig.httpClient.get(`/v1/stores/${params.store_id}/config/payment`, options);
     },
     async listWebhooks(params, options) {
-      return apiConfig.httpClient.get(
-        `/v1/stores/${params.store_id}/webhooks`,
-        options
-      );
+      return apiConfig.httpClient.get(`/v1/stores/${params.store_id}/webhooks`, options);
     },
     async createWebhook(params, options) {
       const { store_id, ...payload } = params;
-      return apiConfig.httpClient.post(
-        `/v1/stores/${store_id}/webhooks`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.post(`/v1/stores/${store_id}/webhooks`, payload, options);
     },
     async updateWebhook(params, options) {
       const { store_id, id, ...payload } = params;
-      return apiConfig.httpClient.put(
-        `/v1/stores/${store_id}/webhooks/${id}`,
-        payload,
-        options
-      );
+      return apiConfig.httpClient.put(`/v1/stores/${store_id}/webhooks/${id}`, payload, options);
     },
     async deleteWebhook(params, options) {
-      return apiConfig.httpClient.delete(
-        `/v1/stores/${params.store_id}/webhooks/${params.id}`,
-        options
-      );
+      return apiConfig.httpClient.delete(`/v1/stores/${params.store_id}/webhooks/${params.id}`, options);
     }
   };
 };
@@ -1109,9 +1277,10 @@ var createMediaApi = (apiConfig) => {
       return await response.json();
     },
     async deleteStoreMedia(params, options) {
-      const { id, media_id } = params;
+      const { store_id, media_id } = params;
+      const target_store_id = store_id || apiConfig.storeId;
       return apiConfig.httpClient.delete(
-        `/v1/stores/${id}/media/${media_id}`,
+        `/v1/stores/${target_store_id}/media/${media_id}`,
         options
       );
     },
@@ -1155,16 +1324,23 @@ var createMediaApi = (apiConfig) => {
 // src/api/notification.ts
 var createNotificationApi = (apiConfig) => {
   return {
-    async trackEmailOpen(params, options) {
+    async sendEmail(request, options) {
+      return apiConfig.httpClient.post(
+        "/v1/notifications/email",
+        request,
+        options
+      );
+    },
+    async getEmailDelivery(params, options) {
       return apiConfig.httpClient.get(
-        `/v1/notifications/track/pixel/${params.tracking_pixel_id}`,
+        `/v1/notifications/email-deliveries/${params.delivery_id}`,
         options
       );
     },
-    async trigger(params, options) {
+    async retryEmailDelivery(params, options) {
       return apiConfig.httpClient.post(
-        "/v1/notifications/trigger",
-        params,
+        `/v1/notifications/email-deliveries/${params.delivery_id}/retry`,
+        { revision: params.revision },
         options
       );
     }
@@ -1247,14 +1423,7 @@ var createCmsApi = (apiConfig) => {
     },
     async getCollection(params, options) {
       const target_store_id = params.store_id || apiConfig.storeId;
-      let identifier;
-      if (params.id) {
-        identifier = params.id;
-      } else if (params.key) {
-        identifier = `${target_store_id}:${params.key}`;
-      } else {
-        throw new Error("GetCollectionParams requires id or key");
-      }
+      const identifier = params.id !== void 0 ? params.id : `${target_store_id}:${params.key}`;
       return apiConfig.httpClient.get(
         `/v1/stores/${target_store_id}/collections/${identifier}`,
         options
@@ -1522,7 +1691,7 @@ var createEshopApi = (apiConfig) => {
       const target_store_id = store_id || apiConfig.storeId;
       const payload = {
         ...rest,
-        ...items ? { items: normalizeOrderCheckoutItems(items) } : {}
+        ...items ? { items } : {}
       };
       return apiConfig.httpClient.put(
         `/v1/stores/${target_store_id}/orders/${params.id}`,
@@ -1573,7 +1742,7 @@ var createEshopApi = (apiConfig) => {
         `/v1/stores/${target_store_id}/carts`,
         {
           ...payload,
-          items: normalizeOrderCheckoutItems(payload.items || [])
+          items: payload.items || []
         },
         options
       );
@@ -1585,7 +1754,7 @@ var createEshopApi = (apiConfig) => {
         `/v1/stores/${target_store_id}/carts/${id}`,
         {
           ...payload,
-          ...items ? { items: normalizeOrderCheckoutItems(items) } : {}
+          ...items ? { items } : {}
         },
         options
       );
@@ -1595,7 +1764,7 @@ var createEshopApi = (apiConfig) => {
       const target_store_id = store_id || apiConfig.storeId;
       return apiConfig.httpClient.post(
         `/v1/stores/${target_store_id}/carts/${id}/items`,
-        { item: normalizeOrderCheckoutItems([item])[0] },
+        { item },
         options
       );
     },
@@ -1649,27 +1818,134 @@ var createEshopApi = (apiConfig) => {
         `/v1/stores/${target_store_id}/orders/quote`,
         {
           ...rest,
-          items: normalizeOrderQuoteItems(items),
+          items,
           shipping_address,
           market: rest.market || apiConfig.market
         },
         options
       );
     },
-    async processRefund(params, options) {
+    async createRefund(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      const response = await apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/refunds`,
+        {
+          amount: params.amount,
+          refund_id: params.refund_id
+        },
+        options
+      );
+      if (response.refund_id !== params.refund_id) {
+        throw new Error(
+          "Refund response did not match the requested refund_id"
+        );
+      }
+      if (!Number.isSafeInteger(response.amount) || response.amount !== params.amount) {
+        throw new Error("Refund response did not match the requested amount");
+      }
+      if (![
+        "requested",
+        "processing",
+        "succeeded",
+        "rejected",
+        "failed",
+        "unknown"
+      ].includes(response.status)) {
+        throw new Error("Refund response contained an invalid status");
+      }
+      return response;
+    },
+    async retryRefund(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.post(
-        `/v1/stores/${apiConfig.storeId}/orders/${params.id}/refund`,
-        { amount: params.amount },
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/refunds/${params.refund_id}/retry`,
+        {},
         options
       );
     },
+    async getPayment(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/payment`,
+        options
+      );
+    },
+    async retryPaymentTransaction(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/payment/transactions/${params.transaction_id}/retry`,
+        {},
+        options
+      );
+    },
+    async getPaymentTransactions(params, options) {
+      const { order_id, store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${order_id}/payment/transactions`,
+        { ...options, params: queryParams }
+      );
+    },
+    async getPaymentTransaction(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/payment/transactions/${params.transaction_id}`,
+        options
+      );
+    },
+    async getRefund(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/refunds/${params.refund_id}`,
+        options
+      );
+    },
+    async getRefunds(params, options) {
+      const { order_id, store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${order_id}/refunds`,
+        { ...options, params: queryParams }
+      );
+    },
     async downloadDigitalAccess(params, options) {
       const target_store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.post(
-        `/v1/stores/${target_store_id}/orders/${params.id}/digital-access/${params.grant_id}/download`,
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/digital-access/${params.grant_id}/download`,
+        {},
+        options
+      );
+    },
+    async activateDigitalAccess(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/digital-access/${params.grant_id}/activate`,
+        {},
+        options
+      );
+    },
+    async revokeDigitalAccess(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/digital-access/${params.grant_id}/revoke`,
         {},
         options
       );
+    },
+    async findDigitalAccess(params, options) {
+      const { order_id, store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${order_id}/digital-access`,
+        { ...options, params: queryParams }
+      );
+    },
+    async getDigitalAccess(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${params.order_id}/digital-access/${params.grant_id}`,
+        options
+      );
     }
   };
 };
@@ -1868,17 +2144,27 @@ var createContactApi = (apiConfig) => {
         options
       );
     },
-    async revokeToken(params, options) {
+    async findSessions(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const queryParams = {};
+      if (params.limit !== void 0) queryParams.limit = params.limit;
+      if (params.cursor) queryParams.cursor = params.cursor;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/contacts/${params.contact_id}/sessions`,
+        { ...options, params: queryParams }
+      );
+    },
+    async revokeSession(params, options) {
       const store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.delete(
-        `/v1/stores/${store_id}/contacts/${params.id}/sessions/${params.token_id}`,
+        `/v1/stores/${store_id}/contacts/${params.contact_id}/sessions/${params.session_id}`,
         options
       );
     },
-    async revokeAllTokens(params, options) {
+    async revokeAllSessions(params, options) {
       const store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.delete(
-        `/v1/stores/${store_id}/contacts/${params.id}/sessions`,
+        `/v1/stores/${store_id}/contacts/${params.contact_id}/sessions`,
         options
       );
     },
@@ -1916,6 +2202,49 @@ var createContactApi = (apiConfig) => {
           { ...options, params: queryParams }
         );
       },
+      plans: {
+        async create(params, options) {
+          const { store_id, contact_list_id, ...payload } = params;
+          const target_store_id = store_id || apiConfig.storeId;
+          return apiConfig.httpClient.post(
+            `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/plans`,
+            payload,
+            options
+          );
+        },
+        async update(params, options) {
+          const { id, store_id, contact_list_id, ...payload } = params;
+          const target_store_id = store_id || apiConfig.storeId;
+          return apiConfig.httpClient.put(
+            `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/plans/${id}`,
+            payload,
+            options
+          );
+        },
+        async get(params, options) {
+          const target_store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/plans/${params.id}`,
+            options
+          );
+        },
+        async find(params, options) {
+          const { store_id, contact_list_id, ...queryParams } = params;
+          const target_store_id = store_id || apiConfig.storeId;
+          return apiConfig.httpClient.get(
+            `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/plans`,
+            { ...options, params: queryParams }
+          );
+        },
+        async retryCatalog(params, options) {
+          const target_store_id = params.store_id || apiConfig.storeId;
+          return apiConfig.httpClient.post(
+            `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/plans/${params.plan_id}/catalog/retry`,
+            {},
+            options
+          );
+        }
+      },
       async importContacts(params, options) {
         const { store_id, contact_list_id, ...payload } = params;
         const target_store_id = store_id || apiConfig.storeId;
@@ -1972,9 +2301,102 @@ var createContactApi = (apiConfig) => {
             { ...options, params: queryParams }
           );
         }
+      },
+      memberships: {
+        async refund(params, options) {
+          const { store_id, contact_list_id, membership_id, ...payload } = params;
+          const target_store_id = store_id || apiConfig.storeId;
+          const response = await apiConfig.httpClient.post(
+            `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/memberships/${membership_id}/refund`,
+            payload,
+            options
+          );
+          if (response.refund_id !== params.refund_id) {
+            throw new Error(
+              "Membership refund response did not match the requested refund_id"
+            );
+          }
+          return response;
+        },
+        paymentAttempts: {
+          async find(params, options) {
+            const { store_id, contact_list_id, membership_id, ...queryParams } = params;
+            const target_store_id = store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/memberships/${membership_id}/payment-attempts`,
+              { ...options, params: queryParams }
+            );
+          },
+          async get(params, options) {
+            const target_store_id = params.store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/memberships/${params.membership_id}/payment-attempts/${params.id}`,
+              options
+            );
+          }
+        },
+        refunds: {
+          async find(params, options) {
+            const { store_id, contact_list_id, membership_id, ...queryParams } = params;
+            const target_store_id = store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/memberships/${membership_id}/refunds`,
+              { ...options, params: queryParams }
+            );
+          },
+          async get(params, options) {
+            const target_store_id = params.store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/memberships/${params.membership_id}/refunds/${params.id}`,
+              options
+            );
+          },
+          async retry(params, options) {
+            const target_store_id = params.store_id || apiConfig.storeId;
+            return apiConfig.httpClient.post(
+              `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/memberships/${params.membership_id}/refunds/${params.id}/retry`,
+              {},
+              options
+            );
+          }
+        },
+        cancellations: {
+          async find(params, options) {
+            const { store_id, contact_list_id, membership_id, ...queryParams } = params;
+            const target_store_id = store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${contact_list_id}/memberships/${membership_id}/cancellations`,
+              { ...options, params: queryParams }
+            );
+          },
+          async get(params, options) {
+            const target_store_id = params.store_id || apiConfig.storeId;
+            return apiConfig.httpClient.get(
+              `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/memberships/${params.membership_id}/cancellations/${params.id}`,
+              options
+            );
+          },
+          async retry(params, options) {
+            const target_store_id = params.store_id || apiConfig.storeId;
+            return apiConfig.httpClient.post(
+              `/v1/stores/${target_store_id}/contact-lists/${params.contact_list_id}/memberships/${params.membership_id}/cancellations/${params.id}/retry`,
+              {},
+              options
+            );
+          }
+        }
       }
     },
     mailbox: {
+      async connectGoogle(params, options) {
+        const { store_id, ...payload } = params;
+        const target_store_id = store_id || apiConfig.storeId;
+        return apiConfig.httpClient.post(
+          `/v1/stores/${target_store_id}/mailboxes/google/connect-url`,
+          payload,
+          options
+        );
+      },
       async create(params, options) {
         const { store_id, ...payload } = params;
         const target_store_id = store_id || apiConfig.storeId;
@@ -2231,28 +2653,49 @@ function supportConversationQuery(params) {
   if (params.after_id) qs.set("after_id", params.after_id);
   return qs.toString();
 }
+function storefrontSupportOptions(supportToken, options) {
+  if (!/^[0-9a-f]{64}$/.test(supportToken)) {
+    throw new Error("support_token must be a 64-character lowercase hexadecimal token");
+  }
+  const headers = { ...options?.headers };
+  for (const name of Object.keys(headers)) {
+    if (name.toLowerCase() === "x-arky-support-token") delete headers[name];
+  }
+  return {
+    ...options,
+    headers: {
+      ...headers,
+      "X-Arky-Support-Token": supportToken
+    }
+  };
+}
 function createStorefrontSupportApi(config) {
-  const { httpClient, storeId } = config;
+  const { httpClient } = config;
   return {
     async startConversation(params = {}, opts) {
+      const storeId = config.storeId;
       return httpClient.post(
         `/v1/storefront/${storeId}/support/conversations`,
-        { store_id: storeId, ...params },
+        { ...params, store_id: storeId },
         opts
       );
     },
     async sendMessage(params, opts) {
+      const { support_token, ...request } = params;
+      const storeId = config.storeId;
       return httpClient.post(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}/messages`,
-        { store_id: storeId, ...params },
-        opts
+        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}/messages`,
+        { ...request, store_id: storeId },
+        storefrontSupportOptions(support_token, opts)
       );
     },
     async getConversation(params, opts) {
-      const qs = supportConversationQuery({ store_id: storeId, ...params });
+      const { support_token, ...request } = params;
+      const storeId = config.storeId;
+      const qs = supportConversationQuery({ ...request, store_id: storeId });
       return httpClient.get(
-        `/v1/storefront/${storeId}/support/conversations/${params.conversation_id}?${qs}`,
-        opts
+        `/v1/storefront/${storeId}/support/conversations/${request.conversation_id}?${qs}`,
+        storefrontSupportOptions(support_token, opts)
       );
     }
   };
@@ -2574,11 +3017,50 @@ var createSocialApi = (apiConfig) => {
         options
       );
     },
-    async replyToPublicationComment(params, options) {
-      const { store_id, publication_id, comment_id, text } = params;
+    async createCommentReply(params, options) {
+      const { store_id, publication_id, comment_id, ...payload } = params;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${storeId(store_id)}/social-publications/${publication_id}/comments/${comment_id}/replies`,
+        payload,
+        options
+      );
+    },
+    async listCommentReplies(params, options) {
+      const { store_id, publication_id, comment_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/social-publications/${publication_id}/comments/${comment_id}/replies`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    },
+    async getCommentReply(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(params.store_id)}/social-publications/${params.publication_id}/comments/${params.comment_id}/replies/${params.reply_id}`,
+        options
+      );
+    },
+    async retryCommentReply(params, options) {
       return apiConfig.httpClient.post(
-        `/v1/stores/${storeId(store_id)}/social-publications/${publication_id}/comments/${comment_id}/reply`,
-        { text },
+        `/v1/stores/${storeId(params.store_id)}/social-publications/${params.publication_id}/comments/${params.comment_id}/replies/${params.reply_id}/retry`,
+        {},
+        options
+      );
+    },
+    async listPublicationEffects(params, options) {
+      const { store_id, publication_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/social-publications/${publication_id}/effects`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    },
+    async getPublicationEffect(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(params.store_id)}/social-publications/${params.publication_id}/effects/${params.effect_id}`,
         options
       );
     },
@@ -2605,41 +3087,41 @@ var createSocialApi = (apiConfig) => {
     },
     async getCapabilities(params, options) {
       return apiConfig.httpClient.get(
-        `/v1/stores/${storeId(params?.store_id)}/social-accounts/capabilities`,
+        `/v1/stores/${storeId(params?.store_id)}/social-connections/capabilities`,
         options
       );
     },
-    async listAccounts(params, options) {
+    async listConnections(params, options) {
       return apiConfig.httpClient.get(
-        `/v1/stores/${storeId(params?.store_id)}/social-accounts`,
+        `/v1/stores/${storeId(params?.store_id)}/social-connections`,
         options
       );
     },
     async connect(params, options) {
       const { store_id, ...payload } = params;
       return apiConfig.httpClient.post(
-        `/v1/stores/${storeId(store_id)}/social-accounts/oauth/connect`,
+        `/v1/stores/${storeId(store_id)}/social-connections/oauth/connect`,
         payload,
         options
       );
     },
     async getOAuthAttempt(params, options) {
       return apiConfig.httpClient.get(
-        `/v1/stores/${storeId(params.store_id)}/social-accounts/oauth/attempts/${params.attempt_id}`,
+        `/v1/stores/${storeId(params.store_id)}/social-connections/oauth/attempts/${params.attempt_id}`,
         options
       );
     },
     async selectDestination(params, options) {
       const { store_id, ...payload } = params;
       return apiConfig.httpClient.post(
-        `/v1/stores/${storeId(store_id)}/social-accounts/oauth/select-destination`,
+        `/v1/stores/${storeId(store_id)}/social-connections/oauth/select-destination`,
         payload,
         options
       );
     },
-    async deleteAccount(params, options) {
+    async deleteConnection(params, options) {
       return apiConfig.httpClient.delete(
-        `/v1/stores/${storeId(params.store_id)}/social-accounts/${params.id}`,
+        `/v1/stores/${storeId(params.store_id)}/social-connections/${params.id}`,
         options
       );
     },
@@ -2725,26 +3207,44 @@ var createWorkflowApi = (apiConfig) => {
         options
       );
     },
-    async getWorkflowAccounts(params, options) {
+    async getWorkflowEffects(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const { store_id: _, workflow_id, execution_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/workflows/${workflow_id}/executions/${execution_id}/effects`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    },
+    async getWorkflowEffect(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/workflows/${params.workflow_id}/executions/${params.execution_id}/effects/${params.effect_id}`,
+        options
+      );
+    },
+    async getWorkflowConnections(params, options) {
       const store_id = params?.store_id || apiConfig.storeId;
       return apiConfig.httpClient.get(
-        `/v1/stores/${store_id}/workflow-accounts`,
+        `/v1/stores/${store_id}/workflow-connections`,
         options
       );
     },
-    async getWorkflowAccountConnectUrl(params, options) {
+    async getWorkflowConnectionConnectUrl(params, options) {
       const { store_id, type, ...payload } = params;
       const target_store_id = store_id || apiConfig.storeId;
       return apiConfig.httpClient.post(
-        `/v1/stores/${target_store_id}/workflow-accounts/connect-url`,
+        `/v1/stores/${target_store_id}/workflow-connections/connect-url`,
         { ...payload, type, store_id: target_store_id },
         options
       );
     },
-    async deleteWorkflowAccount(params, options) {
+    async deleteWorkflowConnection(params, options) {
       const store_id = params.store_id || apiConfig.storeId;
       return apiConfig.httpClient.delete(
-        `/v1/stores/${store_id}/workflow-accounts/${params.id}`,
+        `/v1/stores/${store_id}/workflow-connections/${params.id}`,
         options
       );
     }
@@ -2788,27 +3288,105 @@ var createPlatformApi = (apiConfig) => {
 
 // src/api/shipping.ts
 var createShippingApi = (apiConfig) => {
+  const storeId = (value) => value || apiConfig.storeId;
   return {
+    async findFulfillmentOrders(params, options) {
+      const { store_id, order_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/fulfillment-orders`,
+        { ...options, params: queryParams }
+      );
+    },
+    async getFulfillmentOrder(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/fulfillment-orders/${params.fulfillment_order_id}`,
+        options
+      );
+    },
     async getRates(params, options) {
-      const { order_id, ...payload } = params;
+      const { store_id, order_id, ...payload } = params;
       return apiConfig.httpClient.post(
-        `/v1/stores/${apiConfig.storeId}/orders/${order_id}/shipping/rates`,
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipping/rates`,
         payload,
         options
       );
     },
-    async ship(params, options) {
-      const { order_id, ...payload } = params;
-      return apiConfig.httpClient.post(
-        `/v1/stores/${apiConfig.storeId}/orders/${order_id}/ship`,
+    async findShipments(params, options) {
+      const { store_id, order_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipments`,
+        { ...options, params: queryParams }
+      );
+    },
+    async getShipment(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}`,
+        options
+      );
+    },
+    async createShipment(params, options) {
+      const { store_id, order_id, ...payload } = params;
+      const response = await apiConfig.httpClient.post(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipments`,
         payload,
         options
       );
+      if (response.shipment_id !== params.shipment_id || response.shipment.id !== params.shipment_id) {
+        throw new Error("Shipping response did not match the requested shipment_id");
+      }
+      return response;
+    },
+    async retryShipment(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}/retry`,
+        {},
+        options
+      );
+    },
+    async requestRefund(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}/refunds`,
+        {},
+        options
+      );
+    },
+    async findRefunds(params, options) {
+      const { store_id, order_id, shipment_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipments/${shipment_id}/refunds`,
+        { ...options, params: queryParams }
+      );
+    },
+    async getRefund(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}/refunds/${params.refund_id}`,
+        options
+      );
+    },
+    async retryRefund(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}/refunds/${params.refund_id}/retry`,
+        {},
+        options
+      );
+    },
+    async findAdjustments(params, options) {
+      const { store_id, order_id, shipment_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipments/${shipment_id}/adjustments`,
+        { ...options, params: queryParams }
+      );
+    },
+    async findSettlements(params, options) {
+      const { store_id, order_id, shipment_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${storeId(store_id)}/orders/${order_id}/shipments/${shipment_id}/settlements`,
+        { ...options, params: queryParams }
+      );
     },
-    async refundLabel(params, options) {
-      const { order_id, shipment_id } = params;
+    async retrySettlement(params, options) {
       return apiConfig.httpClient.post(
-        `/v1/stores/${apiConfig.storeId}/orders/${order_id}/shipments/${shipment_id}/label/refund`,
+        `/v1/stores/${storeId(params.store_id)}/orders/${params.order_id}/shipments/${params.shipment_id}/settlements/${params.settlement_id}/retry`,
         {},
         options
       );
@@ -3117,155 +3695,230 @@ var createExperimentsApi = (apiConfig) => {
 };
 
 // src/utils/blocks.ts
-function getBlockLabel(block) {
-  if (!block) return "";
-  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) ?? "";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function formatBlockValue(block) {
-  if (!block || block.value === null || block.value === void 0) return "";
-  const value = block.value;
-  switch (block.type) {
-    case "boolean":
-      return value ? "Yes" : "No";
-    case "number":
-      if (block.properties?.variant === "DATE" || block.properties?.variant === "DATE_TIME") {
-        return new Date(value).toLocaleDateString();
-      }
-      return String(value);
-    case "media":
-      if (value && typeof value === "object") {
-        return value.mime_type ? value.name || value.id : value.title || value.name || value.id;
-      }
-      return String(value);
-    default:
-      return String(value);
-  }
+function isBlock(value) {
+  return isRecord2(value) && typeof value.key === "string" && typeof value.type === "string";
 }
-function prepareBlocksForSubmission(formData, blockTypes) {
-  return Object.keys(formData).filter((key) => formData[key] !== null && formData[key] !== void 0).map((key) => ({
-    key,
-    value: (blockTypes?.[key] || "text") === "array" && !Array.isArray(formData[key]) ? [formData[key]] : formData[key]
-  }));
+function recordFromBlocks(values, locale) {
+  const result = {};
+  for (const value of values) {
+    if (!isBlock(value)) continue;
+    result[value.key] = unwrapBlock(value, locale);
+  }
+  return result;
 }
-function extractBlockValues(blocks) {
-  const values = {};
-  blocks.forEach((block) => {
-    values[block.key] = block.value ?? null;
-  });
-  return values;
+function localizedValue(value, locale) {
+  if (typeof value === "string") return value;
+  if (!isRecord2(value)) return "";
+  const selected = value[locale] ?? value.en;
+  return typeof selected === "string" ? selected : "";
 }
-var getBlockValue = (entry, blockKey) => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  return block?.value ?? null;
-};
-var getBlockTextValue = (block, locale = "en") => {
-  if (!block || block.value === null || block.value === void 0) return "";
-  const blockType = block.type;
-  if (blockType === "localized_text" || blockType === "markdown") {
-    if (typeof block.value === "object" && block.value !== null) {
-      return block.value[locale] ?? block.value["en"] ?? "";
-    }
-  }
-  if (typeof block.value === "string") return block.value;
-  return String(block.value ?? "");
-};
-var getBlockValues = (entry, blockKey) => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block) return [];
-  if (block.type === "array" && Array.isArray(block.value)) {
-    return block.value;
+function unwrapBlock(value, locale) {
+  if (!isBlock(value)) return value;
+  if (value.type === "localized_text" || value.type === "markdown") {
+    return localizedValue(value.value, locale);
   }
-  return [];
-};
-function unwrapBlock(block, locale) {
-  if (!block?.type || block.value === void 0) return block;
-  const blockType = block.type;
-  if (blockType === "array") {
-    return block.value.map((obj) => {
-      const parsed = {};
-      for (const [k, v] of Object.entries(obj)) {
-        parsed[k] = unwrapBlock(v, locale);
+  if (value.type === "array") {
+    if (!Array.isArray(value.value)) return [];
+    return value.value.map((item) => {
+      if (isBlock(item)) return unwrapBlock(item, locale);
+      if (isRecord2(item) && Array.isArray(item.value)) {
+        return recordFromBlocks(item.value, locale);
       }
-      return parsed;
+      if (!isRecord2(item)) return item;
+      return Object.fromEntries(
+        Object.entries(item).map(([key, nested]) => [key, unwrapBlock(nested, locale)])
+      );
     });
   }
-  if (blockType === "object") {
-    const parsed = {};
-    for (const [k, v] of Object.entries(block.value || {})) {
-      parsed[k] = unwrapBlock(v, locale);
-    }
-    return parsed;
+  if (value.type === "object") {
+    if (Array.isArray(value.value)) return recordFromBlocks(value.value, locale);
+    if (!isRecord2(value.value)) return {};
+    return Object.fromEntries(
+      Object.entries(value.value).map(([key, nested]) => [key, unwrapBlock(nested, locale)])
+    );
   }
-  if (blockType === "localized_text" || blockType === "markdown") {
-    return block.value?.[locale];
+  return value.value;
+}
+function blockContentArray(values, locale) {
+  const blocks = values.filter(isBlock);
+  if (blocks.length === 0) return [];
+  if (blocks.every((block) => block.key === blocks[0].key)) {
+    return blocks.map((block) => blockContentValue(block, locale));
   }
-  return block.value;
+  return Object.fromEntries(
+    blocks.map((block) => [block.key, blockContentValue(block, locale)])
+  );
 }
-var getBlockObjectValues = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block || block.type !== "array" || !Array.isArray(block.value)) return [];
-  return block.value.map((obj) => {
-    if (!obj?.value || !Array.isArray(obj.value)) return {};
-    return obj.value.reduce((acc, current) => {
-      acc[current.key] = unwrapBlock(current, locale);
-      return acc;
-    }, {});
-  });
-};
-var getBlockFromArray = (entry, blockKey, locale = "en") => {
-  const block = entry?.blocks?.find((f) => f.key === blockKey);
-  if (!block) return {};
-  if (block.type === "array" && Array.isArray(block.value)) {
-    return block.value.reduce((acc, current) => {
-      acc[current.key] = unwrapBlock(current, locale);
-      return acc;
-    }, {});
+function blockContentValue(block, locale) {
+  if (block.type === "localized_text" || block.type === "markdown") {
+    return localizedValue(block.value, locale);
+  }
+  if (block.type === "media") return block.value ?? null;
+  if (block.type === "array") {
+    return Array.isArray(block.value) ? blockContentArray(block.value, locale) : [];
   }
-  if (block.type === "object" && block.value && typeof block.value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(block.value)) {
-      result[k] = unwrapBlock(v, locale);
+  if (block.type === "object") {
+    if (Array.isArray(block.value)) return blockContentArray(block.value, locale);
+    if (!isRecord2(block.value)) return {};
+    return Object.fromEntries(
+      Object.entries(block.value).map(([key, value]) => [
+        key,
+        isBlock(value) ? blockContentValue(value, locale) : value
+      ])
+    );
+  }
+  return block.value;
+}
+function findBlock(entry, key) {
+  return entry?.blocks?.find((block) => block.key === key);
+}
+function getBlockLabel(block) {
+  return block?.key.replace(/_/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()) ?? "";
+}
+function formatBlockValue(block) {
+  if (block?.value === null || block?.value === void 0) return "";
+  if (block.type === "boolean") return block.value ? "Yes" : "No";
+  if (block.type === "number") {
+    const properties = isRecord2(block.properties) ? block.properties : {};
+    if (properties.variant === "DATE" || properties.variant === "DATE_TIME") {
+      return new Date(Number(block.value)).toLocaleDateString();
     }
-    return result;
   }
-  return { [block.key]: unwrapBlock(block, locale) };
-};
-var getImageUrl = (imageBlock, isBlock = true) => {
-  if (!imageBlock) return null;
-  if (imageBlock.type === "media") {
-    const mediaValue = imageBlock.value;
-    return mediaValue?.resolutions?.original?.url || mediaValue?.url || null;
+  if (block.type === "media" && isRecord2(block.value)) {
+    const label = block.value.name ?? block.value.title ?? block.value.id;
+    return typeof label === "string" ? label : "";
   }
-  if (isBlock) {
-    if (typeof imageBlock === "string") return imageBlock;
-    if (imageBlock.url) return imageBlock.url;
+  return String(block.value);
+}
+function prepareBlocksForSubmission(formData, blockTypes = {}) {
+  return Object.entries(formData).filter(([, value]) => value !== null && value !== void 0).map(([key, value]) => ({
+    key,
+    value: blockTypes[key] === "array" && !Array.isArray(value) ? [value] : value
+  }));
+}
+function extractBlockValues(blocks) {
+  return Object.fromEntries(blocks.map((block) => [block.key, block.value ?? null]));
+}
+function getBlockValue(entry, key) {
+  return findBlock(entry, key)?.value ?? null;
+}
+function getBlockTextValue(block, locale = "en") {
+  if (!block || block.value === null || block.value === void 0) return "";
+  if (block.type === "localized_text" || block.type === "markdown") {
+    return localizedValue(block.value, locale);
   }
-  return imageBlock.resolutions?.original?.url || null;
-};
+  return typeof block.value === "string" ? block.value : String(block.value);
+}
+function getBlockContentValue(entry, key, locale = "en") {
+  const block = findBlock(entry, key);
+  return block ? blockContentValue(block, locale) : null;
+}
+function getBlockValues(entry, key) {
+  const block = findBlock(entry, key);
+  return block?.type === "array" && Array.isArray(block.value) ? block.value : [];
+}
+function getBlockObjectValues(entry, key, locale = "en") {
+  return getBlockValues(entry, key).map((value) => {
+    if (isRecord2(value) && Array.isArray(value.value)) {
+      return recordFromBlocks(value.value, locale);
+    }
+    return isRecord2(value) ? Object.fromEntries(
+      Object.entries(value).map(([field, nested]) => [field, unwrapBlock(nested, locale)])
+    ) : {};
+  });
+}
+function getBlockFromArray(entry, key, locale = "en") {
+  const block = findBlock(entry, key);
+  if (!block) return {};
+  const value = unwrapBlock(block, locale);
+  if (isRecord2(value)) return value;
+  if (Array.isArray(block.value)) return recordFromBlocks(block.value, locale);
+  return { [block.key]: value };
+}
+function nestedUrl(value) {
+  const resolutions = isRecord2(value.resolutions) ? value.resolutions : null;
+  const original = resolutions && isRecord2(resolutions.original) ? resolutions.original : null;
+  if (typeof original?.url === "string") return original.url;
+  return typeof value.url === "string" ? value.url : null;
+}
+function getImageUrl(value, isBlock2 = true) {
+  if (typeof value === "string") return value;
+  if (!isRecord2(value)) return null;
+  if (value.type === "media" && isRecord2(value.value)) return nestedUrl(value.value);
+  if (isBlock2 && typeof value.url === "string") return value.url;
+  return nestedUrl(value);
+}
 
 // src/utils/price.ts
+var SUPPORTED_STORE_CURRENCIES = Object.freeze([
+  "USD",
+  "EUR",
+  "GBP",
+  "JPY",
+  "CNY",
+  "CHF",
+  "AUD",
+  "CAD",
+  "HKD",
+  "SGD",
+  "NZD",
+  "KRW",
+  "SEK",
+  "NOK",
+  "DKK",
+  "INR",
+  "MXN",
+  "BRL",
+  "ZAR",
+  "RUB",
+  "TRY",
+  "PLN",
+  "THB",
+  "IDR",
+  "MYR",
+  "PHP",
+  "CZK",
+  "ILS",
+  "AED",
+  "SAR",
+  "HUF",
+  "RON",
+  "BGN",
+  "HRK",
+  "BAM",
+  "RSD",
+  "MKD",
+  "ALL"
+]);
+var SUPPORTED_STORE_CURRENCY_SET = Object.freeze(
+  new Set(SUPPORTED_STORE_CURRENCIES)
+);
+var ZERO_MINOR_UNIT_STORE_CURRENCIES = Object.freeze(
+  /* @__PURE__ */ new Set(["JPY", "KRW"])
+);
 function formatCurrency(amount, currencyCode, locale = "en") {
-  if (!currencyCode) return "";
+  const normalized = currencyCode.trim().toUpperCase();
+  if (!normalized) return "";
+  const minorUnits = getCurrencyMinorUnits(normalized);
   return new Intl.NumberFormat(locale, {
     style: "currency",
-    currency: currencyCode.toUpperCase()
+    currency: normalized,
+    minimumFractionDigits: minorUnits,
+    maximumFractionDigits: minorUnits
   }).format(amount);
 }
-function getMinorUnits(currency) {
-  try {
-    const formatter = new Intl.NumberFormat("en", {
-      style: "currency",
-      currency: currency.toUpperCase()
-    });
-    const parts = formatter.formatToParts(1.11);
-    const fractionPart = parts.find((p) => p.type === "fraction");
-    return fractionPart?.value.length ?? 2;
-  } catch {
-    return 2;
+function getCurrencyMinorUnits(currency) {
+  const normalized = currency.trim().toUpperCase();
+  if (!SUPPORTED_STORE_CURRENCY_SET.has(normalized)) {
+    throw new RangeError(`Unsupported currency '${currency}'`);
   }
+  return ZERO_MINOR_UNIT_STORE_CURRENCIES.has(normalized) ? 0 : 2;
 }
 function convertToMajor(minorAmount, currency) {
-  const units = getMinorUnits(currency);
+  const units = getCurrencyMinorUnits(currency);
   return minorAmount / Math.pow(10, units);
 }
 function getCurrencySymbol(currency) {
@@ -3287,22 +3940,24 @@ function getCurrencyName(currency) {
   }
 }
 function formatMinor(amountMinor, currency) {
-  if (!currency) return "";
+  if (!Number.isSafeInteger(amountMinor)) {
+    throw new RangeError("Minor-unit amount must be a safe integer");
+  }
   return formatCurrency(convertToMajor(amountMinor, currency), currency);
 }
 function formatPayment(payment) {
   return formatMinor(payment.total, payment.currency);
 }
 function formatPrice(prices, marketId) {
-  if (!prices || prices.length === 0) return "";
-  const price = marketId ? prices.find((p) => p.market === marketId) || prices[0] : prices[0];
-  if (!price) return "";
+  if (!prices || prices.length === 0 || !marketId) return "";
+  const price = prices.find((p) => p.market === marketId);
+  if (!price || !Number.isSafeInteger(price.amount) || price.amount < 0 || !price.currency) return "";
   return formatMinor(price.amount, price.currency);
 }
 function getPriceAmount(prices, marketId) {
-  if (!prices || prices.length === 0) return 0;
-  const price = prices.find((p) => p.market === marketId) || prices[0];
-  return price?.amount || 0;
+  if (!prices || prices.length === 0 || !marketId) return null;
+  const price = prices.find((p) => p.market === marketId);
+  return price && Number.isSafeInteger(price.amount) && price.amount >= 0 ? price.amount : null;
 }
 
 // src/utils/validation.ts
@@ -3403,6 +4058,7 @@ function formatDate(date, locale) {
 async function fetchSvgContent(mediaObject) {
   if (!mediaObject) return null;
   const svgUrl = getImageUrl(mediaObject, false);
+  if (!svgUrl) return null;
   try {
     const response = await fetch(svgUrl);
     if (!response.ok) {
@@ -3493,7 +4149,7 @@ function getFirstAvailableFCId(variant, quantity = 1) {
 }
 
 // src/index.ts
-var SDK_VERSION = "0.9.11";
+var SDK_VERSION = "0.9.16";
 var SUPPORTED_FRAMEWORKS = [
   "astro",
   "react",
@@ -3503,9 +4159,10 @@ var SUPPORTED_FRAMEWORKS = [
 ];
 function createUtilitySurface(apiConfig) {
   return {
-    getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock),
+    getImageUrl: (imageBlock, isBlock2 = true) => getImageUrl(imageBlock, isBlock2),
     getBlockValue,
     getBlockTextValue,
+    getBlockContentValue,
     getBlockValues,
     getBlockLabel,
     getBlockObjectValues,
@@ -3656,9 +4313,11 @@ function createAdmin(config) {
     trigger: workflowApi.triggerWorkflow,
     getExecutions: workflowApi.getWorkflowExecutions,
     getExecution: workflowApi.getWorkflowExecution,
-    listAccounts: workflowApi.getWorkflowAccounts,
-    getAccountConnectUrl: workflowApi.getWorkflowAccountConnectUrl,
-    deleteAccount: workflowApi.deleteWorkflowAccount
+    listEffects: workflowApi.getWorkflowEffects,
+    getEffect: workflowApi.getWorkflowEffect,
+    listConnections: workflowApi.getWorkflowConnections,
+    getConnectionConnectUrl: workflowApi.getWorkflowConnectionConnectUrl,
+    deleteConnection: workflowApi.deleteWorkflowConnection
   };
   const formApi = createFormApi(apiConfig);
   const taxonomyApi = createTaxonomyApi(apiConfig);
@@ -3671,22 +4330,43 @@ function createAdmin(config) {
       delete: accountApi.deleteAccount,
       getMe: accountApi.getMe,
       search: accountApi.searchAccounts,
+      apiToken: {
+        list: accountApi.listApiTokens,
+        create: accountApi.createApiToken,
+        update: accountApi.updateApiToken,
+        revoke: accountApi.revokeApiToken
+      },
+      session: {
+        list: accountApi.listSessions,
+        revoke: accountApi.revokeSession
+      },
       auth: authApi
     },
     store: {
       create: storeApi.createStore,
       update: storeApi.updateStore,
-      delete: storeApi.deleteStore,
       get: storeApi.getStore,
       find: storeApi.getStores,
       subscription: {
+        get: storeApi.getSubscription,
         getPlans: storeApi.getSubscriptionPlans,
-        subscribe: storeApi.subscribe,
+        action: {
+          create: storeApi.createSubscriptionAction,
+          find: storeApi.findSubscriptionActions,
+          get: storeApi.getSubscriptionAction,
+          retry: storeApi.retrySubscriptionAction,
+          effect: {
+            find: storeApi.findSubscriptionActionEffects,
+            get: storeApi.getSubscriptionActionEffect
+          }
+        },
         createPortalSession: storeApi.createPortalSession
       },
       member: {
         add: storeApi.addMember,
         invite: storeApi.inviteUser,
+        find: storeApi.findMembers,
+        findOwn: storeApi.findOwnMemberships,
         remove: storeApi.removeMember
       },
       buildHook: {
@@ -3703,10 +4383,7 @@ function createAdmin(config) {
         delete: storeApi.deleteWebhook
       },
       config: {
-        get: storeApi.getStoreConfig
-      },
-      media: {
-        find: storeApi.getStoreMedia
+        getPayment: storeApi.getPaymentConfig
       },
       location: locationApi,
       market: marketApi,
@@ -3715,22 +4392,21 @@ function createAdmin(config) {
     media: createMediaApi(apiConfig),
     notification: {
       email: {
-        trackOpen: notificationApi.trackEmailOpen
-      },
-      trigger: {
-        send: notificationApi.trigger
+        send: notificationApi.sendEmail,
+        getDelivery: notificationApi.getEmailDelivery,
+        retryDelivery: notificationApi.retryEmailDelivery
       },
       mailbox: crmApi.mailbox
     },
     platform: platformApi,
     social: {
-      account: {
+      connection: {
         getCapabilities: socialApi.getCapabilities,
-        list: socialApi.listAccounts,
+        list: socialApi.listConnections,
         connect: socialApi.connect,
         getOAuthAttempt: socialApi.getOAuthAttempt,
         selectDestination: socialApi.selectDestination,
-        delete: socialApi.deleteAccount
+        delete: socialApi.deleteConnection
       },
       publication: {
         create: socialApi.createPublication,
@@ -3746,7 +4422,16 @@ function createAdmin(config) {
         syncCommentThread: socialApi.syncPublicationCommentThread,
         findComments: socialApi.findPublicationComments,
         classifyComments: socialApi.classifyPublicationComments,
-        replyToComment: socialApi.replyToPublicationComment,
+        commentReply: {
+          create: socialApi.createCommentReply,
+          list: socialApi.listCommentReplies,
+          get: socialApi.getCommentReply,
+          retry: socialApi.retryCommentReply
+        },
+        effect: {
+          list: socialApi.listPublicationEffects,
+          get: socialApi.getPublicationEffect
+        },
         getMetrics: socialApi.getPublicationMetrics,
         syncMetrics: socialApi.syncPublicationMetrics,
         syncEngagement: socialApi.syncEngagement
@@ -3808,11 +4493,43 @@ function createAdmin(config) {
         get: eshopApi.getOrder,
         find: eshopApi.getOrders,
         getQuote: eshopApi.getQuote,
-        processRefund: eshopApi.processRefund,
+        createRefund: eshopApi.createRefund,
+        getRefund: eshopApi.getRefund,
+        getRefunds: eshopApi.getRefunds,
+        retryRefund: eshopApi.retryRefund,
+        getPayment: eshopApi.getPayment,
+        retryPaymentTransaction: eshopApi.retryPaymentTransaction,
+        getPaymentTransactions: eshopApi.getPaymentTransactions,
+        getPaymentTransaction: eshopApi.getPaymentTransaction,
+        findDigitalAccess: eshopApi.findDigitalAccess,
+        getDigitalAccess: eshopApi.getDigitalAccess,
         downloadDigitalAccess: eshopApi.downloadDigitalAccess,
-        getShippingRates: shippingApi.getRates,
-        ship: shippingApi.ship,
-        refundShippingLabel: shippingApi.refundLabel
+        activateDigitalAccess: eshopApi.activateDigitalAccess,
+        revokeDigitalAccess: eshopApi.revokeDigitalAccess
+      },
+      shipment: {
+        getRates: shippingApi.getRates,
+        create: shippingApi.createShipment,
+        get: shippingApi.getShipment,
+        find: shippingApi.findShipments,
+        retry: shippingApi.retryShipment,
+        fulfillment: {
+          find: shippingApi.findFulfillmentOrders,
+          get: shippingApi.getFulfillmentOrder
+        },
+        refund: {
+          request: shippingApi.requestRefund,
+          get: shippingApi.getRefund,
+          find: shippingApi.findRefunds,
+          retry: shippingApi.retryRefund
+        },
+        adjustment: {
+          find: shippingApi.findAdjustments
+        },
+        settlement: {
+          find: shippingApi.findSettlements,
+          retry: shippingApi.retrySettlement
+        }
       },
       cart: {
         create: eshopApi.createCart,
@@ -3854,8 +4571,9 @@ function createAdmin(config) {
         update: crmApi.update,
         merge: crmApi.merge,
         import: crmApi.import,
-        revokeToken: crmApi.revokeToken,
-        revokeAllTokens: crmApi.revokeAllTokens
+        findSessions: crmApi.findSessions,
+        revokeSession: crmApi.revokeSession,
+        revokeAllSessions: crmApi.revokeAllSessions
       },
       contactList: {
         create: crmApi.contactList.create,
@@ -3867,7 +4585,14 @@ function createAdmin(config) {
         addMember: crmApi.contactList.members.add,
         updateMember: crmApi.contactList.members.update,
         removeMember: crmApi.contactList.members.remove,
-        findMembers: crmApi.contactList.members.find
+        findMembers: crmApi.contactList.members.find,
+        plans: crmApi.contactList.plans,
+        memberships: {
+          refund: crmApi.contactList.memberships.refund,
+          paymentAttempts: crmApi.contactList.memberships.paymentAttempts,
+          refunds: crmApi.contactList.memberships.refunds,
+          cancellations: crmApi.contactList.memberships.cancellations
+        }
       },
       action: crmApi.action
     },
@@ -3941,29 +4666,50 @@ function createAdmin(config) {
   };
   return sdk;
 }
-var CONTACT_STORAGE_KEY = "arky_contact_session";
-function readContactSession() {
+function defaultStorefrontSessionStorage() {
   if (typeof window === "undefined") return null;
   try {
-    const raw = localStorage.getItem(CONTACT_STORAGE_KEY);
-    return raw ? JSON.parse(raw) : null;
+    return window.localStorage;
   } catch {
     return null;
   }
 }
-function writeContactSession(s) {
-  if (typeof window === "undefined") return;
-  if (s) {
-    localStorage.setItem(CONTACT_STORAGE_KEY, JSON.stringify(s));
-  } else {
-    localStorage.removeItem(CONTACT_STORAGE_KEY);
-  }
+function storefrontSessionStorageKey(baseUrl, storeId) {
+  const normalizedBaseUrl = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
+  return `arky_contact_session:${encodeURIComponent(normalizedBaseUrl)}:${encodeURIComponent(storeId)}`;
 }
-function createStorefront(config) {
+function createStorefrontClient(config) {
   const locale = config.locale || "en";
   const initialMarket = config.market || "";
   const listeners = /* @__PURE__ */ new Set();
   let bareIdentifyPromise = null;
+  let identityTail = Promise.resolve();
+  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage();
+  let memorySession = null;
+  function readContactSession() {
+    if (!sessionStorage) return memorySession;
+    try {
+      const raw = sessionStorage.getItem(
+        storefrontSessionStorageKey(config.baseUrl, config.storeId)
+      );
+      return raw ? JSON.parse(raw) : null;
+    } catch {
+      return memorySession;
+    }
+  }
+  function writeContactSession(session) {
+    memorySession = session;
+    if (!sessionStorage) return;
+    const key = storefrontSessionStorageKey(config.baseUrl, config.storeId);
+    try {
+      if (session) {
+        sessionStorage.setItem(key, JSON.stringify(session));
+      } else {
+        sessionStorage.removeItem(key);
+      }
+    } catch {
+    }
+  }
   function toPublic(s) {
     return s ? { contact: s.contact, store: s.store, market: s.market } : null;
   }
@@ -4019,19 +4765,23 @@ function createStorefront(config) {
   const contactApi = storefrontApi.crm.contact;
   function identify(params) {
     if (params?.market !== void 0) apiConfig.market = params.market;
+    const market = apiConfig.market;
     const isBareCall = !params?.email && !params?.verify;
     if (isBareCall && bareIdentifyPromise) return bareIdentifyPromise;
-    const promise = (async () => {
+    const run = async () => {
       try {
-        const result = await contactApi.identify({
-          market: apiConfig.market,
-          email: params?.email,
-          verify: params?.verify
-        });
+        const result = await (params?.verify ? contactApi.requestCode({
+          market,
+          email: params.email
+        }) : contactApi.identify({
+          market,
+          email: params?.email
+        }));
         return {
           contact: result.contact,
           store: result.store,
-          market: result.market
+          market: result.market,
+          verification_challenge: result.verification_challenge
         };
       } catch (err) {
         const e = err;
@@ -4039,21 +4789,34 @@ function createStorefront(config) {
         if (isBareCall && status === 401) {
           updateSession(() => null);
           const result = await contactApi.identify({
-            market: apiConfig.market
+            market
           });
           return {
             contact: result.contact,
             store: result.store,
-            market: result.market
+            market: result.market,
+            verification_challenge: result.verification_challenge
           };
         }
         throw err;
       }
-    })().catch((err) => {
-      if (isBareCall) bareIdentifyPromise = null;
-      throw err;
-    });
-    if (isBareCall) bareIdentifyPromise = promise;
+    };
+    const promise = identityTail.then(run);
+    identityTail = promise.then(
+      () => void 0,
+      () => void 0
+    );
+    if (isBareCall) {
+      bareIdentifyPromise = promise;
+      void promise.then(
+        () => {
+          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+        },
+        () => {
+          if (bareIdentifyPromise === promise) bareIdentifyPromise = null;
+        }
+      );
+    }
     return promise;
   }
   async function verify(params) {
@@ -4096,17 +4859,12 @@ function createStorefront(config) {
       };
     },
     store: storefrontApi.store,
-    cart: createCartController(storefrontApi.eshop.cart),
     cms: storefrontApi.cms,
     eshop: storefrontApi.eshop,
     crm: storefrontApi.crm,
     action: storefrontApi.action,
     experiments: storefrontApi.experiments,
     support: createStorefrontSupportApi(apiConfig),
-    setStoreId: (storeId) => {
-      apiConfig.storeId = storeId;
-      bareIdentifyPromise = null;
-    },
     getStoreId: () => apiConfig.storeId,
     setMarket: (key) => {
       apiConfig.market = key;
@@ -4120,6 +4878,26 @@ function createStorefront(config) {
     utils: createUtilitySurface(apiConfig)
   };
 }
+function createStorefront(config) {
+  const sessionStorage = config.sessionStorage || defaultStorefrontSessionStorage() || void 0;
+  const scopedConfig = {
+    ...config,
+    sessionStorage
+  };
+  const client = createStorefrontClient(scopedConfig);
+  Object.defineProperty(client, "forStore", {
+    enumerable: true,
+    configurable: false,
+    writable: false,
+    value: (storeId) => createStorefront({
+      ...scopedConfig,
+      storeId,
+      market: client.getMarket(),
+      locale: client.getLocale()
+    })
+  });
+  return client;
+}
 
 export { COMMON_ACTION_KEYS, PaymentMethodType, SDK_VERSION, SUPPORTED_FRAMEWORKS, createAdmin, createCartController, createStorefront };
 //# sourceMappingURL=index.js.map