@ecomiq/core 0.1.0

package/dist/client.cjs

@@ -0,0 +1,1344 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/libs/api.ts
+var DEFAULT_API_BASE_URL = "https://storefront.ecomiq.pe";
+var DEFAULT_API_VERSION = "v1";
+var ApiError = class extends Error {
+  constructor(message, status, url, body) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.body = body;
+    this.name = "ApiError";
+  }
+  status;
+  url;
+  body;
+};
+function resolveApiBaseUrl(baseUrl = DEFAULT_API_BASE_URL, version = DEFAULT_API_VERSION) {
+  const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const segment = version.replace(/^\/+|\/+$/g, "");
+  return new URL(`${segment}/`, root).toString();
+}
+function createApi(options = {}) {
+  const {
+    baseUrl = DEFAULT_API_BASE_URL,
+    version = DEFAULT_API_VERSION,
+    headers: baseHeaders = {},
+    timeoutMs = 1e4
+  } = options;
+  const effectiveBaseUrl = resolveApiBaseUrl(baseUrl, version);
+  async function request(method, path, schema, opts = {}) {
+    const url = new URL(path.replace(/^\//, ""), effectiveBaseUrl);
+    for (const [key, value] of Object.entries(opts.query ?? {})) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    if (opts.signal) opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    const isFormData = typeof FormData !== "undefined" && opts.body instanceof FormData;
+    let response;
+    try {
+      response = await fetch(url.toString(), {
+        method,
+        headers: {
+          accept: "application/json",
+          ...opts.body !== void 0 && !isFormData ? { "content-type": "application/json" } : {},
+          ...baseHeaders,
+          ...opts.headers
+        },
+        body: opts.body === void 0 ? void 0 : isFormData ? opts.body : JSON.stringify(opts.body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      throw new ApiError(
+        err instanceof DOMException && err.name === "AbortError" ? `Timeout tras ${timeoutMs}ms: ${url}` : `No se pudo conectar con ${url}`,
+        0,
+        url.toString()
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      const bodyText = await response.text().catch(() => void 0);
+      let body = bodyText;
+      if (bodyText) {
+        try {
+          body = JSON.parse(bodyText);
+        } catch {
+        }
+      }
+      throw new ApiError(`${method} ${url} \u2192 ${response.status}`, response.status, url.toString(), body);
+    }
+    const json = await response.json();
+    const parsed = schema.safeParse(json);
+    if (!parsed.success) {
+      throw new ApiError(
+        `Respuesta inesperada de ${url}: ${parsed.error.issues[0]?.path.join(".")} ${parsed.error.issues[0]?.message}`,
+        response.status,
+        url.toString(),
+        json
+      );
+    }
+    return parsed.data;
+  }
+  return {
+    request,
+    get: (path, schema, opts) => request("GET", path, schema, opts),
+    post: (path, body, schema, opts) => request("POST", path, schema, { ...opts, body }),
+    postForm: (path, body, schema, opts) => request("POST", path, schema, { ...opts, body })
+  };
+}
+var CollectionSchema = zod.z.object({
+  id: zod.z.number(),
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string().nullable().optional(),
+  imageUrl: zod.z.string().nullable().optional(),
+  type: zod.z.string(),
+  productCount: zod.z.number().optional()
+});
+var CollectionsSchema = zod.z.array(CollectionSchema);
+var ProductPublicIdSchema = zod.z.union([
+  zod.z.string().regex(/^[1-9]\d*$/),
+  zod.z.number().int().safe().positive()
+]).transform(String);
+var ProductSummarySchema = zod.z.object({
+  id: ProductPublicIdSchema,
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  productType: zod.z.string(),
+  imageUrl: zod.z.string(),
+  price: zod.z.number().nonnegative(),
+  compareAtPrice: zod.z.number().nonnegative().nullable(),
+  variantCount: zod.z.number().int().nonnegative(),
+  isAvailable: zod.z.boolean(),
+  totalInventory: zod.z.number().int().nonnegative(),
+  bundleItemsCount: zod.z.number().int().nonnegative(),
+  brand: zod.z.string(),
+  category: zod.z.string(),
+  status: zod.z.string(),
+  collections: zod.z.array(zod.z.string()),
+  tags: zod.z.array(zod.z.string())
+});
+var ProductSummariesSchema = zod.z.array(ProductSummarySchema);
+var FacetItemSchema = zod.z.object({
+  value: zod.z.string(),
+  count: zod.z.number().int().nonnegative(),
+  label: zod.z.string().nullable(),
+  selected: zod.z.boolean()
+});
+var SearchFilterSchema = zod.z.object({
+  id: zod.z.string(),
+  label: zod.z.string(),
+  type: zod.z.enum(["list", "price_range"]),
+  values: zod.z.array(FacetItemSchema),
+  min: zod.z.number().nonnegative().nullable(),
+  max: zod.z.number().nonnegative().nullable(),
+  selectedMin: zod.z.number().nonnegative().nullable(),
+  selectedMax: zod.z.number().nonnegative().nullable()
+});
+var ProductsResponseSchema = zod.z.object({
+  pageIndex: zod.z.number().int().positive(),
+  pageSize: zod.z.number().int().positive().max(100),
+  totalCount: zod.z.number().int().nonnegative(),
+  totalPages: zod.z.number().int().nonnegative(),
+  products: zod.z.array(ProductSummarySchema),
+  filters: zod.z.array(SearchFilterSchema)
+});
+var ProductSortSchema = zod.z.enum([
+  "price_asc",
+  "price_desc",
+  "name_asc",
+  "name_desc",
+  "newest"
+]);
+var ProductsParamsSchema = zod.z.object({
+  page: zod.z.number().int().positive().default(1),
+  pageSize: zod.z.number().int().positive().max(100).default(24),
+  sort: ProductSortSchema.optional(),
+  sellerId: zod.z.string().uuid().optional(),
+  search: zod.z.string().optional(),
+  collection: zod.z.string().optional(),
+  collections: zod.z.array(zod.z.string()).optional(),
+  collectionId: ProductPublicIdSchema.optional(),
+  category: zod.z.string().optional(),
+  categories: zod.z.array(zod.z.string()).optional(),
+  brand: zod.z.string().optional(),
+  brands: zod.z.array(zod.z.string()).optional(),
+  productType: zod.z.string().optional(),
+  productTypes: zod.z.array(zod.z.string()).optional(),
+  tag: zod.z.string().optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  filters: zod.z.array(zod.z.string()).optional(),
+  locationId: zod.z.string().uuid().optional(),
+  inStock: zod.z.boolean().optional(),
+  minPrice: zod.z.number().nonnegative().optional(),
+  maxPrice: zod.z.number().nonnegative().optional()
+});
+var ProductDetailParamsSchema = zod.z.object({
+  sellerId: zod.z.string().uuid().optional()
+});
+var RelatedProductsParamsSchema = zod.z.object({
+  productId: ProductPublicIdSchema,
+  limit: zod.z.number().int().positive().max(12).default(8),
+  sellerId: zod.z.string().uuid().optional()
+});
+var SpecItemSchema = zod.z.object({
+  key: zod.z.string(),
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var ProductImageSchema = zod.z.object({
+  url: zod.z.string(),
+  name: zod.z.string(),
+  order: zod.z.number().int().nonnegative()
+});
+var VariantItemSchema = zod.z.object({
+  id: zod.z.string().nullable(),
+  sku: zod.z.string(),
+  status: zod.z.string(),
+  price: zod.z.number().nonnegative(),
+  compareAtPrice: zod.z.number().nonnegative().nullable(),
+  quantity: zod.z.number().int().nonnegative(),
+  options: zod.z.array(SpecItemSchema),
+  images: zod.z.array(ProductImageSchema)
+});
+var ProductPriceTierSchema = zod.z.object({
+  variantId: zod.z.string(),
+  minQuantity: zod.z.number().int().positive(),
+  maxQuantity: zod.z.number().int().positive().nullable(),
+  unitPrice: zod.z.number().nonnegative()
+});
+var BundleItemSchema = zod.z.object({
+  productId: ProductPublicIdSchema,
+  variantId: ProductPublicIdSchema,
+  productName: zod.z.string(),
+  variantName: zod.z.string().nullable(),
+  sku: zod.z.string().nullable(),
+  brand: zod.z.string().nullable(),
+  imageUrl: zod.z.string().nullable(),
+  quantity: zod.z.number().int().positive(),
+  available: zod.z.number().int().nonnegative(),
+  allowBackorders: zod.z.boolean(),
+  requiresShipping: zod.z.boolean()
+});
+var SizeGuideMeasurementSchema = zod.z.object({
+  key: zod.z.string(),
+  name: zod.z.string(),
+  min: zod.z.number().nullable(),
+  max: zod.z.number().nullable(),
+  value: zod.z.number().nullable(),
+  description: zod.z.string().nullable()
+});
+var SizeGuideRowSchema = zod.z.object({
+  label: zod.z.string(),
+  sizeKey: zod.z.string(),
+  order: zod.z.number().int().nonnegative(),
+  measurements: zod.z.array(SizeGuideMeasurementSchema)
+});
+var SizeGuideSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  description: zod.z.string().nullable(),
+  imageUrl: zod.z.string().nullable(),
+  gender: zod.z.string(),
+  measurementType: zod.z.string(),
+  unit: zod.z.string(),
+  notes: zod.z.string().nullable(),
+  rows: zod.z.array(SizeGuideRowSchema)
+});
+var ProductDetailSchema = zod.z.object({
+  id: ProductPublicIdSchema,
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  description: zod.z.string(),
+  productType: zod.z.string(),
+  status: zod.z.string(),
+  imageUrl: zod.z.string(),
+  price: zod.z.number().nonnegative(),
+  compareAtPrice: zod.z.number().nonnegative().nullable(),
+  isAvailable: zod.z.boolean(),
+  totalInventory: zod.z.number().int().nonnegative(),
+  brand: zod.z.string(),
+  category: zod.z.string(),
+  categoryId: ProductPublicIdSchema.nullable(),
+  tags: zod.z.array(zod.z.string()),
+  specifications: zod.z.array(SpecItemSchema),
+  variants: zod.z.array(VariantItemSchema),
+  images: zod.z.array(ProductImageSchema),
+  bundleItems: zod.z.array(BundleItemSchema),
+  sizeGuide: SizeGuideSchema.nullable(),
+  priceTiers: zod.z.array(ProductPriceTierSchema),
+  createdAt: zod.z.string().datetime({ offset: true }).nullable(),
+  updatedAt: zod.z.string().datetime({ offset: true }).nullable()
+});
+var JsonElementSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.null(),
+    zod.z.boolean(),
+    zod.z.number().finite(),
+    zod.z.string(),
+    zod.z.array(JsonElementSchema),
+    zod.z.record(zod.z.string(), JsonElementSchema)
+  ])
+);
+var DateTimeOffsetSchema = zod.z.string().datetime({ offset: true });
+var NullableDateTimeOffsetSchema = DateTimeOffsetSchema.nullable();
+var NullableUuidSchema = zod.z.string().uuid().nullable();
+var StoreTypeSchema = zod.z.enum([
+  "b2C",
+  "marketplace",
+  "retail",
+  "b2B",
+  "social",
+  "hub",
+  "restaurant"
+]);
+var StoreVisibilitySchema = zod.z.enum(["public", "private"]);
+var StoreThemeSettingsSchema = zod.z.object({
+  name: zod.z.string().nullable(),
+  mode: zod.z.string().nullable(),
+  colors: zod.z.record(zod.z.string(), zod.z.string()),
+  fonts: zod.z.record(zod.z.string(), zod.z.string()),
+  assets: zod.z.record(zod.z.string(), zod.z.string())
+}).strict();
+var StoreFeatureFlagsSchema = zod.z.object({
+  flags: zod.z.record(zod.z.string(), zod.z.boolean())
+}).strict();
+var StoreCheckoutGeneralSettingsSchema = zod.z.object({
+  allowGuestCheckout: zod.z.boolean(),
+  identityScope: zod.z.enum(["store", "tenant", "global"]),
+  signInMethods: zod.z.array(zod.z.enum(["password", "emailOtp", "google"])),
+  useSequentialOrderNumbers: zod.z.boolean(),
+  automaticallySelectFirstAddress: zod.z.boolean(),
+  alwaysRequestCustomerAddress: zod.z.boolean(),
+  requestCustomerDateOfBirth: zod.z.boolean(),
+  automaticallySelectBestPromotion: zod.z.boolean()
+}).strict();
+var StoreCheckoutShippingSettingsSchema = zod.z.object({
+  showDeliveryTime: zod.z.boolean(),
+  showDeliveryTimeInDays: zod.z.boolean(),
+  useBusinessDaysForDeliveryTime: zod.z.boolean(),
+  showEstimatedDeliveryDateInThankYouAndEmails: zod.z.boolean(),
+  showOriginalShippingPriceWhenFree: zod.z.boolean()
+}).strict();
+var StoreCheckoutCartPageSettingsSchema = zod.z.object({
+  showShippingCostCalculation: zod.z.boolean(),
+  allowProductLinks: zod.z.boolean(),
+  redirectToCartPage: zod.z.boolean()
+}).strict();
+var StoreCheckoutOrderBumpSettingsSchema = zod.z.object({
+  mergeOrderBumpOrders: zod.z.boolean(),
+  allowOnlyOneAdditionalOffer: zod.z.boolean(),
+  maxVisibleOffers: zod.z.number().int()
+}).strict();
+var StoreCheckoutOrdersAndPaymentsSettingsSchema = zod.z.object({
+  allowPurchasesFrom: zod.z.enum(["any", "individual", "company"]),
+  creditCardDailyOrderLimitPerIp: zod.z.number().int().nullable(),
+  maximumItemsPerOrder: zod.z.number().int().nullable(),
+  deliveryNoteText: zod.z.string().nullable(),
+  boletoPaymentNoteText: zod.z.string().nullable()
+}).strict();
+var StoreCheckoutSettingsSchema = zod.z.object({
+  general: StoreCheckoutGeneralSettingsSchema,
+  shipping: StoreCheckoutShippingSettingsSchema,
+  cartPage: StoreCheckoutCartPageSettingsSchema,
+  orderBumps: StoreCheckoutOrderBumpSettingsSchema,
+  ordersAndPayments: StoreCheckoutOrdersAndPaymentsSettingsSchema
+}).strict();
+var StorefrontStoreShape = {
+  id: zod.z.string().uuid(),
+  tenantId: zod.z.string().uuid(),
+  sellerId: NullableUuidSchema,
+  type: StoreTypeSchema,
+  isActive: zod.z.boolean(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  logo: zod.z.string().nullable(),
+  icon: zod.z.string().nullable(),
+  slug: zod.z.string().nullable(),
+  domain: zod.z.string().nullable(),
+  domains: zod.z.array(zod.z.string()),
+  timeZone: zod.z.string(),
+  currency: zod.z.string(),
+  language: zod.z.string(),
+  visibility: StoreVisibilitySchema,
+  themeConfig: StoreThemeSettingsSchema,
+  featuresEnabled: StoreFeatureFlagsSchema,
+  checkoutSettings: StoreCheckoutSettingsSchema
+};
+var StoreModelSchema = zod.z.object(StorefrontStoreShape).strict();
+var CmsBrandingSettingsDtoSchema = zod.z.object({
+  logoUrl: zod.z.string().nullable(),
+  logoDarkUrl: zod.z.string().nullable(),
+  faviconUrl: zod.z.string().nullable(),
+  socialImageUrl: zod.z.string().nullable()
+}).strict();
+var CmsSeoSettingsDtoSchema = zod.z.object({
+  siteName: zod.z.string().nullable(),
+  metaTitle: zod.z.string().nullable(),
+  metaDescription: zod.z.string().nullable(),
+  titleTemplate: zod.z.string().nullable(),
+  robotsIndex: zod.z.boolean()
+}).strict();
+var CmsSocialLinksDtoSchema = zod.z.object({
+  instagram: zod.z.string().nullable(),
+  facebook: zod.z.string().nullable(),
+  tiktok: zod.z.string().nullable(),
+  youtube: zod.z.string().nullable(),
+  x: zod.z.string().nullable()
+}).strict();
+var CmsContactSettingsDtoSchema = zod.z.object({
+  supportEmail: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  whatsapp: zod.z.string().nullable(),
+  address: zod.z.string().nullable(),
+  socialLinks: CmsSocialLinksDtoSchema
+}).strict();
+var CmsTrackingSettingsDtoSchema = zod.z.object({
+  googleAnalyticsMeasurementId: zod.z.string().nullable(),
+  metaPixelId: zod.z.string().nullable(),
+  googleTagManagerContainerId: zod.z.string().nullable()
+}).strict();
+var CmsCustomScriptsDtoSchema = zod.z.object({
+  enabled: zod.z.boolean(),
+  head: zod.z.string().nullable(),
+  bodyEnd: zod.z.string().nullable()
+}).strict();
+var CmsSiteSettingsDtoSchema = zod.z.object({
+  themeKey: zod.z.string(),
+  branding: CmsBrandingSettingsDtoSchema,
+  seo: CmsSeoSettingsDtoSchema,
+  contact: CmsContactSettingsDtoSchema,
+  tracking: CmsTrackingSettingsDtoSchema,
+  customScripts: CmsCustomScriptsDtoSchema,
+  updatedOn: NullableDateTimeOffsetSchema
+}).strict();
+var CmsMenuItemSchema = zod.z.lazy(
+  () => zod.z.object({
+    label: zod.z.string(),
+    url: zod.z.string(),
+    order: zod.z.number().int(),
+    target: zod.z.string().nullable(),
+    visible: zod.z.boolean().nullable(),
+    children: zod.z.array(CmsMenuItemSchema).nullable()
+  }).strict()
+);
+var CmsMenuDtoSchema = zod.z.object({
+  key: zod.z.string(),
+  name: zod.z.string(),
+  items: zod.z.array(CmsMenuItemSchema)
+}).strict();
+var CmsBlockDtoSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  type: zod.z.string(),
+  order: zod.z.number().int(),
+  settings: JsonElementSchema
+}).strict();
+var CmsSectionDtoSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  type: zod.z.string(),
+  order: zod.z.number().int(),
+  settings: JsonElementSchema,
+  blocks: zod.z.array(CmsBlockDtoSchema)
+}).strict();
+var CmsContentChannelSchema = zod.z.enum(["storefront", "pos"]);
+var CmsPageStatusSchema = zod.z.enum(["draft", "published", "archived"]);
+var CmsPageDetailsDtoSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  channel: CmsContentChannelSchema,
+  layout: zod.z.string(),
+  version: zod.z.number().int().nullable(),
+  settings: JsonElementSchema,
+  sections: zod.z.array(CmsSectionDtoSchema),
+  status: CmsPageStatusSchema,
+  hasPublishedVersion: zod.z.boolean(),
+  publishedOn: NullableDateTimeOffsetSchema,
+  publishedBy: NullableUuidSchema,
+  createdOn: DateTimeOffsetSchema,
+  updatedOn: NullableDateTimeOffsetSchema,
+  createdBy: NullableUuidSchema,
+  updatedBy: NullableUuidSchema,
+  lastModifiedBy: zod.z.string().nullable()
+}).strict();
+var CmsSnapshotDtoSchema = zod.z.object({
+  settings: CmsSiteSettingsDtoSchema,
+  pages: zod.z.array(CmsPageDetailsDtoSchema),
+  menus: zod.z.array(CmsMenuDtoSchema)
+}).strict();
+var StoreSettingsSnapshotV1Schema = zod.z.object({
+  schemaVersion: zod.z.literal(1),
+  generatedAt: DateTimeOffsetSchema,
+  store: zod.z.object(StorefrontStoreShape),
+  cms: CmsSnapshotDtoSchema
+}).strict();
+var StoreSettingsSnapshotV2Schema = zod.z.object({
+  schemaVersion: zod.z.literal(2),
+  generatedAt: DateTimeOffsetSchema,
+  store: StoreModelSchema,
+  cms: CmsSnapshotDtoSchema
+}).strict();
+var StoreSettingsSnapshotDtoSchema = zod.z.discriminatedUnion(
+  "schemaVersion",
+  [StoreSettingsSnapshotV1Schema, StoreSettingsSnapshotV2Schema]
+);
+var StorefrontSettingsSchema = StoreSettingsSnapshotDtoSchema;
+
+// src/services/product.service.ts
+async function getProducts(api, params = {}) {
+  const input = ProductsParamsSchema.parse(params);
+  const query = new URLSearchParams();
+  query.set("page", String(input.page));
+  query.set("pageSize", String(input.pageSize));
+  if (input.sort) query.set("sort", input.sort);
+  if (input.sellerId) query.set("sellerId", input.sellerId);
+  if (input.search) query.set("search", input.search);
+  if (input.collection) query.set("collection", input.collection);
+  for (const collection of input.collections ?? []) {
+    query.append("collections", collection);
+  }
+  if (input.collectionId) query.set("collectionId", input.collectionId);
+  if (input.category) query.set("category", input.category);
+  for (const category of input.categories ?? []) {
+    query.append("categories", category);
+  }
+  if (input.brand) query.set("brand", input.brand);
+  for (const brand of input.brands ?? []) {
+    query.append("brands", brand);
+  }
+  if (input.productType) query.set("productType", input.productType);
+  for (const productType of input.productTypes ?? []) {
+    query.append("productTypes", productType);
+  }
+  if (input.tag) query.set("tag", input.tag);
+  for (const tag of input.tags ?? []) {
+    query.append("tags", tag);
+  }
+  for (const filter of input.filters ?? []) {
+    query.append("filters", filter);
+  }
+  if (input.locationId) query.set("locationId", input.locationId);
+  if (input.inStock !== void 0) query.set("inStock", String(input.inStock));
+  if (input.minPrice !== void 0) query.set("minPrice", String(input.minPrice));
+  if (input.maxPrice !== void 0) query.set("maxPrice", String(input.maxPrice));
+  return api.get(`products?${query.toString()}`, ProductsResponseSchema);
+}
+async function getProductBySlug(api, slug, params = {}) {
+  const input = ProductDetailParamsSchema.parse(params);
+  const query = new URLSearchParams();
+  if (input.sellerId) query.set("sellerId", input.sellerId);
+  const path = `products/${encodeURIComponent(slug)}`;
+  const search = query.toString();
+  if (search) {
+    return api.get(`${path}?${search}`, ProductDetailSchema);
+  }
+  return api.get(path, ProductDetailSchema);
+}
+async function getRelatedProducts(api, params) {
+  const input = RelatedProductsParamsSchema.parse(params);
+  return api.get(
+    `products/${encodeURIComponent(input.productId)}/related`,
+    ProductSummariesSchema,
+    {
+      query: {
+        limit: input.limit,
+        sellerId: input.sellerId
+      }
+    }
+  );
+}
+var ProductAutocompleteParamsSchema = zod.z.object({
+  search: zod.z.string().min(2).max(80),
+  limit: zod.z.number().int().positive().max(20).default(8),
+  sellerId: zod.z.string().uuid().optional()
+});
+var ProductSuggestionSchema = zod.z.object({
+  id: ProductPublicIdSchema,
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  imageUrl: zod.z.string()
+});
+var ProductSuggestionsSchema = zod.z.array(ProductSuggestionSchema);
+
+// src/services/search.service.ts
+async function autocompleteProducts(api, params) {
+  const input = ProductAutocompleteParamsSchema.parse(params);
+  return api.get("search/autocomplete", ProductSuggestionsSchema, {
+    query: {
+      search: input.search,
+      limit: input.limit,
+      sellerId: input.sellerId
+    }
+  });
+}
+var StorefrontReviewSchema = zod.z.object({
+  id: ProductPublicIdSchema,
+  productId: ProductPublicIdSchema,
+  isVerifiedPurchase: zod.z.boolean(),
+  rating: zod.z.number().int().min(1).max(5),
+  title: zod.z.string().nullable(),
+  content: zod.z.string(),
+  reviewerName: zod.z.string().nullable(),
+  createdOn: zod.z.string().datetime({ offset: true })
+});
+var StorefrontReviewsSchema = zod.z.object({
+  data: zod.z.array(StorefrontReviewSchema),
+  hasNextPage: zod.z.boolean(),
+  nextCursor: zod.z.string().nullable(),
+  totalCount: zod.z.number().int().nonnegative().nullable()
+});
+var ListProductReviewsParamsSchema = zod.z.object({
+  productId: ProductPublicIdSchema,
+  limit: zod.z.number().int().min(1).max(200).optional(),
+  cursor: zod.z.string().optional(),
+  search: zod.z.string().optional(),
+  sortBy: zod.z.enum(["rating", "createdOn"]).optional(),
+  sortDirection: zod.z.enum(["asc", "desc"]).optional(),
+  rating: zod.z.number().int().min(1).max(5).optional()
+});
+var CreateProductReviewParamsSchema = zod.z.object({
+  productId: ProductPublicIdSchema,
+  rating: zod.z.number().int().min(1).max(5),
+  content: zod.z.string().min(1).max(4e3),
+  title: zod.z.string().max(200).optional(),
+  reviewerName: zod.z.string().min(1).max(200),
+  reviewerEmail: zod.z.string().email().max(320),
+  orderId: zod.z.number().int().safe().positive().optional()
+});
+
+// src/services/review.service.ts
+async function listProductReviews(api, params) {
+  const input = ListProductReviewsParamsSchema.parse(params);
+  return api.get(
+    `products/${encodeURIComponent(input.productId)}/reviews`,
+    StorefrontReviewsSchema,
+    {
+      query: {
+        limit: input.limit,
+        cursor: input.cursor,
+        search: input.search,
+        sortBy: input.sortBy,
+        sortDirection: input.sortDirection,
+        rating: input.rating
+      }
+    }
+  );
+}
+async function createProductReview(api, params) {
+  const input = CreateProductReviewParamsSchema.parse(params);
+  return api.post(
+    `products/${encodeURIComponent(input.productId)}/reviews`,
+    {
+      rating: input.rating,
+      content: input.content,
+      title: input.title,
+      reviewerName: input.reviewerName,
+      reviewerEmail: input.reviewerEmail,
+      orderId: input.orderId
+    },
+    StorefrontReviewSchema
+  );
+}
+var StorefrontAddressSchema = zod.z.object({
+  name: zod.z.string().nullable(),
+  address1: zod.z.string(),
+  city: zod.z.string(),
+  countryCode: zod.z.string(),
+  company: zod.z.string().nullable(),
+  address2: zod.z.string().nullable(),
+  province: zod.z.string().nullable(),
+  postalCode: zod.z.string().nullable(),
+  district: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  latitude: zod.z.number().nullable(),
+  longitude: zod.z.number().nullable()
+});
+var StorefrontCartBundleItemSchema = zod.z.object({
+  productId: zod.z.number().int().safe().nonnegative(),
+  variantId: zod.z.number().int().safe().nonnegative(),
+  productName: zod.z.string(),
+  variantName: zod.z.string().nullable(),
+  sku: zod.z.string().nullable(),
+  brand: zod.z.string().nullable(),
+  imageUrl: zod.z.string().nullable(),
+  quantity: zod.z.number().int().positive()
+});
+var StorefrontCartItemSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  productId: zod.z.number().int().safe().nonnegative(),
+  title: zod.z.string(),
+  variantLabel: zod.z.string().nullable(),
+  productHandle: zod.z.string().nullable(),
+  thumbnail: zod.z.string().nullable(),
+  quantity: zod.z.number().int().positive(),
+  variantId: zod.z.number().int().safe().nonnegative(),
+  variantSku: zod.z.string().nullable(),
+  unitPrice: zod.z.number(),
+  compareAtUnitPrice: zod.z.number().nullable(),
+  bundleItems: zod.z.array(StorefrontCartBundleItemSchema)
+});
+var StorefrontCartShippingMethodSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  shippingMethodId: zod.z.string().uuid().nullable(),
+  rateId: zod.z.string().uuid().nullable(),
+  name: zod.z.string(),
+  description: zod.z.string().nullable(),
+  total: zod.z.number(),
+  locationId: zod.z.string().uuid().nullable(),
+  estimatedDays: zod.z.number().int().nullable(),
+  pickupPointId: zod.z.string().uuid().nullable(),
+  scheduledDate: zod.z.string().nullable(),
+  scheduledTime: zod.z.string().nullable(),
+  serviceCode: zod.z.string().nullable(),
+  sellerId: zod.z.string().uuid().nullable(),
+  shippingProfileId: zod.z.string().uuid().nullable()
+});
+var StorefrontCartTotalsSchema = zod.z.object({
+  subtotal: zod.z.number(),
+  discountTotal: zod.z.number(),
+  shippingOriginalTotal: zod.z.number(),
+  shippingTotal: zod.z.number(),
+  taxTotal: zod.z.number(),
+  warrantyTotal: zod.z.number(),
+  total: zod.z.number()
+});
+var StorefrontCartStatusSchema = zod.z.enum([
+  "inProgress",
+  "pending",
+  "completed",
+  "abandoned",
+  "cancelled",
+  "expired",
+  "failed"
+]);
+var StorefrontCartSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  cartNumber: zod.z.string(),
+  email: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  firstName: zod.z.string().nullable(),
+  lastName: zod.z.string().nullable(),
+  currencyCode: zod.z.string(),
+  status: StorefrontCartStatusSchema,
+  completedAt: zod.z.string().datetime({ offset: true }).nullable(),
+  shippingAddress: StorefrontAddressSchema.nullable(),
+  billingAddress: StorefrontAddressSchema.nullable(),
+  promotionCodes: zod.z.array(zod.z.string()),
+  items: zod.z.array(StorefrontCartItemSchema),
+  shippingMethods: zod.z.array(StorefrontCartShippingMethodSchema),
+  totals: StorefrontCartTotalsSchema
+});
+var CreateCartParamsSchema = zod.z.object({
+  currencyCode: zod.z.string().length(3),
+  salesChannelId: zod.z.string().optional(),
+  email: zod.z.string().email().optional()
+});
+var GetCartParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid()
+});
+var CartItemModifierSchema = zod.z.object({
+  modifierGroupId: zod.z.number().int().safe().positive(),
+  optionIds: zod.z.array(zod.z.number().int().safe().positive()).min(1)
+});
+var AddCartItemParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  variantId: zod.z.number().int().safe().positive(),
+  quantity: zod.z.number().int().positive(),
+  modifiers: zod.z.array(CartItemModifierSchema).optional()
+});
+var UpdateCartItemQuantityParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  cartItemId: zod.z.string().uuid(),
+  quantity: zod.z.number().int().nonnegative()
+});
+var RemoveCartItemParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  cartItemId: zod.z.string().uuid()
+});
+
+// src/services/cart.service.ts
+async function createCart(api, params) {
+  const input = CreateCartParamsSchema.parse(params);
+  return api.post(
+    "carts",
+    {
+      currencyCode: input.currencyCode,
+      salesChannelId: input.salesChannelId,
+      email: input.email
+    },
+    StorefrontCartSchema
+  );
+}
+async function getCart(api, params) {
+  const input = GetCartParamsSchema.parse(params);
+  return api.get(
+    `carts/${encodeURIComponent(input.cartId)}`,
+    StorefrontCartSchema
+  );
+}
+async function addCartItem(api, params) {
+  const input = AddCartItemParamsSchema.parse(params);
+  return api.post(
+    `carts/${encodeURIComponent(input.cartId)}/items`,
+    {
+      variantId: input.variantId,
+      quantity: input.quantity,
+      modifiers: input.modifiers
+    },
+    StorefrontCartSchema
+  );
+}
+async function updateCartItemQuantity(api, params) {
+  const input = UpdateCartItemQuantityParamsSchema.parse(params);
+  return api.request(
+    "PATCH",
+    `carts/${encodeURIComponent(input.cartId)}/items/${encodeURIComponent(input.cartItemId)}`,
+    StorefrontCartSchema,
+    { body: { quantity: input.quantity } }
+  );
+}
+async function removeCartItem(api, params) {
+  const input = RemoveCartItemParamsSchema.parse(params);
+  return api.request(
+    "DELETE",
+    `carts/${encodeURIComponent(input.cartId)}/items/${encodeURIComponent(input.cartItemId)}`,
+    StorefrontCartSchema
+  );
+}
+
+// src/services/collection.service.ts
+async function getCollections(api) {
+  return api.get("collections", CollectionsSchema);
+}
+async function getCollectionBySlug(api, collectionSlug) {
+  return api.get(`collections/${encodeURIComponent(collectionSlug)}`, CollectionSchema);
+}
+var CartBuyerParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  email: zod.z.string().email(),
+  firstName: zod.z.string().min(1),
+  lastName: zod.z.string().min(1),
+  phone: zod.z.string().min(1)
+});
+var CartAddressWriteSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  address1: zod.z.string().min(1),
+  city: zod.z.string().min(1),
+  countryCode: zod.z.string().length(2),
+  company: zod.z.string().nullable().optional(),
+  address2: zod.z.string().nullable().optional(),
+  province: zod.z.string().nullable().optional(),
+  postalCode: zod.z.string().nullable().optional(),
+  district: zod.z.string().nullable().optional(),
+  phone: zod.z.string().nullable().optional(),
+  latitude: zod.z.number().nullable().optional(),
+  longitude: zod.z.number().nullable().optional(),
+  geo: zod.z.object({
+    departmentCode: zod.z.string().nullable().optional(),
+    provinceCode: zod.z.string().nullable().optional(),
+    districtCode: zod.z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartAddressesParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  shippingAddress: CartAddressWriteSchema,
+  billingAddress: CartAddressWriteSchema
+});
+var CartPaymentMethodSchema = zod.z.object({
+  code: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string().nullable().optional(),
+  kind: zod.z.string(),
+  providerMethodCode: zod.z.string().nullable().optional(),
+  isActive: zod.z.boolean(),
+  isDefault: zod.z.boolean(),
+  isManual: zod.z.boolean(),
+  sortOrder: zod.z.number(),
+  phoneNumber: zod.z.string().nullable().optional(),
+  accountHolder: zod.z.string().nullable().optional(),
+  qrImageUrl: zod.z.string().nullable().optional()
+});
+var StorefrontOrderBumpSchema = zod.z.object({
+  id: zod.z.string(),
+  productPublicId: zod.z.coerce.string(),
+  variantPublicId: zod.z.coerce.string(),
+  productName: zod.z.string(),
+  variantName: zod.z.string().nullable().optional(),
+  imageUrl: zod.z.string().nullable().optional(),
+  currencyCode: zod.z.string(),
+  regularPrice: zod.z.number(),
+  offerPrice: zod.z.number(),
+  badgeLabel: zod.z.string().nullable().optional(),
+  callToAction: zod.z.string(),
+  description: zod.z.string().nullable().optional()
+});
+var CartCheckoutReadParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid()
+});
+var CartCheckoutReadResponseSchema = zod.z.object({
+  cart: StorefrontCartSchema,
+  paymentMethods: zod.z.object({
+    methods: zod.z.array(CartPaymentMethodSchema)
+  }),
+  orderBumps: zod.z.array(StorefrontOrderBumpSchema).optional().default([])
+});
+var CartCheckoutPaymentActionSchema = zod.z.object({
+  publicConfiguration: zod.z.object({
+    publishableKey: zod.z.string().nullable().optional(),
+    checkoutMode: zod.z.string().nullable().optional(),
+    phoneNumber: zod.z.string().nullable().optional(),
+    accountHolder: zod.z.string().nullable().optional(),
+    qrImageUrl: zod.z.string().nullable().optional()
+  }).passthrough().nullable().optional(),
+  url: zod.z.string().nullable().optional(),
+  html: zod.z.string().nullable().optional(),
+  clientSecret: zod.z.string().nullable().optional(),
+  qrCode: zod.z.string().nullable().optional(),
+  expiresAt: zod.z.string().nullable().optional()
+}).passthrough();
+var CartCheckoutPaymentSchema = zod.z.object({
+  transactionId: zod.z.string(),
+  paymentMethodCode: zod.z.string(),
+  providerId: zod.z.string().nullable().optional(),
+  status: zod.z.string(),
+  amount: zod.z.number(),
+  reference: zod.z.string(),
+  actionType: zod.z.string(),
+  receiptUrl: zod.z.string().nullable().optional(),
+  action: CartCheckoutPaymentActionSchema.nullable().optional()
+}).passthrough();
+var CartCheckoutResponseSchema = zod.z.object({
+  publicKey: zod.z.string().optional(),
+  publishableKey: zod.z.string().optional(),
+  stripePublicKey: zod.z.string().optional(),
+  clientSecret: zod.z.string().optional(),
+  intentClientSecret: zod.z.string().optional(),
+  orderId: zod.z.coerce.string().optional(),
+  orderGroup: zod.z.string().optional(),
+  orderIds: zod.z.array(zod.z.coerce.string()).optional(),
+  payment: CartCheckoutPaymentSchema.optional(),
+  cart: StorefrontCartSchema.optional()
+}).passthrough();
+var CartCheckoutParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  paymentMethodCode: zod.z.string().min(1),
+  externalRef: zod.z.string().min(1),
+  receiptUrl: zod.z.string().min(1).optional()
+});
+var ShippingRateSchema = zod.z.object({
+  shippingMethodId: zod.z.string(),
+  name: zod.z.string(),
+  displayName: zod.z.string().optional(),
+  type: zod.z.string().optional(),
+  price: zod.z.number(),
+  currency: zod.z.string().optional(),
+  sortOrder: zod.z.number().optional(),
+  rateId: zod.z.string(),
+  description: zod.z.string().nullable().optional(),
+  deliveryLocationId: zod.z.string().nullable().optional(),
+  deliveryLocationName: zod.z.string().nullable().optional(),
+  estimatedDeliveryDays: zod.z.number().nullable().optional(),
+  serviceCode: zod.z.string().nullable().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+}).passthrough();
+var ShippingOptionGroupSchema = zod.z.object({
+  sellerId: zod.z.string(),
+  shippingProfileId: zod.z.string().nullable().optional(),
+  orderAmount: zod.z.number().optional(),
+  totalWeight: zod.z.number().optional(),
+  itemIds: zod.z.array(zod.z.string()).optional(),
+  rates: zod.z.array(ShippingRateSchema)
+}).passthrough();
+var ShippingOptionsResponseSchema = zod.z.object({
+  groups: zod.z.array(ShippingOptionGroupSchema)
+});
+var GetShippingOptionsParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  postalCode: zod.z.string().min(1)
+});
+var PutShippingMethodParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  rateId: zod.z.string().min(1),
+  shippingMethodId: zod.z.string().min(1),
+  serviceCode: zod.z.string().nullable().optional(),
+  sellerId: zod.z.string().nullable().optional(),
+  shippingProfileId: zod.z.string().nullable().optional(),
+  locationId: zod.z.string().nullable().optional(),
+  pickupPointId: zod.z.string().nullable().optional(),
+  scheduledDate: zod.z.string().nullable().optional(),
+  scheduledTime: zod.z.string().nullable().optional()
+});
+var CartPaymentReceiptResponseSchema = zod.z.object({
+  id: zod.z.string(),
+  url: zod.z.string()
+});
+var CartPromotionCodeParamsSchema = zod.z.object({
+  cartId: zod.z.string().uuid(),
+  code: zod.z.string().min(1)
+});
+
+// src/services/checkout.service.ts
+async function getCartCheckout(api, params) {
+  const input = CartCheckoutReadParamsSchema.parse(params);
+  return api.get(
+    `carts/${encodeURIComponent(input.cartId)}/checkout`,
+    CartCheckoutReadResponseSchema
+  );
+}
+async function getShippingOptions(api, params) {
+  const input = GetShippingOptionsParamsSchema.parse(params);
+  return api.get(
+    `carts/${encodeURIComponent(input.cartId)}/shipping-options`,
+    ShippingOptionsResponseSchema,
+    { query: { postalCode: input.postalCode } }
+  );
+}
+async function putCartShippingMethod(api, params) {
+  const input = PutShippingMethodParamsSchema.parse(params);
+  const { cartId, ...body } = input;
+  return api.request(
+    "PUT",
+    `carts/${encodeURIComponent(cartId)}/shipping-method`,
+    StorefrontCartSchema,
+    { body }
+  );
+}
+async function patchCartBuyer(api, params) {
+  const input = CartBuyerParamsSchema.parse(params);
+  const { cartId, ...body } = input;
+  return api.request(
+    "PATCH",
+    `carts/${encodeURIComponent(cartId)}/buyer`,
+    StorefrontCartSchema,
+    { body }
+  );
+}
+async function patchCartAddresses(api, params) {
+  const input = CartAddressesParamsSchema.parse(params);
+  const { cartId, shippingAddress, billingAddress } = input;
+  return api.request(
+    "PATCH",
+    `carts/${encodeURIComponent(cartId)}/addresses`,
+    StorefrontCartSchema,
+    { body: { shippingAddress, billingAddress } }
+  );
+}
+async function checkoutCart(api, params) {
+  const input = CartCheckoutParamsSchema.parse(params);
+  const { cartId, ...body } = input;
+  return api.post(
+    `carts/${encodeURIComponent(cartId)}/checkout`,
+    body,
+    CartCheckoutResponseSchema
+  );
+}
+async function uploadPaymentReceipt(api, params) {
+  const cartId = CartCheckoutReadParamsSchema.shape.cartId.parse(params.cartId);
+  if (!(params.file instanceof Blob)) {
+    throw new TypeError("uploadPaymentReceipt requiere un archivo (Blob/File)");
+  }
+  const form = new FormData();
+  const name = params.fileName ?? (params.file instanceof File ? params.file.name : "receipt");
+  form.append("file", params.file, name);
+  return api.postForm(
+    `carts/${encodeURIComponent(cartId)}/payment-receipt`,
+    form,
+    CartPaymentReceiptResponseSchema
+  );
+}
+async function addCartPromotionCode(api, params) {
+  const input = CartPromotionCodeParamsSchema.parse(params);
+  return api.post(
+    `carts/${encodeURIComponent(input.cartId)}/promotion-codes`,
+    { code: input.code },
+    StorefrontCartSchema
+  );
+}
+async function removeCartPromotionCode(api, params) {
+  const input = CartPromotionCodeParamsSchema.parse(params);
+  return api.request(
+    "DELETE",
+    `carts/${encodeURIComponent(input.cartId)}/promotion-codes/${encodeURIComponent(input.code)}`,
+    StorefrontCartSchema
+  );
+}
+var CountrySchema = zod.z.object({
+  code: zod.z.string().length(2),
+  name: zod.z.string().min(1)
+}).strict();
+var CountriesSchema = zod.z.array(CountrySchema);
+var GeoDivisionTypeSchema = zod.z.enum(["level1", "level2", "level3"]);
+var GeoDivisionSchema = zod.z.object({
+  id: zod.z.string().uuid(),
+  countryCode: zod.z.string().length(2),
+  type: GeoDivisionTypeSchema,
+  code: zod.z.string().min(1),
+  name: zod.z.string().min(1),
+  parentId: zod.z.string().uuid().nullable(),
+  source: zod.z.string().min(1)
+}).strict();
+var DepartmentSchema = GeoDivisionSchema;
+var DepartmentsSchema = zod.z.array(DepartmentSchema);
+var GetDepartmentsParamsSchema = zod.z.object({
+  countryCode: zod.z.string().length(2),
+  source: zod.z.string().min(1).default("inei"),
+  search: zod.z.string().default(""),
+  limit: zod.z.number().int().positive().max(500).default(200)
+});
+var ProvinceSchema = GeoDivisionSchema;
+var ProvincesSchema = zod.z.array(ProvinceSchema);
+var GetProvincesParamsSchema = zod.z.object({
+  countryCode: zod.z.string().length(2),
+  departmentCode: zod.z.string().min(1),
+  source: zod.z.string().min(1).default("inei"),
+  search: zod.z.string().default(""),
+  limit: zod.z.number().int().positive().max(500).default(200)
+});
+var DistrictSchema = GeoDivisionSchema;
+var DistrictsSchema = zod.z.array(DistrictSchema);
+var GetDistrictsParamsSchema = zod.z.object({
+  countryCode: zod.z.string().length(2),
+  provinceCode: zod.z.string().min(1),
+  source: zod.z.string().min(1).default("inei"),
+  search: zod.z.string().default(""),
+  limit: zod.z.number().int().positive().max(500).default(200)
+});
+
+// src/services/geo.service.ts
+async function getCountries(api) {
+  return api.get("geo/countries", CountriesSchema);
+}
+async function getDepartments(api, params) {
+  const input = GetDepartmentsParamsSchema.parse(params);
+  return api.get("geo/departments", DepartmentsSchema, {
+    query: {
+      countryCode: input.countryCode,
+      source: input.source,
+      search: input.search,
+      limit: input.limit
+    }
+  });
+}
+async function getProvinces(api, params) {
+  const input = GetProvincesParamsSchema.parse(params);
+  return api.get("geo/provinces", ProvincesSchema, {
+    query: {
+      countryCode: input.countryCode,
+      departmentCode: input.departmentCode,
+      source: input.source,
+      search: input.search,
+      limit: input.limit
+    }
+  });
+}
+async function getDistricts(api, params) {
+  const input = GetDistrictsParamsSchema.parse(params);
+  return api.get("geo/districts", DistrictsSchema, {
+    query: {
+      countryCode: input.countryCode,
+      provinceCode: input.provinceCode,
+      source: input.source,
+      search: input.search,
+      limit: input.limit
+    }
+  });
+}
+
+// src/client.ts
+var DEFAULT_SETTINGS_CACHE_TTL_MS = 3e4;
+function createClient(options) {
+  const {
+    slug,
+    settingsCacheTtlMs = DEFAULT_SETTINGS_CACHE_TTL_MS,
+    ...apiOptions
+  } = options;
+  if (!slug?.trim()) {
+    throw new Error("createClient requiere `slug` (config.slug de ecomiq.config.js)");
+  }
+  if (!Number.isFinite(settingsCacheTtlMs) || settingsCacheTtlMs < 0) {
+    throw new Error("settingsCacheTtlMs debe ser un n\xFAmero mayor o igual a 0");
+  }
+  const api = createApi(apiOptions);
+  const apiClient = async () => {
+    const storeId = await getStoreId();
+    return createApi({
+      ...apiOptions,
+      headers: {
+        ...apiOptions.headers,
+        "x-Store-Id": storeId
+      }
+    });
+  };
+  let cache = null;
+  let inflight = null;
+  function clearCache() {
+    cache = null;
+    inflight = null;
+  }
+  async function getSettings() {
+    const now = Date.now();
+    if (cache && cache.expiresAt > now) return cache.data;
+    if (inflight) return inflight;
+    const previous = cache?.data;
+    inflight = api.get("settings", StorefrontSettingsSchema, {
+      headers: { "x-Store-Domain": slug }
+    }).then((data) => {
+      cache = { data, expiresAt: Date.now() + settingsCacheTtlMs };
+      return data;
+    }).catch((error) => {
+      if (previous) return previous;
+      throw error;
+    }).finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+  async function getStoreId() {
+    const settings = await getSettings();
+    return settings.store.id;
+  }
+  async function getCollections2() {
+    const client = await apiClient();
+    return getCollections(client);
+  }
+  async function getCollectionBySlug2(collectionSlug) {
+    const client = await apiClient();
+    return getCollectionBySlug(client, collectionSlug);
+  }
+  async function getProducts2(params = {}) {
+    const client = await apiClient();
+    return getProducts(client, params);
+  }
+  async function getProductBySlug2(productSlug, params = {}) {
+    const client = await apiClient();
+    return getProductBySlug(client, productSlug, params);
+  }
+  async function getRelatedProducts2(params) {
+    const client = await apiClient();
+    return getRelatedProducts(client, params);
+  }
+  async function autocompleteProducts2(params) {
+    const client = await apiClient();
+    return autocompleteProducts(client, params);
+  }
+  async function listProductReviews2(params) {
+    const client = await apiClient();
+    return listProductReviews(client, params);
+  }
+  async function createProductReview2(params) {
+    const client = await apiClient();
+    return createProductReview(client, params);
+  }
+  async function createCart2(params) {
+    const client = await apiClient();
+    return createCart(client, params);
+  }
+  async function getCart2(params) {
+    const client = await apiClient();
+    return getCart(client, params);
+  }
+  async function addCartItem2(params) {
+    const client = await apiClient();
+    return addCartItem(client, params);
+  }
+  async function updateCartItemQuantity2(params) {
+    const client = await apiClient();
+    return updateCartItemQuantity(client, params);
+  }
+  async function removeCartItem2(params) {
+    const client = await apiClient();
+    return removeCartItem(client, params);
+  }
+  async function getCartCheckout2(params) {
+    const client = await apiClient();
+    return getCartCheckout(client, params);
+  }
+  async function getShippingOptions2(params) {
+    const client = await apiClient();
+    return getShippingOptions(client, params);
+  }
+  async function putCartShippingMethod2(params) {
+    const client = await apiClient();
+    return putCartShippingMethod(client, params);
+  }
+  async function patchCartBuyer2(params) {
+    const client = await apiClient();
+    return patchCartBuyer(client, params);
+  }
+  async function patchCartAddresses2(params) {
+    const client = await apiClient();
+    return patchCartAddresses(client, params);
+  }
+  async function checkoutCart2(params) {
+    const client = await apiClient();
+    return checkoutCart(client, params);
+  }
+  async function uploadPaymentReceipt2(params) {
+    const client = await apiClient();
+    return uploadPaymentReceipt(client, params);
+  }
+  async function addCartPromotionCode2(params) {
+    const client = await apiClient();
+    return addCartPromotionCode(client, params);
+  }
+  async function removeCartPromotionCode2(params) {
+    const client = await apiClient();
+    return removeCartPromotionCode(client, params);
+  }
+  async function getCountries2() {
+    return getCountries(api);
+  }
+  async function getDepartments2(params) {
+    return getDepartments(api, params);
+  }
+  async function getProvinces2(params) {
+    return getProvinces(api, params);
+  }
+  async function getDistricts2(params) {
+    return getDistricts(api, params);
+  }
+  return {
+    ...api,
+    getSettings,
+    getStoreId,
+    getCollections: getCollections2,
+    getCollectionBySlug: getCollectionBySlug2,
+    clearCache,
+    getProducts: getProducts2,
+    getProductBySlug: getProductBySlug2,
+    getRelatedProducts: getRelatedProducts2,
+    autocompleteProducts: autocompleteProducts2,
+    listProductReviews: listProductReviews2,
+    createProductReview: createProductReview2,
+    createCart: createCart2,
+    getCart: getCart2,
+    addCartItem: addCartItem2,
+    updateCartItemQuantity: updateCartItemQuantity2,
+    removeCartItem: removeCartItem2,
+    getCartCheckout: getCartCheckout2,
+    getShippingOptions: getShippingOptions2,
+    putCartShippingMethod: putCartShippingMethod2,
+    patchCartBuyer: patchCartBuyer2,
+    patchCartAddresses: patchCartAddresses2,
+    checkoutCart: checkoutCart2,
+    uploadPaymentReceipt: uploadPaymentReceipt2,
+    addCartPromotionCode: addCartPromotionCode2,
+    removeCartPromotionCode: removeCartPromotionCode2,
+    getCountries: getCountries2,
+    getDepartments: getDepartments2,
+    getProvinces: getProvinces2,
+    getDistricts: getDistricts2
+  };
+}
+var createStorefrontClient = createClient;
+
+exports.createClient = createClient;
+exports.createStorefrontClient = createStorefrontClient;
+//# sourceMappingURL=client.cjs.map
+//# sourceMappingURL=client.cjs.map