arky-sdk 0.7.92 → 0.7.95

package/dist/admin.js

@@ -0,0 +1,2322 @@
+// src/utils/blocks.ts
+function getBlockLabel(block) {
+  if (!block) return "";
+  return block.key?.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()) ?? "";
+}
+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 "relationship_entry":
+    case "relationship_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 prepareBlocksForSubmission(formData, blockTypes) {
+  return Object.keys(formData).filter((key) => formData[key] !== null && formData[key] !== void 0).map((key) => ({
+    key,
+    value: blockTypes?.[key] === "list" && !Array.isArray(formData[key]) ? [formData[key]] : formData[key]
+  }));
+}
+function extractBlockValues(blocks) {
+  const values = {};
+  blocks.forEach((block) => {
+    values[block.key] = block.value ?? null;
+  });
+  return values;
+}
+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 "";
+  if (block.type === "localized_text" || block.type === "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 === "list" && Array.isArray(block.value)) {
+    return block.value;
+  }
+  return [];
+};
+function unwrapBlock(block, locale) {
+  if (!block?.type || block.value === void 0) return block;
+  if (block.type === "list") {
+    return block.value.map((obj) => {
+      const parsed = {};
+      for (const [k, v] of Object.entries(obj)) {
+        parsed[k] = unwrapBlock(v, locale);
+      }
+      return parsed;
+    });
+  }
+  if (block.type === "map") {
+    const parsed = {};
+    for (const [k, v] of Object.entries(block.value || {})) {
+      parsed[k] = unwrapBlock(v, locale);
+    }
+    return parsed;
+  }
+  if (block.type === "localized_text" || block.type === "markdown") {
+    return block.value?.[locale];
+  }
+  return block.value;
+}
+var getBlockObjectValues = (entry, blockKey, locale = "en") => {
+  const block = entry?.blocks?.find((f) => f.key === blockKey);
+  if (!block || block.type !== "list" || !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 === "list" && Array.isArray(block.value)) {
+    return block.value.reduce((acc, current) => {
+      acc[current.key] = unwrapBlock(current, locale);
+      return acc;
+    }, {});
+  }
+  if (block.type === "map" && block.value && typeof block.value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(block.value)) {
+      result[k] = unwrapBlock(v, locale);
+    }
+    return result;
+  }
+  return { [block.key]: unwrapBlock(block, locale) };
+};
+var getImageUrl = (imageBlock, isBlock = true) => {
+  if (!imageBlock) return null;
+  if (imageBlock.type === "relationship_media") {
+    const mediaValue = imageBlock.value;
+    return mediaValue?.resolutions?.original?.url || mediaValue?.url || null;
+  }
+  if (isBlock) {
+    if (typeof imageBlock === "string") return imageBlock;
+    if (imageBlock.url) return imageBlock.url;
+  }
+  return imageBlock.resolutions?.original?.url || null;
+};
+
+// src/utils/errors.ts
+var convertServerErrorToRequestError = (serverError, renameRules) => {
+  const validationErrors = serverError?.validationErrors ?? [];
+  return {
+    ...serverError,
+    validationErrors: validationErrors.map((validationError) => {
+      const field = validationError.field;
+      return {
+        field,
+        error: validationError.error || "GENERAL.VALIDATION_ERROR"
+      };
+    })
+  };
+};
+
+// 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)}`);
+    }
+  });
+  return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+}
+
+// src/services/createHttpClient.ts
+var STORAGE_KEYS = {
+  access_token: "arky_token",
+  refresh_token: "arky_refresh",
+  access_expires_at: "arky_expires_at"
+};
+function defaultGetToken() {
+  if (typeof window === "undefined") return { access_token: "" };
+  return {
+    access_token: localStorage.getItem(STORAGE_KEYS.access_token) || "",
+    refresh_token: localStorage.getItem(STORAGE_KEYS.refresh_token) || "",
+    access_expires_at: parseInt(localStorage.getItem(STORAGE_KEYS.access_expires_at) || "0", 10)
+  };
+}
+function defaultSetToken(tokens) {
+  if (typeof window === "undefined") return;
+  if (tokens.access_token) {
+    localStorage.setItem(STORAGE_KEYS.access_token, tokens.access_token);
+    localStorage.setItem(STORAGE_KEYS.refresh_token, tokens.refresh_token || "");
+    localStorage.setItem(STORAGE_KEYS.access_expires_at, (tokens.access_expires_at || 0).toString());
+  } else {
+    Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+  }
+}
+function defaultLogout() {
+  if (typeof window === "undefined") return;
+  Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+}
+function defaultIsAuthenticated() {
+  if (typeof window === "undefined") return false;
+  const token = localStorage.getItem(STORAGE_KEYS.access_token) || "";
+  return token.startsWith("customer_") || token.startsWith("account_");
+}
+function createHttpClient(cfg) {
+  const getToken = cfg.getToken || defaultGetToken;
+  const setToken = cfg.setToken || defaultSetToken;
+  const logout = cfg.logout || defaultLogout;
+  let refreshPromise = null;
+  function getRefreshEndpoint() {
+    const refreshPath = typeof cfg.refreshPath === "function" ? cfg.refreshPath() : cfg.refreshPath || "/v1/auth/refresh";
+    return `${cfg.baseUrl}${refreshPath}`;
+  }
+  async function ensureFreshToken() {
+    if (refreshPromise) {
+      return refreshPromise;
+    }
+    refreshPromise = (async () => {
+      const { refresh_token } = await getToken();
+      if (!refresh_token) {
+        logout();
+        const err = new Error("No refresh token available");
+        err.name = "ApiError";
+        err.statusCode = 401;
+        throw err;
+      }
+      const refRes = await fetch(getRefreshEndpoint(), {
+        method: "POST",
+        headers: { Accept: "application/json", "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token })
+      });
+      if (!refRes.ok) {
+        logout();
+        const err = new Error("Token refresh failed");
+        err.name = "ApiError";
+        err.statusCode = 401;
+        throw err;
+      }
+      const data = await refRes.json();
+      setToken(data);
+    })().finally(() => {
+      refreshPromise = null;
+    });
+    return refreshPromise;
+  }
+  async function request(method, path, body, options) {
+    if (options?.transformRequest) {
+      body = options.transformRequest(body);
+    }
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...options?.headers || {}
+    };
+    let { access_token, access_expires_at } = await getToken();
+    const nowSec = Date.now() / 1e3;
+    if (access_expires_at && nowSec > access_expires_at) {
+      await ensureFreshToken();
+      const tokens = await getToken();
+      access_token = tokens.access_token;
+    }
+    if (access_token) {
+      headers["Authorization"] = `Bearer ${access_token}`;
+    }
+    const finalPath = options?.params ? path + buildQueryString(options.params) : path;
+    const fetchOpts = { method, headers };
+    if (!["GET", "DELETE"].includes(method) && body !== void 0) {
+      fetchOpts.body = JSON.stringify(body);
+    }
+    const fullUrl = `${cfg.baseUrl}${finalPath}`;
+    let res;
+    let data;
+    const startedAt = Date.now();
+    try {
+      res = await fetch(fullUrl, fetchOpts);
+    } catch (error) {
+      const err = new Error(error instanceof Error ? error.message : "Network request failed");
+      err.name = "NetworkError";
+      err.method = method;
+      err.url = fullUrl;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({ error: err, method, url: fullUrl, aborted: false })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (res.status === 401 && !options?.["_retried"]) {
+      try {
+        await ensureFreshToken();
+        const tokens = await getToken();
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+        fetchOpts.headers = headers;
+        return request(method, path, body, { ...options, _retried: true });
+      } catch (refreshError) {
+        throw refreshError;
+      }
+    }
+    try {
+      const contentLength = res.headers.get("content-length");
+      const contentType = res.headers.get("content-type");
+      if (res.status === 204 || contentLength === "0" || !contentType?.includes("application/json")) {
+        data = {};
+      } else {
+        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;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({ error: err, method, url: fullUrl, status: res.status })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (!res.ok) {
+      const serverErr = data;
+      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;
+      if (options?.onError && method !== "GET") {
+        Promise.resolve(
+          options.onError({
+            error: err,
+            method,
+            url: fullUrl,
+            status: res.status,
+            response: serverErr,
+            request_id: requestId || null,
+            duration_ms: Date.now() - startedAt
+          })
+        ).catch(() => {
+        });
+      }
+      throw err;
+    }
+    if (options?.onSuccess && method !== "GET") {
+      const requestId = res.headers.get("x-request-id") || res.headers.get("request-id");
+      Promise.resolve(
+        options.onSuccess({
+          data,
+          method,
+          url: fullUrl,
+          status: res.status,
+          request_id: requestId || null,
+          duration_ms: Date.now() - startedAt
+        })
+      ).catch(() => {
+      });
+    }
+    return data;
+  }
+  return {
+    get: (path, opts) => request("GET", path, void 0, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    delete: (path, opts) => request("DELETE", path, void 0, opts)
+  };
+}
+
+// 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
+        }
+      });
+    }
+  };
+};
+
+// src/api/auth.ts
+var createAuthApi = (apiConfig) => {
+  return {
+    async code(params, options) {
+      return apiConfig.httpClient.post("/v1/auth/code", params, options);
+    },
+    async verify(params, options) {
+      const result = await apiConfig.httpClient.post("/v1/auth/verify", params, options);
+      if (result?.access_token) {
+        apiConfig.setToken({ ...result, email: params.email, is_verified: true });
+      }
+      return result;
+    },
+    async refresh(params, options) {
+      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);
+    },
+    async storeVerify(storeId, params, options) {
+      const result = await apiConfig.httpClient.post(`/v1/stores/${storeId}/auth/verify`, params, options);
+      if (result?.access_token) {
+        apiConfig.setToken({ ...result, email: params.email, is_verified: true });
+      }
+      return result;
+    },
+    async magicLink(params, options) {
+      return apiConfig.httpClient.post("/v1/auth/code", params, options);
+    }
+  };
+};
+
+// src/api/store.ts
+var createStoreApi = (apiConfig) => {
+  return {
+    async createStore(params, options) {
+      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
+      );
+    },
+    async getStore(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${apiConfig.storeId}`,
+        options
+      );
+    },
+    async getStores(params, options) {
+      return apiConfig.httpClient.get(`/v1/stores`, {
+        ...options,
+        params
+      });
+    },
+    async getSubscriptionPlans(params, options) {
+      return apiConfig.httpClient.get("/v1/stores/plans", options);
+    },
+    async subscribe(params, options) {
+      const { store_id, plan_id, 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, success_url, cancel_url },
+        options
+      );
+    },
+    async createPortalSession(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/subscription/portal`,
+        { return_url: params.return_url },
+        options
+      );
+    },
+    async inviteUser(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/invitation`,
+        params,
+        options
+      );
+    },
+    async removeMember(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${apiConfig.storeId}/members/${params.account_id}`,
+        options
+      );
+    },
+    async handleInvitation(params, options) {
+      const { store_id, ...payload } = params;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${store_id || apiConfig.storeId}/invitation`,
+        payload,
+        options
+      );
+    },
+    async testWebhook(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/webhooks/test`,
+        params.webhook,
+        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 = params.ids.join(",");
+      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
+      });
+    },
+    async oauthConnect(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${params.store_id}/oauth/connect`,
+        { provider: params.provider, code: params.code, redirect_uri: params.redirect_uri },
+        options
+      );
+    },
+    async oauthDisconnect(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${params.store_id}/oauth/disconnect`,
+        { provider: params.provider },
+        options
+      );
+    },
+    async listIntegrations(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${params.store_id}/integrations`,
+        options
+      );
+    },
+    async createIntegration(params, options) {
+      const { store_id, ...payload } = params;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/integrations`,
+        payload,
+        options
+      );
+    },
+    async updateIntegration(params, options) {
+      const { store_id, id, ...payload } = params;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${store_id}/integrations/${id}`,
+        payload,
+        options
+      );
+    },
+    async deleteIntegration(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${params.store_id}/integrations/${params.id}`,
+        options
+      );
+    },
+    async getIntegrationConfig(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${params.store_id}/integrations/config/${params.type}`,
+        options
+      );
+    },
+    async listWebhooks(params, 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
+      );
+    },
+    async updateWebhook(params, options) {
+      const { store_id, id, ...payload } = params;
+      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
+      );
+    }
+  };
+};
+
+// src/api/media.ts
+var createMediaApi = (apiConfig) => {
+  return {
+    async getMedia(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/media/${params.media_id}`,
+        options
+      );
+    },
+    async uploadStoreMedia(params, options) {
+      const { store_id, files = [], urls = [] } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      const url = `${apiConfig.baseUrl}/v1/stores/${target_store_id}/media`;
+      const formData = new FormData();
+      files.forEach((file) => formData.append("files", file));
+      urls.forEach((url2) => formData.append("urls", url2));
+      const tokens = await apiConfig.getToken();
+      const response = await fetch(url, {
+        method: "POST",
+        body: formData,
+        headers: {
+          Authorization: `Bearer ${tokens.access_token}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error("Upload failed, server said no");
+      }
+      return await response.json();
+    },
+    async deleteStoreMedia(params, options) {
+      const { id, media_id } = params;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${id}/media/${media_id}`,
+        options
+      );
+    },
+    async getStoreMedia(params, options) {
+      const { store_id, cursor, limit, ids, query, mime_type, sort_field, sort_direction } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      const url = `${apiConfig.baseUrl}/v1/stores/${target_store_id}/media`;
+      const queryParams = { limit: String(limit) };
+      if (cursor) queryParams.cursor = cursor;
+      if (ids && ids.length > 0) queryParams.ids = ids.join(",");
+      if (query) queryParams.query = query;
+      if (mime_type) queryParams.mime_type = mime_type;
+      if (sort_field) queryParams.sort_field = sort_field;
+      if (sort_direction) queryParams.sort_direction = sort_direction;
+      const queryString = new URLSearchParams(queryParams).toString();
+      const tokens = await apiConfig.getToken();
+      const response = await fetch(`${url}?${queryString}`, {
+        headers: {
+          Authorization: `Bearer ${tokens.access_token}`
+        }
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        throw new Error(errorData?.message || "Failed to fetch media");
+      }
+      return await response.json();
+    },
+    async updateMedia(params, options) {
+      const { media_id, store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/media/${media_id}`,
+        payload,
+        options
+      );
+    }
+  };
+};
+
+// src/api/notification.ts
+var createNotificationApi = (apiConfig) => {
+  return {
+    async trackEmailOpen(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/notifications/track/pixel/${params.tracking_pixel_id}`,
+        options
+      );
+    },
+    async trigger(params, options) {
+      return apiConfig.httpClient.post(
+        "/v1/notifications/trigger",
+        params,
+        options
+      );
+    }
+  };
+};
+
+// src/api/promoCode.ts
+var createPromoCodeApi = (apiConfig) => {
+  return {
+    async createPromoCode(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/promo-codes`,
+        payload,
+        options
+      );
+    },
+    async updatePromoCode(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/promo-codes/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deletePromoCode(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/promo-codes/${params.id}`,
+        options
+      );
+    },
+    async getPromoCode(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/promo-codes/${params.id}`,
+        options
+      );
+    },
+    async getPromoCodes(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(`/v1/stores/${target_store_id}/promo-codes`, {
+        ...options,
+        params: queryParams
+      });
+    }
+  };
+};
+
+// src/api/cms.ts
+var createCmsApi = (apiConfig) => {
+  return {
+    async createNode(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/nodes`,
+        payload,
+        options
+      );
+    },
+    async updateNode(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/nodes/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteNode(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/nodes/${params.id}`,
+        options
+      );
+    },
+    async getNode(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      let identifier;
+      if (params.id) {
+        identifier = params.id;
+      } else if (params.slug) {
+        identifier = `${target_store_id}:${apiConfig.locale}:${params.slug}`;
+      } else if (params.key) {
+        identifier = `${target_store_id}:${params.key}`;
+      } else {
+        throw new Error("GetNodeParams requires id, slug, or key");
+      }
+      const response = await apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/nodes/${identifier}`,
+        options
+      );
+      return {
+        ...response,
+        getBlock(key) {
+          return getBlockFromArray(response, key, apiConfig.locale);
+        },
+        getBlockValues(key) {
+          return getBlockObjectValues(response, key, apiConfig.locale);
+        },
+        getImage(key) {
+          const block = getBlockFromArray(response, key, apiConfig.locale);
+          return getImageUrl(block, true);
+        }
+      };
+    },
+    async getNodes(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/nodes`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getNodeChildren(params, options) {
+      const { id, store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/nodes/${id}/children`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    }
+  };
+};
+
+// src/api/eshop.ts
+var createEshopApi = (apiConfig) => {
+  return {
+    async createProduct(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/products`,
+        payload,
+        options
+      );
+    },
+    async updateProduct(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/products/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteProduct(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/products/${params.id}`,
+        options
+      );
+    },
+    async getProduct(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      let identifier;
+      if (params.id) {
+        identifier = params.id;
+      } else if (params.slug) {
+        identifier = `${target_store_id}:${apiConfig.locale}:${params.slug}`;
+      } else {
+        throw new Error("GetProductParams requires id or slug");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/products/${identifier}`,
+        options
+      );
+    },
+    async getProducts(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${encodeURIComponent(target_store_id)}/products`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async createOrder(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/orders`,
+        payload,
+        options
+      );
+    },
+    async updateOrder(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/orders/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async getOrder(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders/${params.id}`,
+        options
+      );
+    },
+    async getOrders(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/orders`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getQuote(params, options) {
+      const { location, ...rest } = params;
+      const shipping_address = location ? {
+        country: location.country || "",
+        state: location.state || "",
+        city: location.city || "",
+        postal_code: location.postal_code || "",
+        name: "",
+        street1: "",
+        street2: null
+      } : void 0;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/orders/quote`,
+        { ...rest, shipping_address, market: apiConfig.market },
+        options
+      );
+    },
+    async processRefund(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/orders/${params.id}/refund`,
+        { amount: params.amount },
+        options
+      );
+    }
+  };
+};
+
+// src/api/booking.ts
+var createBookingApi = (apiConfig) => {
+  let cart = [];
+  return {
+    addToCart(slot) {
+      cart.push(slot);
+    },
+    removeFromCart(slotId) {
+      cart = cart.filter((s) => s.id !== slotId);
+    },
+    getCart() {
+      return [...cart];
+    },
+    clearCart() {
+      cart = [];
+    },
+    async createBooking(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/bookings`,
+        { market: "booking", ...payload },
+        options
+      );
+    },
+    async updateBooking(params, options) {
+      const { id, ...payload } = params;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${apiConfig.storeId}/bookings/${id}`,
+        payload,
+        options
+      );
+    },
+    async getBooking(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/bookings/${params.id}`,
+        options
+      );
+    },
+    async searchBookings(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/bookings`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getQuote(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/bookings/quote`,
+        { market: "booking", ...payload },
+        options
+      );
+    },
+    async processRefund(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/bookings/${params.id}/refund`,
+        { amount: params.amount },
+        options
+      );
+    },
+    async getAvailability(params, options) {
+      const { store_id, ...query } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/bookings/availability`,
+        { ...options, params: query }
+      );
+    },
+    async createService(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/services`,
+        payload,
+        options
+      );
+    },
+    async updateService(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/services/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteService(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/services/${params.id}`,
+        options
+      );
+    },
+    async getService(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      let identifier;
+      if (params.id) {
+        identifier = params.id;
+      } else if (params.slug) {
+        identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+      } else {
+        throw new Error("GetServiceParams requires id or slug");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/services/${identifier}`,
+        options
+      );
+    },
+    async getServices(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/services`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async createProvider(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/providers`,
+        payload,
+        options
+      );
+    },
+    async updateProvider(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/providers/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteProvider(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/providers/${params.id}`,
+        options
+      );
+    },
+    async getProvider(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      let identifier;
+      if (params.id) {
+        identifier = params.id;
+      } else if (params.slug) {
+        identifier = `${store_id}:${apiConfig.locale}:${params.slug}`;
+      } else {
+        throw new Error("GetProviderParams requires id or slug");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/providers/${identifier}`,
+        options
+      );
+    },
+    async getProviders(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/providers`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async cancelBookingItem(params, options) {
+      const { store_id, booking_id, item_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/bookings/${booking_id}/items/${item_id}/cancel`,
+        payload,
+        options
+      );
+    },
+    async findServiceProviders(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/service-providers`,
+        { ...options, params: queryParams }
+      );
+    },
+    async createServiceProvider(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/service-providers`,
+        payload,
+        options
+      );
+    },
+    async updateServiceProvider(params, options) {
+      const { store_id, id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/service-providers/${id}`,
+        payload,
+        options
+      );
+    },
+    async deleteServiceProvider(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/service-providers/${params.id}`,
+        options
+      );
+    }
+  };
+};
+
+// src/api/location.ts
+var createLocationApi = (apiConfig) => {
+  return {
+    async getCountries(options) {
+      return apiConfig.httpClient.get(`/v1/platform/countries`, options);
+    },
+    async getCountry(countryCode, options) {
+      return apiConfig.httpClient.get(
+        `/v1/platform/countries/${countryCode}`,
+        options
+      );
+    },
+    async list(options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${apiConfig.storeId}/locations`,
+        options
+      );
+    },
+    async get(id, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${apiConfig.storeId}/locations/${id}`,
+        options
+      );
+    },
+    async create(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/locations`,
+        { ...params, store_id: apiConfig.storeId },
+        options
+      );
+    },
+    async update(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/stores/${apiConfig.storeId}/locations/${params.id}`,
+        { ...params, store_id: apiConfig.storeId },
+        options
+      );
+    },
+    async delete(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${apiConfig.storeId}/locations/${params.id}`,
+        options
+      );
+    }
+  };
+};
+
+// src/api/market.ts
+var createMarketApi = (apiConfig) => {
+  return {
+    async list(options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${apiConfig.storeId}/markets`,
+        options
+      );
+    },
+    async get(id, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${apiConfig.storeId}/markets/${id}`,
+        options
+      );
+    },
+    async create(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/markets`,
+        { ...params, store_id: apiConfig.storeId },
+        options
+      );
+    },
+    async update(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/stores/${apiConfig.storeId}/markets/${params.id}`,
+        { ...params, store_id: apiConfig.storeId },
+        options
+      );
+    },
+    async delete(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${apiConfig.storeId}/markets/${params.id}`,
+        options
+      );
+    }
+  };
+};
+
+// src/api/crm.ts
+var createActivityAdminApi = (apiConfig) => ({
+  async timeline(params, options) {
+    const store_id = params.store_id || apiConfig.storeId;
+    const queryParams = { customer_id: params.customer_id };
+    if (params.limit !== void 0) queryParams.limit = params.limit;
+    if (params.cursor) queryParams.cursor = params.cursor;
+    return apiConfig.httpClient.get(
+      `/v1/stores/${store_id}/activities/timeline`,
+      { ...options, params: queryParams }
+    );
+  }
+});
+var createCustomerApi = (apiConfig) => {
+  return {
+    async create(params, options) {
+      const { store_id, ...payload } = params;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id || apiConfig.storeId}/customers`,
+        payload,
+        options
+      );
+    },
+    async get(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/stores/${params.store_id || apiConfig.storeId}/customers/${params.id}`,
+        options
+      );
+    },
+    async find(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;
+      if (params?.query) queryParams.query = params.query;
+      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/${store_id}/customers`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async update(params, options) {
+      const { id, store_id, ...body } = params;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${store_id || apiConfig.storeId}/customers/${id}`,
+        body,
+        options
+      );
+    },
+    async merge(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/customers/${params.target_id}/merge`,
+        { source_id: params.source_id, store_id },
+        options
+      );
+    },
+    async revokeToken(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${store_id}/customers/${params.id}/sessions/${params.token_id}`,
+        options
+      );
+    },
+    async revokeAllTokens(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${store_id}/customers/${params.id}/sessions`,
+        options
+      );
+    },
+    audiences: {
+      async create(params, options) {
+        return apiConfig.httpClient.post(
+          `/v1/stores/${apiConfig.storeId}/audiences`,
+          params,
+          options
+        );
+      },
+      async update(params, options) {
+        return apiConfig.httpClient.put(
+          `/v1/stores/${apiConfig.storeId}/audiences/${params.id}`,
+          params,
+          options
+        );
+      },
+      async get(params, options) {
+        let identifier;
+        if (params.id) {
+          identifier = params.id;
+        } else if (params.key) {
+          identifier = `${apiConfig.storeId}:${params.key}`;
+        } else {
+          throw new Error("GetAudienceParams requires id or key");
+        }
+        return apiConfig.httpClient.get(
+          `/v1/stores/${apiConfig.storeId}/audiences/${identifier}`,
+          options
+        );
+      },
+      async find(params, options) {
+        return apiConfig.httpClient.get(
+          `/v1/stores/${apiConfig.storeId}/audiences`,
+          { ...options, params }
+        );
+      },
+      async getSubscribers(params, options) {
+        return apiConfig.httpClient.get(
+          `/v1/stores/${apiConfig.storeId}/audiences/${params.id}/subscribers`,
+          {
+            ...options,
+            params: { limit: params.limit, cursor: params.cursor }
+          }
+        );
+      },
+      async addSubscriber(params, options) {
+        return apiConfig.httpClient.post(
+          `/v1/stores/${apiConfig.storeId}/audiences/${params.id}/subscribers`,
+          { customer_id: params.customer_id },
+          options
+        );
+      },
+      async removeSubscriber(params, options) {
+        return apiConfig.httpClient.delete(
+          `/v1/stores/${apiConfig.storeId}/audiences/${params.id}/subscribers/${params.customer_id}`,
+          options
+        );
+      }
+    },
+    activity: createActivityAdminApi(apiConfig)
+  };
+};
+
+// src/api/workflow.ts
+var createWorkflowApi = (apiConfig) => {
+  return {
+    async createWorkflow(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/workflows`,
+        { ...payload, store_id: target_store_id },
+        options
+      );
+    },
+    async updateWorkflow(params, options) {
+      const { store_id, id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/workflows/${id}`,
+        payload,
+        options
+      );
+    },
+    async deleteWorkflow(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${store_id}/workflows/${params.id}`,
+        options
+      );
+    },
+    async getWorkflow(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/workflows/${params.id}`,
+        options
+      );
+    },
+    async getWorkflows(params, options) {
+      const store_id = params?.store_id || apiConfig.storeId;
+      const { store_id: _, ...queryParams } = params || {};
+      return apiConfig.httpClient.get(`/v1/stores/${store_id}/workflows`, {
+        ...options,
+        params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+      });
+    },
+    async triggerWorkflow(params, options) {
+      const { secret, ...payload } = params;
+      return apiConfig.httpClient.post(`/v1/workflows/trigger/${secret}`, payload, options);
+    },
+    async getWorkflowExecutions(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const { store_id: _, workflow_id, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/workflows/${workflow_id}/executions`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    },
+    async getWorkflowExecution(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}`,
+        options
+      );
+    }
+  };
+};
+
+// src/api/platform.ts
+var createPlatformApi = (apiConfig) => {
+  return {
+    async getCurrencies(options) {
+      return apiConfig.httpClient.get("/v1/platform/currencies", options);
+    },
+    async getIntegrationServices(options) {
+      return apiConfig.httpClient.get("/v1/platform/integration-services", options);
+    },
+    async getWebhookEvents(options) {
+      return apiConfig.httpClient.get("/v1/platform/events", options);
+    }
+  };
+};
+
+// src/api/shipping.ts
+var createShippingApi = (apiConfig) => {
+  return {
+    async getRates(params, options) {
+      const { order_id, ...payload } = params;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${apiConfig.storeId}/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`,
+        payload,
+        options
+      );
+    }
+  };
+};
+
+// src/api/agent.ts
+var createAgentApi = (apiConfig) => {
+  return {
+    async createAgent(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/agents`,
+        { ...payload, store_id: target_store_id },
+        options
+      );
+    },
+    async updateAgent(params, options) {
+      const { store_id, id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/agents/${id}`,
+        payload,
+        options
+      );
+    },
+    async deleteAgent(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${store_id}/agents/${params.id}`,
+        options
+      );
+    },
+    async getAgent(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/agents/${params.id}`,
+        options
+      );
+    },
+    async getAgents(params, options) {
+      const store_id = params?.store_id || apiConfig.storeId;
+      const { store_id: _, ...queryParams } = params || {};
+      return apiConfig.httpClient.get(`/v1/stores/${store_id}/agents`, {
+        ...options,
+        params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+      });
+    },
+    async sendMessage(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const body = { message: params.message };
+      if (params.chat_id) body.chat_id = params.chat_id;
+      if (params.direct) body.direct = params.direct;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/agents/${params.id}/chats/messages`,
+        body,
+        options
+      );
+    },
+    async getChats(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const queryParams = {};
+      if (params.limit) queryParams.limit = String(params.limit);
+      if (params.cursor) queryParams.cursor = params.cursor;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/agents/${params.id}/chats`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    },
+    async getChat(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/agents/${params.id}/chats/${params.chat_id}`,
+        options
+      );
+    },
+    async updateChat(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${store_id}/agents/${params.id}/chats/${params.chat_id}`,
+        { status: params.status },
+        options
+      );
+    },
+    async rateChat(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const body = { rating: params.rating };
+      if (params.comment) body.comment = params.comment;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/agents/${params.id}/chats/${params.chat_id}/rate`,
+        body,
+        options
+      );
+    },
+    async getStoreChats(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const { store_id: _, ...queryParams } = params;
+      return apiConfig.httpClient.get(`/v1/stores/${store_id}/chats`, {
+        ...options,
+        params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+      });
+    },
+    async getChatMessages(params, options) {
+      const store_id = params.store_id || apiConfig.storeId;
+      const queryParams = {};
+      if (params.limit) queryParams.limit = String(params.limit);
+      return apiConfig.httpClient.get(
+        `/v1/stores/${store_id}/agents/${params.id}/chats/${params.chat_id}/messages`,
+        {
+          ...options,
+          params: Object.keys(queryParams).length > 0 ? queryParams : void 0
+        }
+      );
+    }
+  };
+};
+
+// src/api/emailTemplate.ts
+var createEmailTemplateApi = (apiConfig) => {
+  return {
+    async createEmailTemplate(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/email-templates`,
+        payload,
+        options
+      );
+    },
+    async updateEmailTemplate(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/email-templates/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteEmailTemplate(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/email-templates/${params.id}`,
+        options
+      );
+    },
+    async getEmailTemplate(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("GetEmailTemplateParams requires id or key");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/email-templates/${identifier}`,
+        options
+      );
+    },
+    async getEmailTemplates(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/email-templates`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    }
+  };
+};
+
+// src/api/form.ts
+var createFormApi = (apiConfig) => {
+  return {
+    async createForm(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/forms`,
+        payload,
+        options
+      );
+    },
+    async updateForm(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/forms/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteForm(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/forms/${params.id}`,
+        options
+      );
+    },
+    async getForm(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("GetFormParams requires id or key");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/forms/${identifier}`,
+        options
+      );
+    },
+    async getForms(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/forms`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async submit(params, options) {
+      const { store_id, form_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/forms/${form_id}/submissions`,
+        { ...payload, form_id, store_id: target_store_id },
+        options
+      );
+    },
+    async getSubmissions(params, options) {
+      const { store_id, form_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/forms/${form_id}/submissions`,
+        {
+          ...options,
+          params: { ...queryParams, form_id, store_id: target_store_id }
+        }
+      );
+    },
+    async getSubmission(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/forms/${params.form_id}/submissions/${params.id}`,
+        options
+      );
+    },
+    async updateSubmission(params, options) {
+      const { store_id, form_id, id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/forms/${form_id}/submissions/${id}`,
+        { ...payload, form_id, store_id: target_store_id, id },
+        options
+      );
+    }
+  };
+};
+
+// src/api/taxonomy.ts
+var createTaxonomyApi = (apiConfig) => {
+  return {
+    async createTaxonomy(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${target_store_id}/taxonomies`,
+        payload,
+        options
+      );
+    },
+    async updateTaxonomy(params, options) {
+      const { store_id, ...payload } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.put(
+        `/v1/stores/${target_store_id}/taxonomies/${params.id}`,
+        payload,
+        options
+      );
+    },
+    async deleteTaxonomy(params, options) {
+      const target_store_id = params.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.delete(
+        `/v1/stores/${target_store_id}/taxonomies/${params.id}`,
+        options
+      );
+    },
+    async getTaxonomy(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("GetTaxonomyParams requires id or key");
+      }
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/taxonomies/${identifier}`,
+        options
+      );
+    },
+    async getTaxonomies(params, options) {
+      const { store_id, ...queryParams } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/taxonomies`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getTaxonomyChildren(params, options) {
+      const { id, store_id } = params;
+      const target_store_id = store_id || apiConfig.storeId;
+      return apiConfig.httpClient.get(
+        `/v1/stores/${target_store_id}/taxonomies/${id}/children`,
+        options
+      );
+    }
+  };
+};
+
+// src/api/analytics.ts
+var createAnalyticsApi = (apiConfig) => {
+  return {
+    async query(spec, options) {
+      const store_id = options?.store_id || apiConfig.storeId;
+      return apiConfig.httpClient.post(
+        `/v1/stores/${store_id}/analytics/query`,
+        spec,
+        options
+      );
+    }
+  };
+};
+
+// src/utils/price.ts
+function formatCurrency(amount, currencyCode, locale = "en") {
+  if (!currencyCode) return "";
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode.toUpperCase()
+  }).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 convertToMajor(minorAmount, currency) {
+  const units = getMinorUnits(currency);
+  return minorAmount / Math.pow(10, units);
+}
+function getCurrencySymbol(currency) {
+  try {
+    return new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: currency.toUpperCase(),
+      currencyDisplay: "narrowSymbol"
+    }).formatToParts(0).find((p) => p.type === "currency")?.value || currency.toUpperCase();
+  } catch {
+    return currency.toUpperCase();
+  }
+}
+function getCurrencyName(currency) {
+  try {
+    return new Intl.DisplayNames(["en"], { type: "currency" }).of(currency.toUpperCase()) || currency.toUpperCase();
+  } catch {
+    return currency.toUpperCase();
+  }
+}
+function formatMinor(amountMinor, currency) {
+  if (!currency) return "";
+  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 "";
+  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;
+}
+
+// src/utils/validation.ts
+function validatePhoneNumber(phone) {
+  if (!phone) {
+    return { isValid: false, error: "Phone number is required" };
+  }
+  const cleaned = phone.replace(/\D/g, "");
+  if (cleaned.length < 8) {
+    return { isValid: false, error: "Phone number is too short" };
+  }
+  if (cleaned.length > 15) {
+    return { isValid: false, error: "Phone number is too long" };
+  }
+  return { isValid: true };
+}
+
+// src/utils/timezone.ts
+var tzGroups = [
+  {
+    label: "US",
+    zones: [
+      { label: "Eastern Time", value: "America/New_York" },
+      { label: "Central Time", value: "America/Chicago" },
+      { label: "Mountain Time", value: "America/Denver" },
+      { label: "Pacific Time", value: "America/Los_Angeles" }
+    ]
+  },
+  {
+    label: "Europe",
+    zones: [
+      { label: "London", value: "Europe/London" },
+      { label: "Paris", value: "Europe/Paris" },
+      { label: "Berlin", value: "Europe/Berlin" },
+      { label: "Rome", value: "Europe/Rome" }
+    ]
+  },
+  {
+    label: "Asia",
+    zones: [
+      { label: "Tokyo", value: "Asia/Tokyo" },
+      { label: "Shanghai", value: "Asia/Shanghai" },
+      { label: "Mumbai", value: "Asia/Kolkata" },
+      { label: "Dubai", value: "Asia/Dubai" }
+    ]
+  }
+];
+function findTimeZone(groups) {
+  try {
+    const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    for (const group of groups) {
+      for (const zone of group.zones) {
+        if (zone.value === detected) {
+          return detected;
+        }
+      }
+    }
+    return "UTC";
+  } catch (e) {
+    return "UTC";
+  }
+}
+
+// src/utils/text.ts
+var locales = ["en", "sr-latn"];
+var localeMap = {
+  "en": "en-US",
+  "sr-latn": "sr-RS"
+};
+function slugify(text) {
+  return text.toString().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function humanize(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").replace(
+    /\w\S*/g,
+    (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
+  );
+}
+function categorify(text) {
+  const slugifiedText = slugify(text);
+  return slugifiedText.replace(/-/g, " ").toUpperCase();
+}
+function formatDate(date, locale) {
+  let localeString = "en-US";
+  if (locales.includes(locale)) {
+    localeString = localeMap[locale];
+  }
+  return new Date(date).toLocaleDateString(localeString, {
+    timeZone: "UTC",
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+
+// src/utils/svg.ts
+async function fetchSvgContent(mediaObject) {
+  if (!mediaObject) return null;
+  const svgUrl = getImageUrl(mediaObject, false);
+  try {
+    const response = await fetch(svgUrl);
+    if (!response.ok) {
+      console.error(`Failed to fetch SVG: ${response.status} ${response.statusText}`);
+      return null;
+    }
+    const svgContent = await response.text();
+    return svgContent;
+  } catch (error) {
+    console.error("Error fetching SVG:", error);
+    return null;
+  }
+}
+async function getSvgContentForAstro(mediaObject) {
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    return svgContent || "";
+  } catch (error) {
+    console.error("Error getting SVG content for Astro:", error);
+    return "";
+  }
+}
+async function injectSvgIntoElement(mediaObject, targetElement, className) {
+  if (!targetElement) return;
+  try {
+    const svgContent = await fetchSvgContent(mediaObject);
+    if (svgContent) {
+      targetElement.innerHTML = svgContent;
+      if (className) {
+        const svgElement = targetElement.querySelector("svg");
+        if (svgElement) {
+          svgElement.classList.add(...className.split(" "));
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error injecting SVG:", error);
+  }
+}
+
+// src/utils/keyValidation.ts
+var KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function isValidKey(key) {
+  if (!key || key.length === 0) return false;
+  return KEY_PATTERN.test(key);
+}
+function validateKey(key) {
+  if (!key || key.length === 0) {
+    return { valid: false, error: "Key is required" };
+  }
+  if (key.length > 255) {
+    return { valid: false, error: "Key must be 255 characters or less" };
+  }
+  if (!KEY_PATTERN.test(key)) {
+    return {
+      valid: false,
+      error: "Key can only contain letters, numbers, underscores (_) and hyphens (-)"
+    };
+  }
+  return { valid: true };
+}
+function toKey(input) {
+  if (!input) return "";
+  return input.toLowerCase().trim().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "").replace(/^[-_]+|[-_]+$/g, "").replace(/[-_]{2,}/g, "_");
+}
+function nameToKey(name) {
+  return toKey(name);
+}
+
+// src/utils/inventory.ts
+function getAvailableStock(variant) {
+  if (!variant?.inventory) return 0;
+  return variant.inventory.reduce((sum, inv) => sum + inv.available, 0);
+}
+function getReservedStock(variant) {
+  if (!variant?.inventory) return 0;
+  return variant.inventory.reduce((sum, inv) => sum + inv.reserved, 0);
+}
+function hasStock(variant, quantity = 1) {
+  return getAvailableStock(variant) >= quantity;
+}
+function getInventoryAt(variant, locationId) {
+  return variant?.inventory?.find((inv) => inv.location_id === locationId);
+}
+function getFirstAvailableFCId(variant, quantity = 1) {
+  const inv = variant?.inventory?.find((i) => i.available >= quantity);
+  return inv?.location_id;
+}
+
+// src/index.ts
+function createUtilitySurface(apiConfig) {
+  return {
+    getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock),
+    getBlockValue,
+    getBlockTextValue,
+    getBlockValues,
+    getBlockLabel,
+    getBlockObjectValues,
+    getBlockFromArray,
+    formatBlockValue,
+    prepareBlocksForSubmission,
+    extractBlockValues,
+    formatPrice: (prices) => formatPrice(prices, apiConfig.market),
+    getPriceAmount: (prices) => getPriceAmount(prices, apiConfig.market),
+    formatPayment,
+    formatMinor,
+    getCurrencySymbol,
+    getCurrencyName,
+    validatePhoneNumber,
+    tzGroups,
+    findTimeZone,
+    slugify,
+    humanize,
+    categorify,
+    formatDate,
+    getSvgContentForAstro,
+    fetchSvgContent,
+    injectSvgIntoElement,
+    isValidKey,
+    validateKey,
+    toKey,
+    nameToKey,
+    getAvailableStock,
+    getReservedStock,
+    hasStock,
+    getInventoryAt,
+    getFirstAvailableFCId
+  };
+}
+function createAdmin(config) {
+  const locale = config.locale || "en";
+  const getToken = config.getToken || defaultGetToken;
+  const setToken = config.setToken || defaultSetToken;
+  const logout = config.logout || defaultLogout;
+  const isAuthenticated = config.isAuthenticated || defaultIsAuthenticated;
+  const httpClient = createHttpClient({ ...config, getToken, setToken, logout });
+  const apiConfig = {
+    httpClient,
+    storeId: config.storeId,
+    baseUrl: config.baseUrl,
+    market: config.market,
+    locale,
+    setToken,
+    getToken
+  };
+  const accountApi = createAccountApi(apiConfig);
+  const authApi = createAuthApi(apiConfig);
+  const storeApi = createStoreApi(apiConfig);
+  const platformApi = createPlatformApi(apiConfig);
+  const cmsApi = createCmsApi(apiConfig);
+  const eshopApi = createEshopApi(apiConfig);
+  const bookingApi = createBookingApi(apiConfig);
+  const crmApi = createCustomerApi(apiConfig);
+  const locationApi = createLocationApi(apiConfig);
+  const marketApi = createMarketApi(apiConfig);
+  const agentApi = createAgentApi(apiConfig);
+  const workflowApi = createWorkflowApi(apiConfig);
+  const formApi = createFormApi(apiConfig);
+  const taxonomyApi = createTaxonomyApi(apiConfig);
+  const emailTemplateApi = createEmailTemplateApi(apiConfig);
+  const analyticsApi = createAnalyticsApi(apiConfig);
+  const sdk = {
+    auth: authApi,
+    account: accountApi,
+    store: {
+      ...storeApi,
+      location: locationApi,
+      market: marketApi
+    },
+    media: createMediaApi(apiConfig),
+    notification: createNotificationApi(apiConfig),
+    promoCode: createPromoCodeApi(apiConfig),
+    platform: platformApi,
+    shipping: createShippingApi(apiConfig),
+    cms: {
+      node: {
+        create: cmsApi.createNode,
+        update: cmsApi.updateNode,
+        delete: cmsApi.deleteNode,
+        get: cmsApi.getNode,
+        find: cmsApi.getNodes,
+        getChildren: cmsApi.getNodeChildren
+      },
+      form: {
+        create: formApi.createForm,
+        update: formApi.updateForm,
+        delete: formApi.deleteForm,
+        get: formApi.getForm,
+        find: formApi.getForms,
+        submit: formApi.submit,
+        getSubmissions: formApi.getSubmissions,
+        getSubmission: formApi.getSubmission,
+        updateSubmission: formApi.updateSubmission
+      },
+      taxonomy: {
+        create: taxonomyApi.createTaxonomy,
+        update: taxonomyApi.updateTaxonomy,
+        delete: taxonomyApi.deleteTaxonomy,
+        get: taxonomyApi.getTaxonomy,
+        find: taxonomyApi.getTaxonomies,
+        getChildren: taxonomyApi.getTaxonomyChildren
+      },
+      emailTemplate: {
+        create: emailTemplateApi.createEmailTemplate,
+        update: emailTemplateApi.updateEmailTemplate,
+        delete: emailTemplateApi.deleteEmailTemplate,
+        get: emailTemplateApi.getEmailTemplate,
+        find: emailTemplateApi.getEmailTemplates
+      }
+    },
+    eshop: {
+      product: {
+        create: eshopApi.createProduct,
+        update: eshopApi.updateProduct,
+        delete: eshopApi.deleteProduct,
+        get: eshopApi.getProduct,
+        find: eshopApi.getProducts
+      },
+      order: {
+        create: eshopApi.createOrder,
+        update: eshopApi.updateOrder,
+        get: eshopApi.getOrder,
+        find: eshopApi.getOrders,
+        getQuote: eshopApi.getQuote,
+        processRefund: eshopApi.processRefund
+      }
+    },
+    booking: {
+      addToCart: bookingApi.addToCart,
+      removeFromCart: bookingApi.removeFromCart,
+      getCart: bookingApi.getCart,
+      clearCart: bookingApi.clearCart,
+      create: bookingApi.createBooking,
+      update: bookingApi.updateBooking,
+      get: bookingApi.getBooking,
+      find: bookingApi.searchBookings,
+      getQuote: bookingApi.getQuote,
+      processRefund: bookingApi.processRefund,
+      getAvailability: bookingApi.getAvailability,
+      cancelItem: bookingApi.cancelBookingItem,
+      service: {
+        create: bookingApi.createService,
+        update: bookingApi.updateService,
+        delete: bookingApi.deleteService,
+        get: bookingApi.getService,
+        find: bookingApi.getServices,
+        findProviders: bookingApi.findServiceProviders,
+        createProvider: bookingApi.createServiceProvider,
+        updateProvider: bookingApi.updateServiceProvider,
+        deleteProvider: bookingApi.deleteServiceProvider
+      },
+      provider: {
+        create: bookingApi.createProvider,
+        update: bookingApi.updateProvider,
+        delete: bookingApi.deleteProvider,
+        get: bookingApi.getProvider,
+        find: bookingApi.getProviders
+      }
+    },
+    crm: {
+      customer: {
+        create: crmApi.create,
+        get: crmApi.get,
+        find: crmApi.find,
+        update: crmApi.update,
+        merge: crmApi.merge,
+        revokeToken: crmApi.revokeToken,
+        revokeAllTokens: crmApi.revokeAllTokens
+      },
+      audience: {
+        create: crmApi.audiences.create,
+        update: crmApi.audiences.update,
+        get: crmApi.audiences.get,
+        find: crmApi.audiences.find,
+        getSubscribers: crmApi.audiences.getSubscribers,
+        addSubscriber: crmApi.audiences.addSubscriber,
+        removeSubscriber: crmApi.audiences.removeSubscriber
+      },
+      activity: crmApi.activity
+    },
+    automation: {
+      agent: {
+        create: agentApi.createAgent,
+        update: agentApi.updateAgent,
+        delete: agentApi.deleteAgent,
+        get: agentApi.getAgent,
+        find: agentApi.getAgents,
+        sendMessage: agentApi.sendMessage,
+        getChats: agentApi.getChats,
+        getChat: agentApi.getChat,
+        updateChat: agentApi.updateChat,
+        rateChat: agentApi.rateChat,
+        getStoreChats: agentApi.getStoreChats,
+        getChatMessages: agentApi.getChatMessages
+      },
+      workflow: {
+        create: workflowApi.createWorkflow,
+        update: workflowApi.updateWorkflow,
+        delete: workflowApi.deleteWorkflow,
+        get: workflowApi.getWorkflow,
+        find: workflowApi.getWorkflows,
+        trigger: workflowApi.triggerWorkflow,
+        getExecutions: workflowApi.getWorkflowExecutions,
+        getExecution: workflowApi.getWorkflowExecution
+      }
+    },
+    analytics: {
+      query: analyticsApi.query
+    },
+    setStoreId: (storeId) => {
+      apiConfig.storeId = storeId;
+    },
+    getStoreId: () => apiConfig.storeId,
+    setMarket: (market) => {
+      apiConfig.market = market;
+    },
+    getMarket: () => apiConfig.market,
+    setLocale: (locale2) => {
+      apiConfig.locale = locale2;
+    },
+    getLocale: () => apiConfig.locale,
+    isAuthenticated,
+    logout,
+    setToken,
+    extractBlockValues,
+    utils: createUtilitySurface(apiConfig)
+  };
+  return sdk;
+}
+
+export { createAdmin };
+//# sourceMappingURL=admin.js.map
+//# sourceMappingURL=admin.js.map