arky-sdk 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1615 @@
+'use strict';
+
+var nanostores = require('nanostores');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  API_URL: () => exports.API_URL,
+  BUSINESS_ID: () => exports.BUSINESS_ID,
+  STORAGE_URL: () => exports.STORAGE_URL,
+  getGlobalConfig: () => getGlobalConfig,
+  setGlobalConfig: () => setGlobalConfig
+});
+function setGlobalConfig(config) {
+  globalConfig = config;
+  exports.API_URL = config.apiUrl;
+  exports.BUSINESS_ID = config.businessId;
+  exports.STORAGE_URL = config.storageUrl || "";
+}
+function getGlobalConfig() {
+  if (!globalConfig) {
+    throw new Error(
+      "Arky SDK not initialized. Call initArky() or create an ArkyClient instance."
+    );
+  }
+  return globalConfig;
+}
+var globalConfig; exports.API_URL = void 0; exports.BUSINESS_ID = void 0; exports.STORAGE_URL = void 0;
+var init_config = __esm({
+  "src/config.ts"() {
+    globalConfig = null;
+    exports.API_URL = "";
+    exports.BUSINESS_ID = "";
+    exports.STORAGE_URL = "";
+  }
+});
+
+// src/index.ts
+init_config();
+
+// src/types/index.ts
+var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
+  PaymentMethod2["Cash"] = "CASH";
+  PaymentMethod2["CreditCard"] = "CREDIT_CARD";
+  PaymentMethod2["Free"] = "FREE";
+  return PaymentMethod2;
+})(PaymentMethod || {});
+
+// src/api/cms.ts
+init_config();
+
+// 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("&")}` : "";
+}
+function appendQueryString(url, params) {
+  const queryString = buildQueryString(params);
+  return queryString ? `${url}${queryString}` : url;
+}
+
+// src/services/http.ts
+async function get(url, options) {
+  try {
+    const finalUrl = options?.params ? appendQueryString(url, options.params) : url;
+    const response = await fetch(finalUrl);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+      value: data,
+      success: true
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error occurred";
+    return {
+      value: null,
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+async function post(url, data, options) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const responseData = await response.json();
+    return {
+      value: responseData,
+      success: true
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error occurred";
+    return {
+      value: null,
+      success: false,
+      error: errorMsg
+    };
+  }
+}
+var httpClient = {
+  get,
+  post
+};
+var http_default = httpClient;
+
+// src/api/cms.ts
+var getCollection = async (id) => {
+  const url = `${exports.API_URL}/v1/businesses/${exports.BUSINESS_ID}/collections/${id}`;
+  const { value } = await http_default.get(url);
+  return value;
+};
+var getCollections = async ({ name = null, ids = null }) => {
+  const url = `${exports.API_URL}/v1/businesses/${exports.BUSINESS_ID}/collections`;
+  const response = await http_default.get(url, {
+    params: { name, ids }
+  });
+  return response.value;
+};
+var getCollectionEntries = async ({
+  collectionId,
+  limit,
+  cursor,
+  ids = null
+}) => {
+  const url = `${exports.API_URL}/v1/businesses/${exports.BUSINESS_ID}/collections/${collectionId}/entries`;
+  const response = await http_default.get(url, {
+    params: { limit, cursor, ids }
+  });
+  return response.value;
+};
+var createCollectionEntry = async (collectionEntryData) => {
+  const url = `${exports.API_URL}/v1/businesses/${exports.BUSINESS_ID}/collections/${collectionEntryData.collectionId}/entries`;
+  const result = await http_default.post(url, collectionEntryData, {
+    successMessage: "Created successfully",
+    errorMessage: "Failed to create collection"
+  });
+  return result;
+};
+var getCollectionEntry = async ({ collectionId, id }) => {
+  const url = `${exports.API_URL}/v1/businesses/${exports.BUSINESS_ID}/collections/${collectionId}/entries/${id}`;
+  const response = await http_default.get(url);
+  return response;
+};
+var cmsApi = {
+  getCollection,
+  getCollections,
+  getCollectionEntries,
+  getCollectionEntry,
+  createCollectionEntry
+};
+
+// src/api/eshop.ts
+init_config();
+
+// src/api/reservation.ts
+init_config();
+var reservationApi = {
+  // Get quote for reservation parts
+  async getQuote({
+    token,
+    businessId,
+    market,
+    currency: currency2,
+    userId,
+    parts,
+    paymentMethod = "CASH",
+    promoCode
+  }) {
+    try {
+      const lines = parts.map((part) => ({
+        type: "SERVICE",
+        serviceId: part.serviceId,
+        quantity: 1
+      }));
+      const payload = {
+        businessId,
+        market,
+        currency: currency2,
+        userId,
+        paymentMethod,
+        lines,
+        promoCode: promoCode || void 0,
+        shippingMethodId: null
+      };
+      const res = await fetch(`${exports.API_URL}/v1/payments/quote`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      const text = await res.text();
+      if (!res.ok) {
+        try {
+          const json = JSON.parse(text);
+          return { success: false, error: json.reason || json.error || "Failed to fetch quote", code: json.code };
+        } catch {
+          return { success: false, error: text || "Failed to fetch quote" };
+        }
+      }
+      const quote = text ? JSON.parse(text) : null;
+      return { success: true, data: quote };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message || "Failed to fetch quote"
+      };
+    }
+  },
+  // Get available slots for a service
+  async getAvailableSlots({
+    businessId,
+    serviceId,
+    from,
+    to,
+    limit = 1e3,
+    providerId = null
+  }) {
+    const url = `${exports.API_URL}/v1/businesses/${businessId}/services/${serviceId}/available-slots`;
+    const response = await http_default.get(url, {
+      params: {
+        from,
+        to,
+        limit,
+        providerId
+      }
+    });
+    if (response.success) {
+      const json = response.value;
+      return {
+        success: true,
+        data: json.data?.items || json.items || []
+      };
+    } else {
+      console.error("Error fetching available slots:", response.error);
+      return {
+        success: false,
+        error: response.error,
+        data: []
+      };
+    }
+  },
+  // Get all providers for a service
+  async getProviders({ businessId, serviceId, limit = 50 }) {
+    const url = `${exports.API_URL}/v1/businesses/${businessId}/providers`;
+    const response = await http_default.get(url, {
+      params: {
+        serviceId,
+        limit
+      }
+    });
+    if (response.success) {
+      const json = response.value;
+      return {
+        success: true,
+        data: json.items || []
+      };
+    } else {
+      console.error("Error loading providers:", response.error);
+      return {
+        success: false,
+        error: response.error,
+        data: []
+      };
+    }
+  },
+  // Get guest token or create a new one
+  async getGuestToken() {
+    try {
+      const res = await fetch(`${exports.API_URL}/v1/users/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider: "GUEST" })
+      });
+      if (!res.ok) throw new Error("Guest login failed");
+      const json = await res.json();
+      return {
+        success: true,
+        data: { token: json.accessToken }
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  },
+  // Update user's phone number
+  async updateProfilePhone({ token, phoneNumber }) {
+    try {
+      const res = await fetch(`${exports.API_URL}/v1/users/update`, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          phoneNumber,
+          phoneNumbers: [],
+          addresses: []
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text() || res.statusText;
+        return {
+          success: false,
+          error
+        };
+      }
+      return {
+        success: true
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  },
+  // Verify phone number with code
+  async verifyPhoneCode({ token, phoneNumber, code }) {
+    try {
+      const res = await fetch(`${exports.API_URL}/v1/users/confirm/phone-number`, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          phoneNumber,
+          code
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text() || res.statusText;
+        return {
+          success: false,
+          error
+        };
+      }
+      return {
+        success: true
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  },
+  // Complete reservation checkout - Backend calculates currency from market
+  async checkout({
+    token,
+    businessId,
+    parts,
+    paymentMethod = "CASH",
+    blocks = [],
+    market = "US",
+    promoCode
+  }) {
+    try {
+      const payload = {
+        businessId,
+        blocks,
+        market,
+        parts: parts.map((p) => ({
+          serviceId: p.serviceId,
+          from: p.from,
+          to: p.to,
+          blocks: p.blocks,
+          reservationMethod: p.reservationMethod,
+          providerId: p.providerId
+        }))
+      };
+      if (paymentMethod !== void 0) {
+        payload.paymentMethod = paymentMethod;
+      }
+      if (promoCode) {
+        payload.promoCode = promoCode;
+      }
+      const res = await fetch(`${exports.API_URL}/v1/reservations/checkout`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) {
+        const error = await res.text() || res.statusText;
+        throw new Error(error);
+      }
+      const json = await res.json();
+      return {
+        success: true,
+        data: json
+        // Should include reservationId and clientSecret for payments
+      };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  }
+};
+
+// src/api/eshop.ts
+var eshopApi = {
+  // Get products
+  async getProducts({
+    businessId,
+    categoryIds = null,
+    status = "ACTIVE",
+    limit = 20,
+    cursor = null
+  }) {
+    const url = `${exports.API_URL}/v1/businesses/${encodeURIComponent(businessId)}/products`;
+    const response = await http_default.get(url, {
+      params: {
+        categoryIds: categoryIds && categoryIds.length > 0 ? categoryIds : void 0,
+        status,
+        limit,
+        cursor
+      }
+    });
+    if (response.success) {
+      const json = response.value;
+      return {
+        success: true,
+        data: json.items || [],
+        cursor: json.cursor,
+        total: json.total || 0
+      };
+    } else {
+      console.error("Error fetching products:", response.error);
+      return {
+        success: false,
+        error: response.error,
+        data: []
+      };
+    }
+  },
+  // Get product by slug
+  async getProductBySlug({ businessId, slug }) {
+    try {
+      const url = `${exports.API_URL}/v1/businesses/${encodeURIComponent(businessId)}/products/slug/${encodeURIComponent(businessId)}/${encodeURIComponent(slug)}`;
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("Product not found");
+      const json = await res.json();
+      return {
+        success: true,
+        data: json
+      };
+    } catch (e) {
+      console.error("Error fetching product:", e);
+      return {
+        success: false,
+        error: e.message,
+        data: null
+      };
+    }
+  },
+  // Get quote for cart (pricing with promo codes, shipping, taxes)
+  async getQuote({
+    token,
+    businessId,
+    items,
+    market,
+    currency: currency2,
+    userId,
+    paymentMethod,
+    shippingMethodId,
+    promoCode
+  }) {
+    try {
+      const lines = items.map((item) => ({
+        type: "PRODUCT_VARIANT",
+        productId: item.productId,
+        variantId: item.variantId,
+        quantity: item.quantity
+      }));
+      const payload = {
+        businessId,
+        market,
+        currency: currency2,
+        userId,
+        paymentMethod,
+        lines,
+        ...shippingMethodId && { shippingMethodId },
+        ...promoCode && { promoCode }
+      };
+      const res = await fetch(`${exports.API_URL}/v1/payments/quote`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      const text = await res.text();
+      if (!res.ok) {
+        try {
+          const json = JSON.parse(text);
+          return { success: false, error: json.reason || json.error || res.statusText, code: json.code };
+        } catch {
+          return { success: false, error: text || res.statusText };
+        }
+      }
+      const quote = text ? JSON.parse(text) : null;
+      return { success: true, data: quote };
+    } catch (e) {
+      console.error("Quote fetch failed:", e);
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  },
+  // Checkout - Backend calculates currency from market
+  async checkout({
+    token,
+    businessId,
+    items,
+    paymentMethod,
+    blocks,
+    market = "US",
+    shippingMethodId,
+    promoCode,
+    paymentIntentId = null
+  }) {
+    try {
+      const payload = {
+        businessId,
+        items,
+        paymentMethod,
+        blocks,
+        market,
+        ...shippingMethodId && { shippingMethodId },
+        ...promoCode && { promoCode },
+        ...paymentIntentId && { paymentIntentId }
+      };
+      const res = await fetch(`${exports.API_URL}/v1/businesses/${encodeURIComponent(businessId)}/orders/checkout`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      const text = await res.text();
+      if (!res.ok) {
+        try {
+          const json2 = JSON.parse(text);
+          return { success: false, error: json2.reason || json2.error || res.statusText, code: json2.code };
+        } catch {
+          return { success: false, error: text || res.statusText };
+        }
+      }
+      const json = text ? JSON.parse(text) : null;
+      return { success: true, data: json };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  },
+  // Create payment intent for Stripe
+  async createPaymentIntent({ amount, currency: currency2, businessId }) {
+    try {
+      const tokenResponse = await reservationApi.getGuestToken();
+      if (!tokenResponse.success || !tokenResponse.data) {
+        throw new Error("Failed to get guest token");
+      }
+      const token = tokenResponse.data.token;
+      const res = await fetch(`${exports.API_URL}/v1/businesses/${encodeURIComponent(businessId)}/payment/create-intent`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          amount,
+          currency: currency2,
+          businessId
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text() || res.statusText;
+        throw new Error(error);
+      }
+      const json = await res.json();
+      return {
+        success: true,
+        data: json
+      };
+    } catch (e) {
+      console.error("Payment intent creation failed:", e);
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  }
+};
+
+// src/api/newsletter.ts
+var newsletterApi = {
+  async find(payload) {
+    const params = new URLSearchParams({
+      businessId: payload.business_id
+    });
+    const { API_URL: API_URL2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const url = `${API_URL2}/v1/newsletters?${params.toString()}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const backendResponse = await response.json();
+    return {
+      data: backendResponse.items || [],
+      meta: {
+        total: backendResponse.items?.length || 0,
+        page: 1,
+        per_page: backendResponse.items?.length || 0
+      }
+    };
+  },
+  async get(id) {
+    const { API_URL: API_URL2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const url = `${API_URL2}/v1/newsletters/${id}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return await response.json();
+  },
+  async subscribe(payload) {
+    try {
+      const { API_URL: API_URL2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const url = `${API_URL2}/v1/newsletters/${payload.newsletterId}/subscribe`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          newsletterId: payload.newsletterId,
+          email: payload.email,
+          market: "US",
+          // Backend resolves currency from market
+          ...payload.customerId && { customerId: payload.customerId },
+          ...payload.payment && { payment: payload.payment }
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `HTTP error! status: ${response.status}`);
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      console.error("Newsletter subscription error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to subscribe to newsletter"
+      };
+    }
+  }
+};
+
+// src/services/auth.ts
+init_config();
+async function getGuestToken(currentToken = null) {
+  if (currentToken) return currentToken;
+  const response = await reservationApi.getGuestToken();
+  if (response.success && response.data) {
+    return response.data.token;
+  }
+  throw new Error("Failed to get guest token");
+}
+async function updateProfilePhone(token, phoneNumber) {
+  if (!phoneNumber) {
+    throw new Error("Phone number is required");
+  }
+  const response = await reservationApi.updateProfilePhone({ token, phoneNumber });
+  if (response.success) {
+    return { success: true };
+  } else {
+    throw new Error(response.error || "Failed to send verification code");
+  }
+}
+async function verifyPhoneCode(token, phoneNumber, code) {
+  if (!code) {
+    throw new Error("Verification code is required");
+  }
+  const response = await reservationApi.verifyPhoneCode({ token, phoneNumber, code });
+  if (response.success) {
+    return { success: true };
+  } else {
+    throw new Error(response.error || "Invalid verification code");
+  }
+}
+async function getBusinessConfig(businessId) {
+  try {
+    const response = await fetch(`${exports.API_URL}/v1/businesses/${businessId}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch business config: ${response.status}`);
+    }
+    const business = await response.json();
+    return {
+      success: true,
+      data: business
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+// src/utils/blocks.ts
+init_config();
+function getBlockLabel(block, locale = "en") {
+  if (!block) return "";
+  if (block.properties?.label) {
+    if (typeof block.properties.label === "object") {
+      return block.properties.label[locale] || block.properties.label.en || Object.values(block.properties.label)[0] || "";
+    }
+    if (typeof block.properties.label === "string") {
+      return block.properties.label;
+    }
+  }
+  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 "";
+  }
+  switch (block.type) {
+    case "BOOLEAN":
+      return block.value ? "Yes" : "No";
+    case "NUMBER":
+      if (block.properties?.variant === "DATE" || block.properties?.variant === "DATE_TIME") {
+        try {
+          return new Date(block.value).toLocaleDateString();
+        } catch (e) {
+          return String(block.value);
+        }
+      }
+      return String(block.value);
+    case "RELATIONSHIP":
+      if (Array.isArray(block.value) && block.value.length > 0) {
+        const firstValue = block.value[0];
+        if (firstValue && firstValue.mimeType) {
+          return firstValue.name || firstValue.id || "Media";
+        }
+        return firstValue.title || firstValue.name || firstValue.id || "Entry";
+      }
+      return String(block.value);
+    default:
+      return String(block.value);
+  }
+}
+function prepareBlocksForSubmission(formData) {
+  const preparedBlocks = [];
+  Object.keys(formData).forEach((key) => {
+    if (formData[key] !== null && formData[key] !== void 0) {
+      preparedBlocks.push({
+        key,
+        value: [formData[key]]
+      });
+    }
+  });
+  return preparedBlocks;
+}
+function extractBlockValues(blocks) {
+  const values = {};
+  blocks.forEach((block) => {
+    if (block.value && block.value.length > 0) {
+      values[block.key] = block.value[0];
+    } else {
+      values[block.key] = null;
+    }
+  });
+  return values;
+}
+function getBlockTextValue(block, locale = "en") {
+  if (!block || !block.value || block.value.length === 0) return "";
+  const firstValue = block.value[0];
+  if (typeof firstValue === "object" && firstValue !== null) {
+    if (firstValue[locale]) return firstValue[locale];
+    if (firstValue.en) return firstValue.en;
+    const values = Object.values(firstValue);
+    return String(values[0] || "");
+  }
+  return String(firstValue);
+}
+var getBlockValue = (entry, blockKey) => {
+  if (!entry || !entry.blocks) return null;
+  const block = entry.blocks.find((f) => f.key === blockKey);
+  if (!block || !block.value || block.value.length === 0) return null;
+  return block.value[0];
+};
+var getBlockValues = (entry, blockKey) => {
+  if (!entry || !entry.blocks) return null;
+  const block = entry.blocks.find((f) => f.key === blockKey);
+  if (!block || !block.value || block.value.length === 0) return null;
+  return block.value;
+};
+function unwrapBlock(block, locale) {
+  if (!block?.type || block.value === void 0) return block;
+  if (block.type === "BLOCK") {
+    return block.value.map((obj) => {
+      const parsed = {};
+      for (const [k, v] of Object.entries(obj)) {
+        parsed[k] = unwrapBlock(v, locale);
+      }
+      return parsed;
+    });
+  }
+  const isLocalized = block.type === "TEXT";
+  const isList = block.properties?.ui === "list" || (block.properties?.maxValues ?? 1) > 1 || block.value.length > 1;
+  if (isList) {
+    return isLocalized ? block.value.map((v) => v[locale] || v["en"]) : [...block.value];
+  }
+  return isLocalized ? block.value[0][locale] || block.value[0]["en"] : block.value[0];
+}
+var getBlockObjectValues = (entry, blockKey, locale = "en") => {
+  if (!entry) {
+    return [];
+  }
+  const values = getBlockValues(entry, blockKey);
+  const parsed = values.map((obj) => {
+    const res = obj.value.reduce((acc, current) => {
+      acc[current.key] = unwrapBlock(current, locale);
+      return acc;
+    }, {});
+    return res;
+  });
+  return parsed;
+};
+var getBlockFromArray = (entry, blockKey, locale = "en") => {
+  if (!entry) {
+    return [];
+  }
+  const values = getBlockValues(entry, blockKey);
+  return values.reduce((acc, current) => {
+    acc[current.key] = unwrapBlock(current, locale);
+    return acc;
+  });
+};
+var getImageUrl = (imageBlock, isBlock = true) => {
+  if (!imageBlock) return null;
+  const storageUrl = "https://storage.arky.io/dev";
+  const isExternalUrl = (url) => {
+    return url.startsWith("http://") || url.startsWith("https://");
+  };
+  if (imageBlock.type === "RELATIONSHIP" && Array.isArray(imageBlock.value)) {
+    const mediaValue = imageBlock.value[0];
+    if (mediaValue && mediaValue.mimeType) {
+      if (mediaValue.resolutions && mediaValue.resolutions.original && mediaValue.resolutions.original.url) {
+        const url = mediaValue.resolutions.original.url;
+        return isExternalUrl(url) ? url : `${storageUrl}/${url}`;
+      }
+      if (mediaValue.url) {
+        return isExternalUrl(mediaValue.url) ? mediaValue.url : `${storageUrl}/${mediaValue.url}`;
+      }
+    }
+    return null;
+  }
+  if (isBlock) {
+    if (typeof imageBlock === "string") {
+      if (isExternalUrl(imageBlock)) {
+        return imageBlock;
+      }
+      return `${storageUrl}/${imageBlock}`;
+    }
+    if (imageBlock.url) {
+      if (isExternalUrl(imageBlock.url)) {
+        return imageBlock.url;
+      }
+      return `${storageUrl}/${imageBlock.url}`;
+    }
+  }
+  if (imageBlock.resolutions && imageBlock.resolutions.original && imageBlock.resolutions.original.url) {
+    const url = imageBlock.resolutions.original.url;
+    if (isExternalUrl(url)) {
+      return url;
+    }
+    return `${storageUrl}/${url}`;
+  }
+  return null;
+};
+function getGalleryThumbnail(gallery) {
+  if (!gallery?.length) return null;
+  const item = gallery.find((g) => g.settings.isThumbnail) || gallery[0];
+  const res = item.media.resolutions.thumbnail || item.media.resolutions.original;
+  return res?.url || null;
+}
+function thumbnailUrl(service) {
+  const storageUrl = exports.STORAGE_URL || "";
+  const path = getGalleryThumbnail(service.gallery);
+  return path ? `${storageUrl}/${path}` : null;
+}
+var translateMap = (labels, lang, fallback = "unknown") => {
+  let parsedLang = "en";
+  if (lang === "sr") {
+    parsedLang = "bih";
+  }
+  if (!labels) {
+    return fallback;
+  }
+  const label = labels[parsedLang];
+  if (!label) {
+    return fallback;
+  }
+  return label;
+};
+
+// src/utils/errors.ts
+var ERROR_CODES = {
+  // General errors
+  "GENERAL.001": "GENERAL.BAD_REQUEST",
+  "GENERAL.002": "GENERAL.VALIDATION_ERROR",
+  "GENERAL.003": "GENERAL.FORBIDDEN_ERROR",
+  "GENERAL.004": "GENERAL.INTERNAL_SERVER_ERROR",
+  "GENERAL.005": "GENERAL.UNAUTHORIZED",
+  "GENERAL.006": "GENERAL.UNAUTHENTICATED",
+  // Google/OAuth errors
+  "GOOGLE.001": "GOOGLE.INVALID_ORIGIN_URI",
+  "GOOGLE.002": "GOOGLE.INVALID_REDIRECT_URI",
+  "GOOGLE.003": "GOOGLE.FAILED_TO_CALL_API",
+  "GOOGLE.004": "GOOGLE.FAILED_LOGIN",
+  "GOOGLE.005": "GOOGLE.FAILED_LOGOUT",
+  "GOOGLE.006": "GOOGLE.FAILED_REFRESH_TOKEN",
+  "GOOGLE.007": "GOOGLE.INVALID_PROVIDER_PASSED",
+  // User errors
+  "USER.001": "USER.NOT_FOUND",
+  "USER.002": "USER.FAILED_TO_CREATE",
+  "USER.003": "USER.FAILED_TO_UPDATE",
+  "USER.004": "USER.FAILED_TO_DELETE",
+  "USER.005": "USER.EMAIL_EXISTS",
+  "USER.006": "USER.FAILED_TO_GET_UPLOAD_URL",
+  // Business errors
+  "BUSINESS.001": "BUSINESS.NOT_FOUND",
+  "BUSINESS.002": "BUSINESS.FAILED_TO_CREATE",
+  "BUSINESS.003": "BUSINESS.FAILED_TO_UPDATE",
+  "BUSINESS.004": "BUSINESS.FAILED_TO_DELETE",
+  "BUSINESS.005": "BUSINESS.FAILED_TO_GET_UPLOAD_URL",
+  "BUSINESS.006": "BUSINESS.NAME_REQUIRED",
+  "BUSINESS.007": "BUSINESS.BUSINESS_ID_REQUIRED",
+  "BUSINESS.010": "BUSINESS.DESCRIPTION_REQUIRED",
+  "BUSINESS.011": "BUSINESS.SLUG_INVALID",
+  // Provider errors  
+  "PROVIDER.001": "PROVIDER.NOT_FOUND",
+  "PROVIDER.002": "PROVIDER.FAILED_TO_CREATE",
+  "PROVIDER.003": "PROVIDER.FAILED_TO_UPDATE",
+  "PROVIDER.004": "PROVIDER.FAILED_TO_DELETE",
+  "PROVIDER.005": "PROVIDER.FAILED_TO_GET_UPLOAD_URL",
+  "PROVIDER.006": "PROVIDER.NAME_REQUIRED",
+  "PROVIDER.007": "PROVIDER.BUSINESS_ID_REQUIRED",
+  "PROVIDER.008": "PROVIDER.DESCRIPTION_REQUIRED"
+};
+var ERROR_CONSTANTS = {
+  GENERAL: {
+    BAD_REQUEST: "GENERAL.BAD_REQUEST",
+    VALIDATION_ERROR: "GENERAL.VALIDATION_ERROR",
+    FORBIDDEN_ERROR: "GENERAL.FORBIDDEN_ERROR",
+    INTERNAL_SERVER_ERROR: "GENERAL.INTERNAL_SERVER_ERROR",
+    UNAUTHORIZED: "GENERAL.UNAUTHORIZED",
+    UNAUTHENTICATED: "GENERAL.UNAUTHENTICATED"
+  },
+  USER: {
+    NOT_FOUND: "USER.NOT_FOUND",
+    FAILED_TO_CREATE: "USER.FAILED_TO_CREATE",
+    FAILED_TO_UPDATE: "USER.FAILED_TO_UPDATE",
+    FAILED_TO_DELETE: "USER.FAILED_TO_DELETE",
+    EMAIL_EXISTS: "USER.EMAIL_EXISTS",
+    FAILED_TO_GET_UPLOAD_URL: "USER.FAILED_TO_GET_UPLOAD_URL"
+  },
+  BUSINESS: {
+    NOT_FOUND: "BUSINESS.NOT_FOUND",
+    FAILED_TO_CREATE: "BUSINESS.FAILED_TO_CREATE",
+    FAILED_TO_UPDATE: "BUSINESS.FAILED_TO_UPDATE",
+    FAILED_TO_DELETE: "BUSINESS.FAILED_TO_DELETE",
+    FAILED_TO_GET_UPLOAD_URL: "BUSINESS.FAILED_TO_GET_UPLOAD_URL",
+    NAME_REQUIRED: "BUSINESS.NAME_REQUIRED",
+    BUSINESS_ID_REQUIRED: "BUSINESS.BUSINESS_ID_REQUIRED",
+    DESCRIPTION_REQUIRED: "BUSINESS.DESCRIPTION_REQUIRED",
+    SLUG_INVALID: "BUSINESS.SLUG_INVALID"
+  }
+};
+function getErrorMessage(code) {
+  return ERROR_CODES[code] || code;
+}
+function isErrorCode(code) {
+  return code in ERROR_CODES;
+}
+var transformErrors = (zodError) => {
+  const customErrors = [];
+  if (!zodError.issues) return customErrors;
+  zodError.issues.forEach((issue) => {
+    const field = issue.path.join(".");
+    const message = issue.message;
+    if (!customErrors.some(
+      (customError) => customError.field === field && customError.message === message
+    )) {
+      customErrors.push({ field, message });
+    }
+  });
+  return customErrors;
+};
+var convertServerErrorToRequestError = (serverError, renameRules) => {
+  return {
+    ...serverError,
+    validationErrors: serverError.validationErrors.map((validationError) => {
+      const field = renameRules && renameRules[validationError.field] ? renameRules[validationError.field] : validationError.field;
+      return {
+        field,
+        message: ERROR_CODES[validationError.code] || "Unknown error"
+      };
+    })
+  };
+};
+var errors = ERROR_CONSTANTS;
+
+// src/utils/currency.ts
+function getCurrencySymbol(currency2) {
+  const currencySymbols = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    CAD: "C$",
+    AUD: "A$",
+    JPY: "\xA5",
+    CHF: "CHF",
+    SEK: "kr",
+    NOK: "kr",
+    DKK: "kr",
+    PLN: "z\u0142",
+    CZK: "K\u010D",
+    HUF: "Ft",
+    RON: "lei",
+    BGN: "\u043B\u0432",
+    HRK: "kn",
+    RSD: "\u0434\u0438\u043D",
+    BAM: "KM",
+    MKD: "\u0434\u0435\u043D",
+    ALL: "L",
+    TRY: "\u20BA",
+    RUB: "\u20BD",
+    UAH: "\u20B4",
+    BYN: "Br",
+    CNY: "\xA5",
+    INR: "\u20B9",
+    KRW: "\u20A9",
+    THB: "\u0E3F",
+    VND: "\u20AB",
+    SGD: "S$",
+    MYR: "RM",
+    IDR: "Rp",
+    PHP: "\u20B1",
+    BRL: "R$",
+    ARS: "$",
+    CLP: "$",
+    COP: "$",
+    PEN: "S/",
+    MXN: "$",
+    ZAR: "R",
+    EGP: "E\xA3",
+    NGN: "\u20A6",
+    KES: "KSh",
+    GHS: "\u20B5",
+    MAD: "DH",
+    TND: "\u062F.\u062A",
+    DZD: "\u062F.\u062C",
+    LYD: "\u0644.\u062F",
+    AED: "\u062F.\u0625",
+    SAR: "\u0631.\u0633",
+    QAR: "\u0631.\u0642",
+    KWD: "\u062F.\u0643",
+    BHD: "\u0628.\u062F",
+    OMR: "\u0631.\u0639",
+    JOD: "\u062F.\u0623",
+    LBP: "\u0644.\u0644",
+    SYP: "\u0644.\u0633",
+    IQD: "\u0639.\u062F",
+    IRR: "\uFDFC",
+    AFN: "\u060B",
+    PKR: "\u20A8",
+    LKR: "\u20A8",
+    NPR: "\u20A8",
+    BDT: "\u09F3",
+    MMK: "K",
+    LAK: "\u20AD",
+    KHR: "\u17DB",
+    MNT: "\u20AE",
+    KZT: "\u20B8",
+    UZS: "\u043B\u0432",
+    KGS: "\u043B\u0432",
+    TJS: "SM",
+    TMT: "T",
+    AZN: "\u20BC",
+    GEL: "\u20BE",
+    AMD: "\u058F",
+    BYR: "p.",
+    MDL: "L"
+  };
+  return currencySymbols[currency2.toUpperCase()] || currency2;
+}
+
+// src/utils/price.ts
+var CURRENCY_SYMBOLS = {
+  "USD": "$",
+  "EUR": "\u20AC",
+  "GBP": "\xA3",
+  "CAD": "C$",
+  "AUD": "A$"
+};
+var MARKET_CURRENCIES = {
+  "US": "USD",
+  "EU": "EUR",
+  "UK": "GBP",
+  "CA": "CAD",
+  "AU": "AUD"
+};
+function convertToMajor(minorAmount) {
+  return (minorAmount ?? 0) / 100;
+}
+function convertToMinor(majorAmount) {
+  return Math.round((majorAmount ?? 0) * 100);
+}
+function getSymbol(currency2) {
+  return CURRENCY_SYMBOLS[currency2] || "$";
+}
+function getCurrencyFromMarket(marketId) {
+  return MARKET_CURRENCIES[marketId] || "USD";
+}
+function formatCurrencyAmount(amount, currency2, options = {}) {
+  const { showSymbols = true, decimalPlaces = 2, customSymbol } = options;
+  const roundedAmount = amount.toFixed(decimalPlaces);
+  if (!showSymbols) {
+    return `${roundedAmount} ${currency2}`;
+  }
+  const symbol = customSymbol || getSymbol(currency2);
+  return `${symbol}${roundedAmount}`;
+}
+function formatMinor(amountMinor, currency2, options = {}) {
+  const major = convertToMajor(amountMinor);
+  return formatCurrencyAmount(major, currency2, options);
+}
+function formatPayment(payment, options = {}) {
+  if (!payment) return "";
+  const { showSymbols = true, decimalPlaces = 2, showBreakdown = false } = options;
+  if (showBreakdown) {
+    const subtotal = formatMinor(payment.subtotal, payment.currency, { showSymbols, decimalPlaces });
+    const discount = (payment.discount ?? 0) > 0 ? formatMinor(payment.discount, payment.currency, { showSymbols, decimalPlaces }) : null;
+    const tax = (payment.tax ?? 0) > 0 ? formatMinor(payment.tax, payment.currency, { showSymbols, decimalPlaces }) : null;
+    const total = formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
+    let result = `Subtotal: ${subtotal}`;
+    if (discount) result += `, Discount: -${discount}`;
+    if (tax) result += `, Tax: ${tax}`;
+    result += `, Total: ${total}`;
+    return result;
+  }
+  return formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
+}
+function getMarketPrice(prices, marketId, businessMarkets, options = {}) {
+  if (!prices || prices.length === 0) return "";
+  const {
+    showSymbols = true,
+    decimalPlaces = 2,
+    showCompareAt = true,
+    fallbackMarket = "US"
+  } = options;
+  let price = prices.find((p) => p.market === marketId);
+  if (!price) {
+    price = prices.find((p) => p.market === fallbackMarket) || prices[0];
+  }
+  if (!price) return "";
+  let currency2;
+  let symbol;
+  if (businessMarkets) {
+    const marketData = businessMarkets.find((m) => m.id === price.market || m.code === price.market);
+    if (marketData?.currency) {
+      currency2 = marketData.currency;
+      symbol = getCurrencySymbol(currency2);
+    } else {
+      currency2 = getCurrencyFromMarket(price.market);
+      symbol = getSymbol(currency2);
+    }
+  } else {
+    currency2 = getCurrencyFromMarket(price.market);
+    symbol = getSymbol(currency2);
+  }
+  const formattedPrice = formatMinor(price.amount ?? 0, currency2, {
+    showSymbols,
+    decimalPlaces,
+    customSymbol: symbol
+  });
+  if (showCompareAt && price.compareAt && price.compareAt > (price.amount ?? 0)) {
+    const formattedCompareAt = formatMinor(price.compareAt, currency2, {
+      showSymbols,
+      decimalPlaces,
+      customSymbol: symbol
+    });
+    return `${formattedPrice} was ${formattedCompareAt}`;
+  }
+  return formattedPrice;
+}
+function getPriceAmount(prices, marketId, fallbackMarket = "US") {
+  if (!prices || prices.length === 0) return 0;
+  const price = prices.find((p) => p.market === marketId) || prices.find((p) => p.market === fallbackMarket) || prices[0];
+  return price?.amount || 0;
+}
+function createPaymentForCheckout(subtotalMinor, marketId, currency2, paymentMethod, options = {}) {
+  const { discount = 0, tax = 0, promoCodeId } = options;
+  const total = subtotalMinor - discount + tax;
+  return {
+    currency: currency2,
+    market: marketId,
+    subtotal: subtotalMinor,
+    shipping: 0,
+    discount,
+    tax,
+    total,
+    promoCodeId,
+    method: paymentMethod
+  };
+}
+
+// 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/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(
+    // upper case first letter of every word, and lower case the rest
+    /\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/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/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 };
+}
+function validateEmail(email) {
+  if (!email) {
+    return { isValid: false, error: "Email is required" };
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Please enter a valid email address" };
+  }
+  return { isValid: true };
+}
+function validateVerificationCode(code) {
+  if (!code) {
+    return { isValid: false, error: "Verification code is required" };
+  }
+  const cleaned = code.replace(/\D/g, "");
+  if (cleaned.length !== 4) {
+    return { isValid: false, error: "Please enter a 4-digit verification code" };
+  }
+  return { isValid: true };
+}
+function validateRequired(value, fieldName = "This field") {
+  if (value === null || value === void 0 || value === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+  return { isValid: true };
+}
+
+// src/index.ts
+init_config();
+
+// src/stores/business.ts
+init_config();
+var businessStore = nanostores.deepMap({
+  data: null,
+  loading: false,
+  error: null,
+  initialized: false
+});
+var selectedMarket = nanostores.computed(businessStore, (state) => {
+  if (!state.data?.configs?.markets) return null;
+  const markets2 = state.data.configs.markets;
+  return markets2.find((m) => m.id === "us") || markets2[0] || null;
+});
+nanostores.computed(selectedMarket, (market) => {
+  return market?.currency || "USD";
+});
+nanostores.computed(selectedMarket, (market) => {
+  return getCurrencySymbol(market?.currency || "USD");
+});
+nanostores.computed(businessStore, (state) => {
+  if (!state.data?.configs?.markets) return [];
+  return state.data.configs.markets;
+});
+nanostores.computed(businessStore, (state) => {
+  if (!state.data?.configs?.zones) return [];
+  return state.data.configs.zones;
+});
+var paymentMethods = nanostores.computed(selectedMarket, (market) => {
+  if (!market) return ["CASH"];
+  const methods = market.paymentMethods || [];
+  return methods.map((pm) => pm.method || pm);
+});
+nanostores.computed(businessStore, (state) => {
+  if (!state.data?.configs) return { provider: null, enabled: false };
+  const provider = state.data.configs.paymentProvider || null;
+  const hasCreditCard = paymentMethods.get().includes("CREDIT_CARD");
+  return {
+    provider,
+    enabled: hasCreditCard && !!provider
+  };
+});
+nanostores.computed(businessStore, (state) => {
+  return state.data?.configs?.orderBlocks || [];
+});
+nanostores.computed(businessStore, (state) => {
+  return state.data?.configs?.reservationBlocks || [];
+});
+var businessActions = {
+  // Initialize business data - SINGLE API CALL for entire app
+  async init() {
+    const state = businessStore.get();
+    if (state.initialized && state.data) {
+      return;
+    }
+    try {
+      businessStore.setKey("loading", true);
+      businessStore.setKey("error", null);
+      const result = await getBusinessConfig(exports.BUSINESS_ID);
+      if (result.success) {
+        businessStore.setKey("data", result.data);
+        businessStore.setKey("initialized", true);
+      } else {
+        throw new Error(result.error || "Failed to load business configuration");
+      }
+    } catch (error) {
+      businessStore.setKey("error", error.message);
+      console.error("Business store initialization failed:", error);
+    } finally {
+      businessStore.setKey("loading", false);
+    }
+  },
+  // Reset store (useful for testing)
+  reset() {
+    businessStore.setKey("data", null);
+    businessStore.setKey("loading", false);
+    businessStore.setKey("error", null);
+    businessStore.setKey("initialized", false);
+  },
+  // Get business data (with auto-init)
+  async getBusiness() {
+    const state = businessStore.get();
+    if (!state.initialized || !state.data) {
+      await this.init();
+    }
+    return businessStore.get().data;
+  }
+};
+if (typeof window !== "undefined" && exports.BUSINESS_ID) {
+  businessActions.init().catch(console.error);
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.2";
+var SUPPORTED_FRAMEWORKS = ["astro", "react", "vue", "svelte", "vanilla"];
+function initArky(config) {
+  if (!config.apiUrl) {
+    throw new Error("apiUrl is required");
+  }
+  if (!config.businessId) {
+    throw new Error("businessId is required");
+  }
+  setGlobalConfig(config);
+  if (typeof window !== "undefined") {
+    businessActions.init().catch(console.error);
+  }
+  return config;
+}
+
+exports.ERROR_CODES = ERROR_CODES;
+exports.ERROR_CONSTANTS = ERROR_CONSTANTS;
+exports.PaymentMethod = PaymentMethod;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SUPPORTED_FRAMEWORKS = SUPPORTED_FRAMEWORKS;
+exports.categorify = categorify;
+exports.cmsApi = cmsApi;
+exports.convertServerErrorToRequestError = convertServerErrorToRequestError;
+exports.convertToMajor = convertToMajor;
+exports.convertToMinor = convertToMinor;
+exports.createPaymentForCheckout = createPaymentForCheckout;
+exports.errors = errors;
+exports.eshopApi = eshopApi;
+exports.extractBlockValues = extractBlockValues;
+exports.fetchSvgContent = fetchSvgContent;
+exports.findTimeZone = findTimeZone;
+exports.formatBlockValue = formatBlockValue;
+exports.formatCurrencyAmount = formatCurrencyAmount;
+exports.formatDate = formatDate;
+exports.formatMinor = formatMinor;
+exports.formatPayment = formatPayment;
+exports.getBlockFromArray = getBlockFromArray;
+exports.getBlockLabel = getBlockLabel;
+exports.getBlockObjectValues = getBlockObjectValues;
+exports.getBlockTextValue = getBlockTextValue;
+exports.getBlockValue = getBlockValue;
+exports.getBlockValues = getBlockValues;
+exports.getBusinessConfig = getBusinessConfig;
+exports.getCurrencyFromMarket = getCurrencyFromMarket;
+exports.getErrorMessage = getErrorMessage;
+exports.getGalleryThumbnail = getGalleryThumbnail;
+exports.getGlobalConfig = getGlobalConfig;
+exports.getGuestToken = getGuestToken;
+exports.getImageUrl = getImageUrl;
+exports.getMarketPrice = getMarketPrice;
+exports.getPriceAmount = getPriceAmount;
+exports.getSvgContentForAstro = getSvgContentForAstro;
+exports.getSymbol = getSymbol;
+exports.httpClient = http_default;
+exports.humanize = humanize;
+exports.initArky = initArky;
+exports.injectSvgIntoElement = injectSvgIntoElement;
+exports.isErrorCode = isErrorCode;
+exports.newsletterApi = newsletterApi;
+exports.prepareBlocksForSubmission = prepareBlocksForSubmission;
+exports.reservationApi = reservationApi;
+exports.setGlobalConfig = setGlobalConfig;
+exports.slugify = slugify;
+exports.thumbnailUrl = thumbnailUrl;
+exports.transformErrors = transformErrors;
+exports.translateMap = translateMap;
+exports.tzGroups = tzGroups;
+exports.updateProfilePhone = updateProfilePhone;
+exports.validateEmail = validateEmail;
+exports.validatePhoneNumber = validatePhoneNumber;
+exports.validateRequired = validateRequired;
+exports.validateVerificationCode = validateVerificationCode;
+exports.verifyPhoneCode = verifyPhoneCode;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map