arky-sdk 0.3.0 → 0.3.1

package/dist/index.cjs

@@ -1,19 +1,5 @@
 'use strict';
 
-// src/config.ts
-var globalConfig = null;
-function setGlobalConfig(config) {
-  globalConfig = config;
-}
-function getGlobalConfig() {
-  if (!globalConfig) {
-    throw new Error(
-      "Arky SDK not initialized. Call initArky() first."
-    );
-  }
-  return globalConfig;
-}
-
 // src/types/index.ts
 var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
   PaymentMethod2["Cash"] = "CASH";
@@ -22,725 +8,888 @@ var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
   return PaymentMethod2;
 })(PaymentMethod || {});
 
-// 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}`);
+// src/api/cms.ts
+var createCmsApi = (apiConfig) => {
+  return {
+    // ===== COLLECTIONS =====
+    async createCollection(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/collections`,
+        params,
+        options
+      );
+    },
+    async updateCollection(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/collections/${params.id}`,
+        params,
+        options
+      );
+    },
+    async deleteCollection(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/collections/${params.id}`,
+        options
+      );
+    },
+    async getCollection(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/collections/${params.id}`,
+        options
+      );
+    },
+    async getCollections(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/collections`,
+        {
+          ...options,
+          params: params || {}
+        }
+      );
+    },
+    async generateBlocks(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/collections/blocks/generate`,
+        params,
+        options
+      );
+    },
+    // ===== ENTRIES =====
+    // Note: Backend uses /entries NOT /collections/{id}/entries
+    async getCollectionEntries(params, options) {
+      const { collectionId, ...queryParams } = params || {};
+      const finalParams = collectionId ? { ...queryParams, owner: `collection:${collectionId}` } : queryParams;
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/entries`,
+        {
+          ...options,
+          params: finalParams
+        }
+      );
+    },
+    async createCollectionEntry(params, options) {
+      const { collectionId, owner, ...rest } = params;
+      const payload = {
+        ...rest,
+        owner: owner || (collectionId ? `collection:${collectionId}` : void 0)
+      };
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/entries`,
+        payload,
+        options
+      );
+    },
+    async updateCollectionEntry(params, options) {
+      const { id, collectionId, owner, ...rest } = params;
+      const payload = {
+        ...rest,
+        owner: owner || (collectionId ? `collection:${collectionId}` : void 0)
+      };
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/entries/${id}`,
+        payload,
+        options
+      );
+    },
+    async deleteCollectionEntry(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/entries/${params.id}`,
+        options
+      );
+    },
+    async getCollectionEntry(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/entries/${params.id}`,
+        options
+      );
+    },
+    async sendEntry(params, options) {
+      const { entryId, scheduledAt } = params;
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/entries/${entryId}/send`,
+        {
+          businessId: apiConfig.businessId,
+          entryId,
+          scheduledAt: scheduledAt || Date.now()
+        },
+        options
+      );
+    },
+    // ===== VARIABLES / METADATA =====
+    async getVariableMetadata(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/collections/entry-types/${params.entryType}/variables`,
+        options
+      );
     }
-    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 config = getGlobalConfig();
-  const url = `${config.apiUrl}/v1/businesses/${config.businessId}/collections/${id}`;
-  const { value } = await http_default.get(url);
-  return value;
-};
-var getCollections = async ({ name = null, ids = null }) => {
-  const config = getGlobalConfig();
-  const url = `${config.apiUrl}/v1/businesses/${config.businessId}/collections`;
-  const response = await http_default.get(url, {
-    params: { name, ids }
-  });
-  return response.value;
-};
-var getCollectionEntries = async ({
-  collectionId,
-  limit,
-  cursor,
-  ids = null
-}) => {
-  const config = getGlobalConfig();
-  const url = `${config.apiUrl}/v1/businesses/${config.businessId}/collections/${collectionId}/entries`;
-  const response = await http_default.get(url, {
-    params: { limit, cursor, ids }
-  });
-  return response.value;
-};
-var createCollectionEntry = async (collectionEntryData) => {
-  const config = getGlobalConfig();
-  const url = `${config.apiUrl}/v1/businesses/${config.businessId}/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 config = getGlobalConfig();
-  const url = `${config.apiUrl}/v1/businesses/${config.businessId}/collections/${collectionId}/entries/${id}`;
-  const response = await http_default.get(url);
-  return response;
-};
-var cmsApi = {
-  getCollection,
-  getCollections,
-  getCollectionEntries,
-  getCollectionEntry,
-  createCollectionEntry
+// src/api/eshop.ts
+var createEshopApi = (apiConfig) => {
+  return {
+    // ===== PRODUCTS =====
+    async createProduct(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/products`,
+        params,
+        options
+      );
+    },
+    async updateProduct(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/products/${params.id}`,
+        params,
+        options
+      );
+    },
+    async deleteProduct(id, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/products/${id}`,
+        options
+      );
+    },
+    async getProduct(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/products/${params.id}`,
+        options
+      );
+    },
+    async getProducts(params, options) {
+      const queryParams = params ? { ...params } : {};
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${encodeURIComponent(apiConfig.businessId)}/products`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getProductBySlug(params, options) {
+      const { businessId, slug } = params;
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${encodeURIComponent(businessId)}/products/slug/${encodeURIComponent(businessId)}/${encodeURIComponent(slug)}`,
+        options
+      );
+    },
+    // ===== ORDERS =====
+    async createOrder(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/orders`,
+        params,
+        options
+      );
+    },
+    async updateOrder(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/orders/update`,
+        params,
+        options
+      );
+    },
+    async getOrder(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/orders/${params.id}`,
+        options
+      );
+    },
+    async getOrders(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/orders`,
+        {
+          ...options,
+          params: params || {}
+        }
+      );
+    },
+    async updateOrderStatus(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/orders/${params.id}/status`,
+        params,
+        options
+      );
+    },
+    async updateOrderPaymentStatus(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/orders/${params.id}/payment-status`,
+        params,
+        options
+      );
+    },
+    // ===== PAYMENTS =====
+    async getQuote(params, options) {
+      const lines = params.items.map((item) => ({
+        type: "PRODUCT_VARIANT",
+        productId: item.productId,
+        variantId: item.variantId,
+        quantity: item.quantity
+      }));
+      const payload = {
+        businessId: apiConfig.businessId,
+        market: params.market,
+        currency: params.currency,
+        paymentMethod: params.paymentMethod,
+        lines,
+        ...params.shippingMethodId && { shippingMethodId: params.shippingMethodId },
+        ...params.promoCode && { promoCode: params.promoCode }
+      };
+      return apiConfig.httpClient.post(`/v1/payments/quote`, payload, options);
+    },
+    async checkout(params, options) {
+      const payload = {
+        businessId: apiConfig.businessId,
+        market: params.market,
+        paymentMethod: params.paymentMethod,
+        shippingMethodId: params.shippingMethodId,
+        items: params.items,
+        blocks: params.blocks || [],
+        ...params.promoCode && { promoCode: params.promoCode }
+      };
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/orders/checkout`,
+        payload,
+        options
+      );
+    }
+  };
 };
 
 // src/api/reservation.ts
-var reservationApi = {
-  // Get quote for reservation parts
-  async getQuote({
-    token,
-    businessId,
-    market,
-    currency,
-    userId,
-    parts,
-    paymentMethod = "CASH",
-    promoCode
-  }) {
-    try {
-      const config = getGlobalConfig();
-      const lines = parts.map((part) => ({
+var createReservationApi = (apiConfig) => {
+  return {
+    // ===== RESERVATIONS =====
+    async createReservation(params, options) {
+      return apiConfig.httpClient.post(`/v1/reservations`, params, {
+        successMessage: "Reservation created successfully",
+        errorMessage: "Failed to create reservation",
+        ...options
+      });
+    },
+    async updateReservation(params, options) {
+      const { id, ...payload } = params;
+      return apiConfig.httpClient.put(`/v1/reservations/${id}`, payload, {
+        successMessage: "Reservation updated successfully",
+        errorMessage: "Failed to update reservation",
+        ...options
+      });
+    },
+    async checkout(params, options) {
+      const payload = {
+        businessId: apiConfig.businessId,
+        blocks: params.blocks || [],
+        market: params.market || "US",
+        parts: params.parts,
+        ...params.paymentMethod && { paymentMethod: params.paymentMethod },
+        ...params.promoCode && { promoCode: params.promoCode }
+      };
+      return apiConfig.httpClient.post(`/v1/reservations/checkout`, payload, {
+        successMessage: "Reservation checkout completed",
+        errorMessage: "Failed to complete checkout",
+        ...options
+      });
+    },
+    async getReservation(params, options) {
+      return apiConfig.httpClient.get(`/v1/reservations/${params.id}`, {
+        ...options,
+        params: params.businessId ? { businessId: params.businessId } : {}
+      });
+    },
+    async getReservationParts(params, options) {
+      return apiConfig.httpClient.get(`/v1/reservations/parts`, {
+        ...options,
+        params: params || {}
+      });
+    },
+    async searchReservations(params, options) {
+      return apiConfig.httpClient.get(`/v1/reservations/search`, {
+        ...options,
+        params
+      });
+    },
+    async searchMyReservations(params, options) {
+      return apiConfig.httpClient.get(`/v1/reservations`, {
+        ...options,
+        params: params || {}
+      });
+    },
+    // ===== QUOTES =====
+    async getQuote(params, options) {
+      const lines = params.parts.map((part) => ({
         type: "SERVICE",
         serviceId: part.serviceId,
         quantity: 1
       }));
       const payload = {
-        businessId,
-        market,
-        currency,
-        userId,
-        paymentMethod,
+        businessId: apiConfig.businessId,
+        market: params.market,
+        currency: params.currency,
+        paymentMethod: params.paymentMethod,
         lines,
-        promoCode: promoCode || void 0,
-        shippingMethodId: null
+        ...params.promoCode && { promoCode: params.promoCode }
       };
-      const res = await fetch(`${config.apiUrl}/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" };
+      return apiConfig.httpClient.post(`/v1/payments/quote`, payload, options);
+    },
+    // ===== SERVICES =====
+    async createService(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/services`,
+        params,
+        {
+          successMessage: "Service created successfully",
+          errorMessage: "Failed to create service",
+          ...options
         }
-      }
-      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 config = getGlobalConfig();
-    const url = `${config.apiUrl}/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 config = getGlobalConfig();
-    const url = `${config.apiUrl}/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: []
-      };
+      );
+    },
+    async updateService(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/services/${params.id}`,
+        params,
+        {
+          successMessage: "Service updated successfully",
+          errorMessage: "Failed to update service",
+          ...options
+        }
+      );
+    },
+    async deleteService(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/services/${params.id}`,
+        {
+          successMessage: "Service deleted successfully",
+          errorMessage: "Failed to delete service",
+          ...options
+        }
+      );
+    },
+    async getService(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/services/${params.id}`,
+        options
+      );
+    },
+    async getServices(params, options) {
+      const queryParams = params ? { ...params } : {};
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/services`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getAvailableSlots(params, options) {
+      const { serviceId, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/services/${serviceId}/available-slots`,
+        {
+          ...options,
+          params: {
+            ...queryParams,
+            limit: queryParams.limit || 1e3
+          }
+        }
+      );
+    },
+    // ===== PROVIDERS =====
+    async createProvider(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/providers`,
+        params,
+        {
+          successMessage: "Provider created successfully",
+          errorMessage: "Failed to create provider",
+          ...options
+        }
+      );
+    },
+    async updateProvider(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/providers/${params.id}`,
+        params,
+        {
+          successMessage: "Provider updated successfully",
+          errorMessage: "Failed to update provider",
+          ...options
+        }
+      );
+    },
+    async deleteProvider(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/providers/${params.id}`,
+        {
+          successMessage: "Provider deleted successfully",
+          errorMessage: "Failed to delete provider",
+          ...options
+        }
+      );
+    },
+    async getProvider(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/providers/${params.id}`,
+        options
+      );
+    },
+    async getProviders(params, options) {
+      const { businessId, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/providers`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
+    },
+    async getProviderWorkingTime(params, options) {
+      const { businessId, providerId, ...queryParams } = params;
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/providers/${providerId}/working-time`,
+        {
+          ...options,
+          params: queryParams
+        }
+      );
     }
-  },
-  // Get guest token or create a new one
-  async getGuestToken() {
-    try {
-      const config = getGlobalConfig();
-      const res = await fetch(`${config.apiUrl}/v1/users/login`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ provider: "GUEST" })
+  };
+};
+
+// src/api/newsletter.ts
+var createNewsletterApi = (apiConfig) => {
+  return {
+    // ===== NEWSLETTERS =====
+    async find(params, options) {
+      return apiConfig.httpClient.get(`/v1/newsletters`, {
+        ...options,
+        params: { businessId: params.businessId }
       });
-      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
+    },
+    async get(params, options) {
+      return apiConfig.httpClient.get(`/v1/newsletters/${params.id}`, options);
+    },
+    async create(params, options) {
+      return apiConfig.httpClient.post(`/v1/newsletters`, params, options);
+    },
+    async update(params, options) {
+      return apiConfig.httpClient.put(`/v1/newsletters/${params.id}`, params, options);
+    },
+    async delete(params, options) {
+      return apiConfig.httpClient.delete(`/v1/newsletters/${params.id}`, options);
+    },
+    // ===== SUBSCRIBERS =====
+    async getSubscribers(params, options) {
+      return apiConfig.httpClient.get(`/v1/newsletters/${params.id}/subscribers`, options);
+    },
+    async subscribe(params, options) {
+      const { newsletterId, email, customerId, payment } = params;
+      const payload = {
+        newsletterId,
+        email,
+        market: "US",
+        ...customerId && { customerId },
+        ...payment && { payment }
       };
-    }
-  },
-  // Update user's phone number
-  async updateProfilePhone({ token, phoneNumber }) {
-    try {
-      const config = getGlobalConfig();
-      const res = await fetch(`${config.apiUrl}/v1/users/update`, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          phoneNumber,
-          phoneNumbers: [],
-          addresses: []
-        })
+      return apiConfig.httpClient.post(
+        `/v1/newsletters/${newsletterId}/subscribe`,
+        payload,
+        options
+      );
+    },
+    async unsubscribe(params, options) {
+      return apiConfig.httpClient.post(`/v1/newsletters/unsubscribe`, params, options);
+    },
+    async unsubscribeWithToken(params, options) {
+      return apiConfig.httpClient.get(`/v1/newsletters/unsubscribe`, {
+        ...options,
+        params
       });
-      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 config = getGlobalConfig();
-      const res = await fetch(`${config.apiUrl}/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
+  };
+};
+
+// src/api/user.ts
+var createUserApi = (apiConfig) => {
+  return {
+    // ===== USER PROFILE =====
+    async updateUser(params, options) {
+      const payload = {
+        name: params.name,
+        phoneNumbers: params.phoneNumbers || [],
+        phoneNumber: params.phoneNumber || null,
+        addresses: params.addresses || [],
+        ...params.apiTokens !== void 0 && { apiTokens: params.apiTokens }
       };
-    }
-  },
-  // Complete reservation checkout - Backend calculates currency from market
-  async checkout({
-    token,
-    businessId,
-    parts,
-    paymentMethod = "CASH",
-    blocks = [],
-    market = "US",
-    promoCode
-  }) {
-    try {
-      const config = getGlobalConfig();
+      return apiConfig.httpClient.put("/v1/users/update", payload, options);
+    },
+    async updateProfilePhone(params, options) {
       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
-        }))
+        phoneNumbers: [],
+        phoneNumber: params.phoneNumber,
+        addresses: []
       };
-      if (paymentMethod !== void 0) {
-        payload.paymentMethod = paymentMethod;
-      }
-      if (promoCode) {
-        payload.promoCode = promoCode;
-      }
-      const res = await fetch(`${config.apiUrl}/v1/reservations/checkout`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
+      return apiConfig.httpClient.put("/v1/users/update", payload, options);
+    },
+    async verifyPhoneCode(params, options) {
+      return apiConfig.httpClient.put("/v1/users/confirm/phone-number", params, options);
+    },
+    async getUserLocation(options) {
+      return apiConfig.httpClient.get("/v1/users/location", options);
+    },
+    async getMe(options) {
+      return apiConfig.httpClient.get("/v1/users/me", options);
+    },
+    async searchUsers(params, options) {
+      return apiConfig.httpClient.get("/v1/users/search", {
+        ...options,
+        params
+      });
+    },
+    async setUserRole(params, options) {
+      return apiConfig.httpClient.put("/v1/users/set-role", params, options);
+    },
+    // ===== AUTHENTICATION =====
+    async loginUser(params, options) {
+      return apiConfig.httpClient.post("/v1/users/login", params, options);
+    },
+    async registerUser(params, options) {
+      return apiConfig.httpClient.post("/v1/users/register", params, options);
+    },
+    async logout(options) {
+      return apiConfig.httpClient.post("/v1/users/logout", {}, options);
+    },
+    async confirmUser(params, options) {
+      return apiConfig.httpClient.put("/v1/users/confirm", params, options);
+    },
+    async getLoginUrl(params, options) {
+      return apiConfig.httpClient.get("/v1/users/login/url", {
+        ...options,
+        params
       });
-      if (!res.ok) {
-        const error = await res.text() || res.statusText;
-        throw new Error(error);
+    },
+    async getGuestToken(params, options) {
+      if (params.existingToken) {
+        return params.existingToken;
       }
-      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
-      };
+      const result = await apiConfig.httpClient.post("/v1/users/login", {
+        provider: "GUEST"
+      }, options);
+      const token = result.accessToken || result.token || "";
+      if (token) {
+        apiConfig.setTokens(result);
+      }
+      return token;
+    },
+    // ===== PASSWORD MANAGEMENT =====
+    async forgotPassword(params, options) {
+      return apiConfig.httpClient.post("/v1/users/forgot-password", params, options);
+    },
+    async resetForgotPassword(params, options) {
+      return apiConfig.httpClient.post("/v1/users/reset-forgot-password", params, options);
+    },
+    async resetPassword(params, options) {
+      return apiConfig.httpClient.post("/v1/users/reset-password", params, options);
     }
-  }
+  };
 };
 
-// src/api/eshop.ts
-var eshopApi = {
-  // Get products
-  async getProducts({
-    businessId,
-    categoryIds = null,
-    status = "ACTIVE",
-    limit = 20,
-    cursor = null
-  }) {
-    const config = getGlobalConfig();
-    const url = `${config.apiUrl}/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 config = getGlobalConfig();
-      const url = `${config.apiUrl}/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,
-    userId,
-    paymentMethod,
-    shippingMethodId,
-    promoCode
-  }) {
-    try {
-      const config = getGlobalConfig();
-      const lines = items.map((item) => ({
-        type: "PRODUCT_VARIANT",
-        productId: item.productId,
-        variantId: item.variantId,
-        quantity: item.quantity
-      }));
-      const payload = {
-        businessId,
-        market,
-        currency,
-        userId,
-        paymentMethod,
-        lines,
-        ...shippingMethodId && { shippingMethodId },
-        ...promoCode && { promoCode }
-      };
-      const res = await fetch(`${config.apiUrl}/v1/payments/quote`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
+// src/api/business.ts
+var createBusinessApi = (apiConfig) => {
+  return {
+    async createBusiness(params, options) {
+      return apiConfig.httpClient.post(`/v1/businesses`, params, options);
+    },
+    async updateBusiness(params, options) {
+      return apiConfig.httpClient.put(`/v1/businesses/${params.id}`, params, options);
+    },
+    async deleteBusiness(params, options) {
+      return apiConfig.httpClient.delete(`/v1/businesses/${params.id}`, options);
+    },
+    async getBusiness(params, options) {
+      return apiConfig.httpClient.get(`/v1/businesses/${params.id}`, options);
+    },
+    async getBusinesses(options) {
+      return apiConfig.httpClient.get(`/v1/businesses`, options);
+    },
+    async getBusinessParents(params, options) {
+      return apiConfig.httpClient.get(`/v1/businesses/${params.businessId}/parents`, options);
+    },
+    async triggerBuilds(params, options) {
+      return apiConfig.httpClient.post(`/v1/businesses/${params.id}/trigger-builds`, {}, options);
+    },
+    async getSubscriptionPlans(options) {
+      return apiConfig.httpClient.get("/v1/businesses/plans", options);
+    },
+    async getSubscription(params, options) {
+      return apiConfig.httpClient.get(`/v1/businesses/${params.businessId}/subscription`, options);
+    },
+    async createSubscription(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${params.businessId}/subscription`,
+        params,
+        options
+      );
+    },
+    async updateSubscription(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${params.businessId}/subscription`,
+        params,
+        options
+      );
+    },
+    async cancelSubscription(params, options) {
+      return apiConfig.httpClient.delete(`/v1/businesses/${params.businessId}/subscription`, {
+        ...options,
+        params: { immediately: params.immediately || false }
       });
-      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 };
+    },
+    async reactivateSubscription(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${params.businessId}/subscription/reactivate`,
+        params,
+        options
+      );
+    },
+    async createPortalSession(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${params.businessId}/subscription/portal`,
+        params,
+        options
+      );
+    },
+    async inviteUser(params, options) {
+      const { businessId, ...payload } = params;
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${businessId}/invitation`,
+        payload,
+        options
+      );
+    },
+    async handleInvitation(params, options) {
+      const { businessId, ...payload } = params;
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${businessId}/invitation`,
+        payload,
+        options
+      );
+    },
+    async testWebhook(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${params.businessId}/webhooks/test`,
+        params.webhook,
+        options
+      );
+    },
+    async getBusinessMedia(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${params.id}/media`,
+        {
+          ...options,
+          params: {
+            cursor: params.cursor,
+            limit: params.limit || 20
+          }
         }
-      }
-      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
-      };
+      );
+    },
+    async setProviderSchedule(params, options) {
+      const { id, ...payload } = params;
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${id}/schedules`,
+        payload,
+        options
+      );
     }
-  },
-  // Checkout - Backend calculates currency from market
-  async checkout({
-    token,
-    businessId,
-    items,
-    paymentMethod,
-    blocks,
-    market = "US",
-    shippingMethodId,
-    promoCode,
-    paymentIntentId = null
-  }) {
-    try {
-      const config = getGlobalConfig();
-      const payload = {
-        businessId,
-        items,
-        paymentMethod,
-        blocks,
-        market,
-        ...shippingMethodId && { shippingMethodId },
-        ...promoCode && { promoCode },
-        ...paymentIntentId && { paymentIntentId }
-      };
-      const res = await fetch(`${config.apiUrl}/v1/businesses/${encodeURIComponent(businessId)}/orders/checkout`, {
+  };
+};
+
+// src/api/media.ts
+var createMediaApi = (apiConfig) => {
+  return {
+    async uploadBusinessMedia(params) {
+      const { businessId, files = [], urls = [] } = params;
+      const url = `${apiConfig.baseUrl}/v1/businesses/${businessId}/upload`;
+      const formData = new FormData();
+      files.forEach((file) => formData.append("files", file));
+      urls.forEach((url2) => formData.append("files", url2));
+      const tokens = await apiConfig.getTokens();
+      const response = await fetch(url, {
         method: "POST",
+        body: formData,
         headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
+          Authorization: `Bearer ${tokens.accessToken}`
+        }
       });
-      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 };
+      if (!response.ok) {
+        throw new Error("Upload failed, server said no");
+      }
+      return await response.json();
+    },
+    async deleteBusinessMedia(params, options) {
+      const { id, mediaId } = params;
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${id}/upload`,
+        {
+          ...options,
+          params: { mediaId }
         }
+      );
+    },
+    async getBusinessMedia(params) {
+      const { businessId, cursor = null, limit = 20 } = params;
+      const url = `${apiConfig.baseUrl}/v1/businesses/${businessId}/media`;
+      const queryParams = { limit };
+      if (cursor) queryParams.cursor = cursor;
+      const queryString = new URLSearchParams(queryParams).toString();
+      const response = await fetch(`${url}?${queryString}`);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        throw new Error(errorData?.message || "Failed to fetch media");
       }
-      const json = text ? JSON.parse(text) : null;
-      return { success: true, data: json };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
+      return await response.json();
     }
-  },
-  // Create payment intent for Stripe
-  async createPaymentIntent({ amount, currency, businessId }) {
-    try {
-      const config = getGlobalConfig();
-      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(`${config.apiUrl}/v1/businesses/${encodeURIComponent(businessId)}/payment/create-intent`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          amount,
-          currency,
-          businessId
-        })
+  };
+};
+
+// src/api/role.ts
+var createRoleApi = (apiConfig) => {
+  return {
+    async createRole(params, options) {
+      return apiConfig.httpClient.post(`/v1/roles`, params, options);
+    },
+    async updateRole(params, options) {
+      return apiConfig.httpClient.put(`/v1/roles/${params.id}`, params, options);
+    },
+    async deleteRole(params, options) {
+      return apiConfig.httpClient.delete(`/v1/roles/${params.id}`, options);
+    },
+    async getRole(params, options) {
+      return apiConfig.httpClient.get(`/v1/roles/${params.id}`, options);
+    },
+    async getRoles(params, options) {
+      return apiConfig.httpClient.get(`/v1/roles`, {
+        ...options,
+        params: params ? {
+          businessId: apiConfig.businessId,
+          action: params.action || "READ"
+        } : {
+          businessId: apiConfig.businessId,
+          action: "READ"
+        }
       });
-      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 config = getGlobalConfig();
-    const params = new URLSearchParams({
-      businessId: payload.business_id
-    });
-    const url = `${config.apiUrl}/v1/newsletters?${params.toString()}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
+// src/api/notification.ts
+var createNotificationApi = (apiConfig) => {
+  return {
+    async getNotifications(params, options) {
+      return apiConfig.httpClient.get(`/v1/notifications`, {
+        ...options,
+        params: {
+          limit: params.limit,
+          previous_id: params.previous_id
+        }
+      });
+    },
+    async updateNotifications(options) {
+      return apiConfig.httpClient.put(`/v1/notifications`, { seen: true }, options);
+    },
+    async trackEmailOpen(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/notifications/track/email/${params.trackingPixelId}`,
+        options
+      );
+    },
+    async getDeliveryStats(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/notifications/track/stats/${apiConfig.businessId}`,
+        options
+      );
     }
-    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 config = getGlobalConfig();
-    const url = `${config.apiUrl}/v1/newsletters/${id}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
+  };
+};
+
+// src/api/promoCode.ts
+var createPromoCodeApi = (apiConfig) => {
+  return {
+    async createPromoCode(params, options) {
+      return apiConfig.httpClient.post(
+        `/v1/businesses/${apiConfig.businessId}/promo-codes`,
+        params,
+        options
+      );
+    },
+    async updatePromoCode(params, options) {
+      return apiConfig.httpClient.put(
+        `/v1/businesses/${apiConfig.businessId}/promo-codes/${params.id}`,
+        params,
+        options
+      );
+    },
+    async deletePromoCode(params, options) {
+      return apiConfig.httpClient.delete(
+        `/v1/businesses/${apiConfig.businessId}/promo-codes/${params.id}`,
+        options
+      );
+    },
+    async getPromoCode(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/businesses/${apiConfig.businessId}/promo-codes/${params.id}`,
+        options
+      );
+    },
+    async getPromoCodes(params, options) {
+      const { businessId, statuses, ...restParams } = params;
+      return apiConfig.httpClient.get(`/v1/businesses/${apiConfig.businessId}/promo-codes`, {
+        ...options,
+        params: {
+          ...restParams,
+          statuses: statuses && statuses.length > 0 ? statuses : void 0
+        }
+      });
     }
-    return await response.json();
-  },
-  async subscribe(payload) {
-    try {
-      const config = getGlobalConfig();
-      const url = `${config.apiUrl}/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 }
-        })
+  };
+};
+
+// src/api/analytics.ts
+var createAnalyticsApi = (apiConfig) => {
+  return {
+    async getAnalytics(params, options) {
+      const { businessId, ...queryParams } = params;
+      return apiConfig.httpClient.get(`/v1/analytics/${apiConfig.businessId}`, {
+        ...options,
+        params: queryParams
       });
-      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"
-      };
+    },
+    async getAnalyticsHealth(params, options) {
+      return apiConfig.httpClient.get(`/v1/analytics/${apiConfig.businessId}/health`, options);
+    },
+    async setupAnalytics(params, options) {
+      return apiConfig.httpClient.post(`/v1/analytics/admin/setup`, params, options);
     }
-  }
+  };
 };
 
-// src/services/auth.ts
-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 config = getGlobalConfig();
-    const response = await fetch(`${config.apiUrl}/v1/businesses/${businessId}`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch business config: ${response.status}`);
+// src/api/payment.ts
+var createPaymentApi = (apiConfig) => {
+  return {
+    async handleStripeWebhook(params, options) {
+      return apiConfig.httpClient.post(`/v1/payments/webhooks/stripe`, params, options);
+    },
+    async getBusinessMarkets(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/payments/businesses/${apiConfig.businessId}/markets`,
+        options
+      );
+    },
+    async getBusinessMarket(params, options) {
+      return apiConfig.httpClient.get(
+        `/v1/payments/businesses/${apiConfig.businessId}/markets/${params.marketId}`,
+        options
+      );
     }
-    const business = await response.json();
-    return {
-      success: true,
-      data: business
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-}
+  };
+};
 
 // src/utils/blocks.ts
 function getBlockLabel(block, locale = "en") {
@@ -872,10 +1021,8 @@ var getBlockFromArray = (entry, blockKey, locale = "en") => {
     return acc;
   });
 };
-var getImageUrl = (imageBlock, isBlock = true) => {
+var getImageUrl = (imageBlock, isBlock = true, storageUrl = "https://storage.arky.io/dev") => {
   if (!imageBlock) return null;
-  const config = getGlobalConfig();
-  const storageUrl = config.storageUrl || "https://storage.arky.io/dev";
   const isExternalUrl = (url) => {
     return url.startsWith("http://") || url.startsWith("https://");
   };
@@ -921,9 +1068,7 @@ function getGalleryThumbnail(gallery) {
   const res = item.media.resolutions.thumbnail || item.media.resolutions.original;
   return res?.url || null;
 }
-function thumbnailUrl(service) {
-  const config = getGlobalConfig();
-  const storageUrl = config.storageUrl || "";
+function thumbnailUrl(service, storageUrl = "") {
   const path = getGalleryThumbnail(service.gallery);
   return path ? `${storageUrl}/${path}` : null;
 }
@@ -942,6 +1087,95 @@ var translateMap = (labels, lang, fallback = "unknown") => {
   return label;
 };
 
+// src/utils/currency.ts
+function getCurrencySymbol(currency) {
+  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[currency.toUpperCase()] || currency;
+}
+var SYMBOL_AFTER_CURRENCIES = ["SEK", "NOK", "DKK", "PLN", "CZK", "HUF", "RON", "BGN", "HRK"];
+function isSymbolAfterCurrency(currency) {
+  return SYMBOL_AFTER_CURRENCIES.includes(currency.toUpperCase());
+}
+
 // src/utils/errors.ts
 var ERROR_CODES = {
   // General errors
@@ -976,7 +1210,7 @@ var ERROR_CODES = {
   "BUSINESS.007": "BUSINESS.BUSINESS_ID_REQUIRED",
   "BUSINESS.010": "BUSINESS.DESCRIPTION_REQUIRED",
   "BUSINESS.011": "BUSINESS.SLUG_INVALID",
-  // Provider errors  
+  // Provider errors
   "PROVIDER.001": "PROVIDER.NOT_FOUND",
   "PROVIDER.002": "PROVIDER.FAILED_TO_CREATE",
   "PROVIDER.003": "PROVIDER.FAILED_TO_UPDATE",
@@ -1026,11 +1260,11 @@ var transformErrors = (zodError) => {
   if (!zodError.issues) return customErrors;
   zodError.issues.forEach((issue) => {
     const field = issue.path.join(".");
-    const message = issue.message;
+    const error = issue.message;
     if (!customErrors.some(
-      (customError) => customError.field === field && customError.message === message
+      (customError) => customError.field === field && customError.error === error
     )) {
-      customErrors.push({ field, message });
+      customErrors.push({ field, error });
     }
   });
   return customErrors;
@@ -1042,106 +1276,44 @@ var convertServerErrorToRequestError = (serverError, renameRules) => {
       const field = renameRules && renameRules[validationError.field] ? renameRules[validationError.field] : validationError.field;
       return {
         field,
-        message: ERROR_CODES[validationError.code] || "Unknown error"
+        error: validationError.error || "GENERAL.VALIDATION_ERROR"
       };
     })
   };
 };
 var errors = ERROR_CONSTANTS;
 
-// src/utils/currency.ts
-function getCurrencySymbol(currency) {
-  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[currency.toUpperCase()] || currency;
+// src/utils/i18n.ts
+var defaultLocale = "en";
+function setDefaultLocale(locale) {
+  defaultLocale = locale;
+}
+function getLocale() {
+  if (typeof window !== "undefined" && window.navigator) {
+    return window.navigator.language.split("-")[0] || defaultLocale;
+  }
+  return defaultLocale;
+}
+function getLocaleFromUrl(url) {
+  const pathParts = url.pathname.split("/").filter(Boolean);
+  const potentialLocale = pathParts[0];
+  const validLocales = ["en", "fr", "es", "de", "it", "pt", "ja", "zh", "ko", "ru"];
+  if (potentialLocale && validLocales.includes(potentialLocale)) {
+    return potentialLocale;
+  }
+  return getLocale();
+}
+function getLocalizedString(value, locale) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "object") {
+    const targetLocale = locale || getLocale();
+    return value[targetLocale] || value["en"] || value[Object.keys(value)[0]] || "";
+  }
+  return String(value);
 }
 
 // src/utils/price.ts
-var CURRENCY_SYMBOLS = {
-  "USD": "$",
-  "EUR": "\u20AC",
-  "GBP": "\xA3",
-  "CAD": "C$",
-  "AUD": "A$"
-};
 var MARKET_CURRENCIES = {
   "US": "USD",
   "EU": "EUR",
@@ -1155,9 +1327,6 @@ function convertToMajor(minorAmount) {
 function convertToMinor(majorAmount) {
   return Math.round((majorAmount ?? 0) * 100);
 }
-function getSymbol(currency) {
-  return CURRENCY_SYMBOLS[currency] || "$";
-}
 function getCurrencyFromMarket(marketId) {
   return MARKET_CURRENCIES[marketId] || "USD";
 }
@@ -1167,7 +1336,10 @@ function formatCurrencyAmount(amount, currency, options = {}) {
   if (!showSymbols) {
     return `${roundedAmount} ${currency}`;
   }
-  const symbol = customSymbol || getSymbol(currency);
+  const symbol = customSymbol || getCurrencySymbol(currency);
+  if (isSymbolAfterCurrency(currency)) {
+    return `${roundedAmount} ${symbol}`;
+  }
   return `${symbol}${roundedAmount}`;
 }
 function formatMinor(amountMinor, currency, options = {}) {
@@ -1212,11 +1384,11 @@ function getMarketPrice(prices, marketId, businessMarkets, options = {}) {
       symbol = getCurrencySymbol(currency);
     } else {
       currency = getCurrencyFromMarket(price.market);
-      symbol = getSymbol(currency);
+      symbol = getCurrencySymbol(currency);
     }
   } else {
     currency = getCurrencyFromMarket(price.market);
-    symbol = getSymbol(currency);
+    symbol = getCurrencySymbol(currency);
   }
   const formattedPrice = formatMinor(price.amount ?? 0, currency, {
     showSymbols,
@@ -1254,6 +1426,32 @@ function createPaymentForCheckout(subtotalMinor, marketId, currency, paymentMeth
   };
 }
 
+// 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/utils/svg.ts
 async function fetchSvgContent(mediaObject) {
   if (!mediaObject) return null;
@@ -1419,18 +1617,169 @@ function validateRequired(value, fieldName = "This field") {
   return { isValid: true };
 }
 
+// src/services/createHttpClient.ts
+function createHttpClient(cfg) {
+  const refreshEndpoint = `${cfg.baseUrl}/v1/users/refresh-access-token`;
+  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 { accessToken, refreshToken, provider, expiresAt } = await cfg.getTokens();
+    const nowSec = Date.now() / 1e3;
+    if (expiresAt && nowSec > expiresAt) {
+      if (refreshToken) {
+        const refRes = await fetch(refreshEndpoint, {
+          method: "POST",
+          headers: { Accept: "application/json", "Content-Type": "application/json" },
+          body: JSON.stringify({ provider, refreshToken })
+        });
+        if (refRes.ok) {
+          const data2 = await refRes.json();
+          cfg.setTokens(data2);
+          accessToken = data2.accessToken;
+        } else {
+          cfg.onAuthFailure();
+          if (cfg.loginFallbackPath) {
+            cfg.navigate?.(cfg.loginFallbackPath);
+          }
+          const err = new Error("Error refreshing token");
+          err.name = "ApiError";
+          err.statusCode = 401;
+          throw err;
+        }
+      } else {
+        cfg.onAuthFailure();
+        if (cfg.loginFallbackPath) {
+          cfg.navigate?.(cfg.loginFallbackPath);
+        }
+        const err = new Error("No refresh token");
+        err.name = "ApiError";
+        err.statusCode = 401;
+        throw err;
+      }
+    }
+    if (accessToken) {
+      headers["Authorization"] = `Bearer ${accessToken}`;
+    }
+    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);
+    }
+    let res;
+    let data;
+    try {
+      const fullUrl = `${cfg.baseUrl}${finalPath}`;
+      console.log("[SDK] Fetching:", method, fullUrl, fetchOpts);
+      res = await fetch(fullUrl, fetchOpts);
+      data = await res.json();
+    } catch (error) {
+      const err = new Error(error instanceof Error ? error.message : "Network request failed");
+      err.name = "NetworkError";
+      throw err;
+    }
+    if (!res.ok) {
+      const serverErr = data;
+      const reqErr = convertServerErrorToRequestError(serverErr);
+      if (options?.errorMessage && cfg.notify) {
+        cfg.notify({ message: options.errorMessage, type: "error" });
+      }
+      const err = new Error(serverErr.message || "Request failed");
+      err.name = "ApiError";
+      err.statusCode = serverErr.statusCode;
+      err.validationErrors = reqErr.validationErrors;
+      throw err;
+    }
+    if (options?.successMessage && cfg.notify) {
+      cfg.notify({ message: options.successMessage, type: "success" });
+    }
+    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/index.ts
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.1";
 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");
+function createArkySDK(config) {
+  const httpClient = createHttpClient(config);
+  const storageUrl = config.storageUrl || "https://storage.arky.io/dev";
+  const apiConfig = {
+    httpClient,
+    businessId: config.businessId,
+    storageUrl,
+    baseUrl: config.baseUrl,
+    market: config.market || "US",
+    setTokens: config.setTokens,
+    getTokens: config.getTokens
+  };
+  const userApi = createUserApi(apiConfig);
+  const autoGuest = config.autoGuest !== void 0 ? config.autoGuest : true;
+  const sdk = {
+    user: userApi,
+    business: createBusinessApi(apiConfig),
+    media: createMediaApi(apiConfig),
+    role: createRoleApi(apiConfig),
+    notification: createNotificationApi(apiConfig),
+    promoCode: createPromoCodeApi(apiConfig),
+    analytics: createAnalyticsApi(apiConfig),
+    cms: createCmsApi(apiConfig),
+    eshop: createEshopApi(apiConfig),
+    reservation: createReservationApi(apiConfig),
+    newsletter: createNewsletterApi(apiConfig),
+    payment: createPaymentApi(apiConfig),
+    setBusinessId: (businessId) => {
+      apiConfig.businessId = businessId;
+    },
+    getBusinessId: () => apiConfig.businessId,
+    auth: {
+      isAuthenticated: config.isAuthenticated || (() => false),
+      logout: config.logout || config.onAuthFailure,
+      setUserToken: config.setUserToken || (() => {
+      })
+    },
+    utils: {
+      getImageUrl: (imageBlock, isBlock = true) => getImageUrl(imageBlock, isBlock, storageUrl),
+      thumbnailUrl: (service) => thumbnailUrl(service, storageUrl),
+      getGalleryThumbnail,
+      getMarketPrice,
+      getPriceAmount,
+      formatPayment,
+      formatMinor,
+      createPaymentForCheckout,
+      getCurrencySymbol,
+      validatePhoneNumber,
+      tzGroups,
+      findTimeZone
+    }
+  };
+  if (autoGuest) {
+    Promise.resolve().then(async () => {
+      try {
+        const tokens = await config.getTokens();
+        if (!tokens.accessToken && !tokens.refreshToken) {
+          const guestToken = await userApi.getGuestToken({});
+          console.log("[SDK Init] Created guest token:", guestToken ? "Success" : "Failed");
+        } else {
+          console.log("[SDK Init] Using existing token from storage");
+        }
+      } catch (error) {
+        console.error("[SDK Init] Failed to initialize auth:", error);
+      }
+    });
   }
-  setGlobalConfig(config);
-  return config;
+  return sdk;
 }
 
 exports.ERROR_CODES = ERROR_CODES;
@@ -1438,14 +1787,28 @@ exports.ERROR_CONSTANTS = ERROR_CONSTANTS;
 exports.PaymentMethod = PaymentMethod;
 exports.SDK_VERSION = SDK_VERSION;
 exports.SUPPORTED_FRAMEWORKS = SUPPORTED_FRAMEWORKS;
+exports.SYMBOL_AFTER_CURRENCIES = SYMBOL_AFTER_CURRENCIES;
+exports.appendQueryString = appendQueryString;
+exports.buildQueryString = buildQueryString;
 exports.categorify = categorify;
-exports.cmsApi = cmsApi;
 exports.convertServerErrorToRequestError = convertServerErrorToRequestError;
 exports.convertToMajor = convertToMajor;
 exports.convertToMinor = convertToMinor;
+exports.createAnalyticsApi = createAnalyticsApi;
+exports.createArkySDK = createArkySDK;
+exports.createBusinessApi = createBusinessApi;
+exports.createCmsApi = createCmsApi;
+exports.createEshopApi = createEshopApi;
+exports.createMediaApi = createMediaApi;
+exports.createNewsletterApi = createNewsletterApi;
+exports.createNotificationApi = createNotificationApi;
+exports.createPaymentApi = createPaymentApi;
 exports.createPaymentForCheckout = createPaymentForCheckout;
+exports.createPromoCodeApi = createPromoCodeApi;
+exports.createReservationApi = createReservationApi;
+exports.createRoleApi = createRoleApi;
+exports.createUserApi = createUserApi;
 exports.errors = errors;
-exports.eshopApi = eshopApi;
 exports.extractBlockValues = extractBlockValues;
 exports.fetchSvgContent = fetchSvgContent;
 exports.findTimeZone = findTimeZone;
@@ -1460,36 +1823,31 @@ exports.getBlockObjectValues = getBlockObjectValues;
 exports.getBlockTextValue = getBlockTextValue;
 exports.getBlockValue = getBlockValue;
 exports.getBlockValues = getBlockValues;
-exports.getBusinessConfig = getBusinessConfig;
 exports.getCurrencyFromMarket = getCurrencyFromMarket;
+exports.getCurrencySymbol = getCurrencySymbol;
 exports.getErrorMessage = getErrorMessage;
 exports.getGalleryThumbnail = getGalleryThumbnail;
-exports.getGlobalConfig = getGlobalConfig;
-exports.getGuestToken = getGuestToken;
 exports.getImageUrl = getImageUrl;
+exports.getLocale = getLocale;
+exports.getLocaleFromUrl = getLocaleFromUrl;
+exports.getLocalizedString = getLocalizedString;
 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.isSymbolAfterCurrency = isSymbolAfterCurrency;
 exports.prepareBlocksForSubmission = prepareBlocksForSubmission;
-exports.reservationApi = reservationApi;
-exports.setGlobalConfig = setGlobalConfig;
+exports.setDefaultLocale = setDefaultLocale;
 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