@ecomiq/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1450 @@
+import { z } from 'zod';
+import sanitize from 'sanitize-html';
+
+// 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 = z.object({
+  id: z.number(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  type: z.string(),
+  productCount: z.number().optional()
+});
+var CollectionsSchema = z.array(CollectionSchema);
+var ProductPublicIdSchema = z.union([
+  z.string().regex(/^[1-9]\d*$/),
+  z.number().int().safe().positive()
+]).transform(String);
+var ProductSummarySchema = z.object({
+  id: ProductPublicIdSchema,
+  name: z.string(),
+  slug: z.string(),
+  productType: z.string(),
+  imageUrl: z.string(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().nullable(),
+  variantCount: z.number().int().nonnegative(),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  bundleItemsCount: z.number().int().nonnegative(),
+  brand: z.string(),
+  category: z.string(),
+  status: z.string(),
+  collections: z.array(z.string()),
+  tags: z.array(z.string())
+});
+var ProductSummariesSchema = z.array(ProductSummarySchema);
+var ProductSchema = ProductSummarySchema;
+var FacetItemSchema = z.object({
+  value: z.string(),
+  count: z.number().int().nonnegative(),
+  label: z.string().nullable(),
+  selected: z.boolean()
+});
+var FacetSchema = FacetItemSchema;
+var SearchFilterSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  type: z.enum(["list", "price_range"]),
+  values: z.array(FacetItemSchema),
+  min: z.number().nonnegative().nullable(),
+  max: z.number().nonnegative().nullable(),
+  selectedMin: z.number().nonnegative().nullable(),
+  selectedMax: z.number().nonnegative().nullable()
+});
+var ProductsResponseSchema = z.object({
+  pageIndex: z.number().int().positive(),
+  pageSize: z.number().int().positive().max(100),
+  totalCount: z.number().int().nonnegative(),
+  totalPages: z.number().int().nonnegative(),
+  products: z.array(ProductSummarySchema),
+  filters: z.array(SearchFilterSchema)
+});
+var ProductSortSchema = z.enum([
+  "price_asc",
+  "price_desc",
+  "name_asc",
+  "name_desc",
+  "newest"
+]);
+var ProductsParamsSchema = z.object({
+  page: z.number().int().positive().default(1),
+  pageSize: z.number().int().positive().max(100).default(24),
+  sort: ProductSortSchema.optional(),
+  sellerId: z.string().uuid().optional(),
+  search: z.string().optional(),
+  collection: z.string().optional(),
+  collections: z.array(z.string()).optional(),
+  collectionId: ProductPublicIdSchema.optional(),
+  category: z.string().optional(),
+  categories: z.array(z.string()).optional(),
+  brand: z.string().optional(),
+  brands: z.array(z.string()).optional(),
+  productType: z.string().optional(),
+  productTypes: z.array(z.string()).optional(),
+  tag: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  filters: z.array(z.string()).optional(),
+  locationId: z.string().uuid().optional(),
+  inStock: z.boolean().optional(),
+  minPrice: z.number().nonnegative().optional(),
+  maxPrice: z.number().nonnegative().optional()
+});
+var ProductDetailParamsSchema = z.object({
+  sellerId: z.string().uuid().optional()
+});
+var RelatedProductsParamsSchema = z.object({
+  productId: ProductPublicIdSchema,
+  limit: z.number().int().positive().max(12).default(8),
+  sellerId: z.string().uuid().optional()
+});
+var SpecItemSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  value: z.string()
+});
+var VariantOptionSchema = SpecItemSchema;
+var ProductImageSchema = z.object({
+  url: z.string(),
+  name: z.string(),
+  order: z.number().int().nonnegative()
+});
+var VariantItemSchema = z.object({
+  id: z.string().nullable(),
+  sku: z.string(),
+  status: z.string(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().nullable(),
+  quantity: z.number().int().nonnegative(),
+  options: z.array(SpecItemSchema),
+  images: z.array(ProductImageSchema)
+});
+var VariantSchema = VariantItemSchema;
+var ProductPriceTierSchema = z.object({
+  variantId: z.string(),
+  minQuantity: z.number().int().positive(),
+  maxQuantity: z.number().int().positive().nullable(),
+  unitPrice: z.number().nonnegative()
+});
+var PriceTierSchema = ProductPriceTierSchema;
+var BundleItemSchema = z.object({
+  productId: ProductPublicIdSchema,
+  variantId: ProductPublicIdSchema,
+  productName: z.string(),
+  variantName: z.string().nullable(),
+  sku: z.string().nullable(),
+  brand: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  quantity: z.number().int().positive(),
+  available: z.number().int().nonnegative(),
+  allowBackorders: z.boolean(),
+  requiresShipping: z.boolean()
+});
+var SizeGuideMeasurementSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  min: z.number().nullable(),
+  max: z.number().nullable(),
+  value: z.number().nullable(),
+  description: z.string().nullable()
+});
+var SizeGuideRowSchema = z.object({
+  label: z.string(),
+  sizeKey: z.string(),
+  order: z.number().int().nonnegative(),
+  measurements: z.array(SizeGuideMeasurementSchema)
+});
+var SizeGuideSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  gender: z.string(),
+  measurementType: z.string(),
+  unit: z.string(),
+  notes: z.string().nullable(),
+  rows: z.array(SizeGuideRowSchema)
+});
+var ProductDetailSchema = z.object({
+  id: ProductPublicIdSchema,
+  name: z.string(),
+  slug: z.string(),
+  description: z.string(),
+  productType: z.string(),
+  status: z.string(),
+  imageUrl: z.string(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().nullable(),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  brand: z.string(),
+  category: z.string(),
+  categoryId: ProductPublicIdSchema.nullable(),
+  tags: z.array(z.string()),
+  specifications: z.array(SpecItemSchema),
+  variants: z.array(VariantItemSchema),
+  images: z.array(ProductImageSchema),
+  bundleItems: z.array(BundleItemSchema),
+  sizeGuide: SizeGuideSchema.nullable(),
+  priceTiers: z.array(ProductPriceTierSchema),
+  createdAt: z.string().datetime({ offset: true }).nullable(),
+  updatedAt: z.string().datetime({ offset: true }).nullable()
+});
+var JsonElementSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(JsonElementSchema),
+    z.record(z.string(), JsonElementSchema)
+  ])
+);
+var DateTimeOffsetSchema = z.string().datetime({ offset: true });
+var NullableDateTimeOffsetSchema = DateTimeOffsetSchema.nullable();
+var NullableUuidSchema = z.string().uuid().nullable();
+var StoreTypeSchema = z.enum([
+  "b2C",
+  "marketplace",
+  "retail",
+  "b2B",
+  "social",
+  "hub",
+  "restaurant"
+]);
+var StoreVisibilitySchema = z.enum(["public", "private"]);
+var StoreThemeSettingsSchema = z.object({
+  name: z.string().nullable(),
+  mode: z.string().nullable(),
+  colors: z.record(z.string(), z.string()),
+  fonts: z.record(z.string(), z.string()),
+  assets: z.record(z.string(), z.string())
+}).strict();
+var StoreFeatureFlagsSchema = z.object({
+  flags: z.record(z.string(), z.boolean())
+}).strict();
+var StoreCheckoutGeneralSettingsSchema = z.object({
+  allowGuestCheckout: z.boolean(),
+  identityScope: z.enum(["store", "tenant", "global"]),
+  signInMethods: z.array(z.enum(["password", "emailOtp", "google"])),
+  useSequentialOrderNumbers: z.boolean(),
+  automaticallySelectFirstAddress: z.boolean(),
+  alwaysRequestCustomerAddress: z.boolean(),
+  requestCustomerDateOfBirth: z.boolean(),
+  automaticallySelectBestPromotion: z.boolean()
+}).strict();
+var StoreCheckoutShippingSettingsSchema = z.object({
+  showDeliveryTime: z.boolean(),
+  showDeliveryTimeInDays: z.boolean(),
+  useBusinessDaysForDeliveryTime: z.boolean(),
+  showEstimatedDeliveryDateInThankYouAndEmails: z.boolean(),
+  showOriginalShippingPriceWhenFree: z.boolean()
+}).strict();
+var StoreCheckoutCartPageSettingsSchema = z.object({
+  showShippingCostCalculation: z.boolean(),
+  allowProductLinks: z.boolean(),
+  redirectToCartPage: z.boolean()
+}).strict();
+var StoreCheckoutOrderBumpSettingsSchema = z.object({
+  mergeOrderBumpOrders: z.boolean(),
+  allowOnlyOneAdditionalOffer: z.boolean(),
+  maxVisibleOffers: z.number().int()
+}).strict();
+var StoreCheckoutOrdersAndPaymentsSettingsSchema = z.object({
+  allowPurchasesFrom: z.enum(["any", "individual", "company"]),
+  creditCardDailyOrderLimitPerIp: z.number().int().nullable(),
+  maximumItemsPerOrder: z.number().int().nullable(),
+  deliveryNoteText: z.string().nullable(),
+  boletoPaymentNoteText: z.string().nullable()
+}).strict();
+var StoreCheckoutSettingsSchema = z.object({
+  general: StoreCheckoutGeneralSettingsSchema,
+  shipping: StoreCheckoutShippingSettingsSchema,
+  cartPage: StoreCheckoutCartPageSettingsSchema,
+  orderBumps: StoreCheckoutOrderBumpSettingsSchema,
+  ordersAndPayments: StoreCheckoutOrdersAndPaymentsSettingsSchema
+}).strict();
+var StorefrontStoreShape = {
+  id: z.string().uuid(),
+  tenantId: z.string().uuid(),
+  sellerId: NullableUuidSchema,
+  type: StoreTypeSchema,
+  isActive: z.boolean(),
+  name: z.string(),
+  description: z.string(),
+  logo: z.string().nullable(),
+  icon: z.string().nullable(),
+  slug: z.string().nullable(),
+  domain: z.string().nullable(),
+  domains: z.array(z.string()),
+  timeZone: z.string(),
+  currency: z.string(),
+  language: z.string(),
+  visibility: StoreVisibilitySchema,
+  themeConfig: StoreThemeSettingsSchema,
+  featuresEnabled: StoreFeatureFlagsSchema,
+  checkoutSettings: StoreCheckoutSettingsSchema
+};
+var StoreModelSchema = z.object(StorefrontStoreShape).strict();
+var CmsBrandingSettingsDtoSchema = z.object({
+  logoUrl: z.string().nullable(),
+  logoDarkUrl: z.string().nullable(),
+  faviconUrl: z.string().nullable(),
+  socialImageUrl: z.string().nullable()
+}).strict();
+var CmsSeoSettingsDtoSchema = z.object({
+  siteName: z.string().nullable(),
+  metaTitle: z.string().nullable(),
+  metaDescription: z.string().nullable(),
+  titleTemplate: z.string().nullable(),
+  robotsIndex: z.boolean()
+}).strict();
+var CmsSocialLinksDtoSchema = z.object({
+  instagram: z.string().nullable(),
+  facebook: z.string().nullable(),
+  tiktok: z.string().nullable(),
+  youtube: z.string().nullable(),
+  x: z.string().nullable()
+}).strict();
+var CmsContactSettingsDtoSchema = z.object({
+  supportEmail: z.string().nullable(),
+  phone: z.string().nullable(),
+  whatsapp: z.string().nullable(),
+  address: z.string().nullable(),
+  socialLinks: CmsSocialLinksDtoSchema
+}).strict();
+var CmsTrackingSettingsDtoSchema = z.object({
+  googleAnalyticsMeasurementId: z.string().nullable(),
+  metaPixelId: z.string().nullable(),
+  googleTagManagerContainerId: z.string().nullable()
+}).strict();
+var CmsCustomScriptsDtoSchema = z.object({
+  enabled: z.boolean(),
+  head: z.string().nullable(),
+  bodyEnd: z.string().nullable()
+}).strict();
+var CmsSiteSettingsDtoSchema = z.object({
+  themeKey: z.string(),
+  branding: CmsBrandingSettingsDtoSchema,
+  seo: CmsSeoSettingsDtoSchema,
+  contact: CmsContactSettingsDtoSchema,
+  tracking: CmsTrackingSettingsDtoSchema,
+  customScripts: CmsCustomScriptsDtoSchema,
+  updatedOn: NullableDateTimeOffsetSchema
+}).strict();
+var CmsMenuItemSchema = z.lazy(
+  () => z.object({
+    label: z.string(),
+    url: z.string(),
+    order: z.number().int(),
+    target: z.string().nullable(),
+    visible: z.boolean().nullable(),
+    children: z.array(CmsMenuItemSchema).nullable()
+  }).strict()
+);
+var CmsMenuDtoSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  items: z.array(CmsMenuItemSchema)
+}).strict();
+var CmsBlockDtoSchema = z.object({
+  id: z.string().uuid(),
+  type: z.string(),
+  order: z.number().int(),
+  settings: JsonElementSchema
+}).strict();
+var CmsSectionDtoSchema = z.object({
+  id: z.string().uuid(),
+  type: z.string(),
+  order: z.number().int(),
+  settings: JsonElementSchema,
+  blocks: z.array(CmsBlockDtoSchema)
+}).strict();
+var CmsContentChannelSchema = z.enum(["storefront", "pos"]);
+var CmsPageStatusSchema = z.enum(["draft", "published", "archived"]);
+var CmsPageDetailsDtoSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  slug: z.string(),
+  channel: CmsContentChannelSchema,
+  layout: z.string(),
+  version: z.number().int().nullable(),
+  settings: JsonElementSchema,
+  sections: z.array(CmsSectionDtoSchema),
+  status: CmsPageStatusSchema,
+  hasPublishedVersion: z.boolean(),
+  publishedOn: NullableDateTimeOffsetSchema,
+  publishedBy: NullableUuidSchema,
+  createdOn: DateTimeOffsetSchema,
+  updatedOn: NullableDateTimeOffsetSchema,
+  createdBy: NullableUuidSchema,
+  updatedBy: NullableUuidSchema,
+  lastModifiedBy: z.string().nullable()
+}).strict();
+var CmsSnapshotDtoSchema = z.object({
+  settings: CmsSiteSettingsDtoSchema,
+  pages: z.array(CmsPageDetailsDtoSchema),
+  menus: z.array(CmsMenuDtoSchema)
+}).strict();
+var StoreSettingsSnapshotV1Schema = z.object({
+  schemaVersion: z.literal(1),
+  generatedAt: DateTimeOffsetSchema,
+  store: z.object(StorefrontStoreShape),
+  cms: CmsSnapshotDtoSchema
+}).strict();
+var StoreSettingsSnapshotV2Schema = z.object({
+  schemaVersion: z.literal(2),
+  generatedAt: DateTimeOffsetSchema,
+  store: StoreModelSchema,
+  cms: CmsSnapshotDtoSchema
+}).strict();
+var StoreSettingsSnapshotDtoSchema = z.discriminatedUnion(
+  "schemaVersion",
+  [StoreSettingsSnapshotV1Schema, StoreSettingsSnapshotV2Schema]
+);
+var StorefrontCheckoutSettingsSchema = StoreCheckoutSettingsSchema;
+var StorefrontFeaturesEnabledSchema = StoreFeatureFlagsSchema;
+var StorefrontCmsBrandingSchema = CmsBrandingSettingsDtoSchema;
+var StorefrontThemeConfigSchema = StoreThemeSettingsSchema;
+var StorefrontStoreTypeSchema = StoreTypeSchema;
+var StorefrontStoreSchema = StoreModelSchema;
+var StorefrontCmsSeoSchema = CmsSeoSettingsDtoSchema;
+var StorefrontCmsSocialLinksSchema = CmsSocialLinksDtoSchema;
+var StorefrontCmsContactSchema = CmsContactSettingsDtoSchema;
+var StorefrontCmsTrackingSchema = CmsTrackingSettingsDtoSchema;
+var StorefrontCmsCustomScriptsSchema = CmsCustomScriptsDtoSchema;
+var StorefrontCmsSettingsSchema = CmsSiteSettingsDtoSchema;
+var StorefrontMenuItemSchema = CmsMenuItemSchema;
+var StorefrontMenuSchema = CmsMenuDtoSchema;
+var StorefrontCmsPageSchema = CmsPageDetailsDtoSchema;
+var StorefrontSettingsSchema = StoreSettingsSnapshotDtoSchema;
+function getMenuItems(settings, key) {
+  const menu = settings?.cms.menus.find((candidate) => candidate.key === key);
+  return (menu?.items ?? []).filter((item) => item.visible !== false).slice().sort((a, b) => a.order - b.order);
+}
+
+// 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 = z.object({
+  search: z.string().min(2).max(80),
+  limit: z.number().int().positive().max(20).default(8),
+  sellerId: z.string().uuid().optional()
+});
+var ProductSuggestionSchema = z.object({
+  id: ProductPublicIdSchema,
+  name: z.string(),
+  slug: z.string(),
+  imageUrl: z.string()
+});
+var ProductSuggestionsSchema = 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 = z.object({
+  id: ProductPublicIdSchema,
+  productId: ProductPublicIdSchema,
+  isVerifiedPurchase: z.boolean(),
+  rating: z.number().int().min(1).max(5),
+  title: z.string().nullable(),
+  content: z.string(),
+  reviewerName: z.string().nullable(),
+  createdOn: z.string().datetime({ offset: true })
+});
+var StorefrontReviewsSchema = z.object({
+  data: z.array(StorefrontReviewSchema),
+  hasNextPage: z.boolean(),
+  nextCursor: z.string().nullable(),
+  totalCount: z.number().int().nonnegative().nullable()
+});
+var ListProductReviewsParamsSchema = z.object({
+  productId: ProductPublicIdSchema,
+  limit: z.number().int().min(1).max(200).optional(),
+  cursor: z.string().optional(),
+  search: z.string().optional(),
+  sortBy: z.enum(["rating", "createdOn"]).optional(),
+  sortDirection: z.enum(["asc", "desc"]).optional(),
+  rating: z.number().int().min(1).max(5).optional()
+});
+var CreateProductReviewParamsSchema = z.object({
+  productId: ProductPublicIdSchema,
+  rating: z.number().int().min(1).max(5),
+  content: z.string().min(1).max(4e3),
+  title: z.string().max(200).optional(),
+  reviewerName: z.string().min(1).max(200),
+  reviewerEmail: z.string().email().max(320),
+  orderId: 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
+  );
+}
+function cartVariantIdFromProduct(variantId) {
+  if (!/^\d+$/.test(variantId)) {
+    throw new RangeError("El variant ID debe ser un integer decimal positivo.");
+  }
+  const value = BigInt(variantId);
+  if (value <= 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError("El variant ID no cabe en un integer seguro de JavaScript.");
+  }
+  return Number(value);
+}
+var StorefrontAddressSchema = z.object({
+  name: z.string().nullable(),
+  address1: z.string(),
+  city: z.string(),
+  countryCode: z.string(),
+  company: z.string().nullable(),
+  address2: z.string().nullable(),
+  province: z.string().nullable(),
+  postalCode: z.string().nullable(),
+  district: z.string().nullable(),
+  phone: z.string().nullable(),
+  latitude: z.number().nullable(),
+  longitude: z.number().nullable()
+});
+var StorefrontCartBundleItemSchema = z.object({
+  productId: z.number().int().safe().nonnegative(),
+  variantId: z.number().int().safe().nonnegative(),
+  productName: z.string(),
+  variantName: z.string().nullable(),
+  sku: z.string().nullable(),
+  brand: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  quantity: z.number().int().positive()
+});
+var StorefrontCartItemSchema = z.object({
+  id: z.string().uuid(),
+  productId: z.number().int().safe().nonnegative(),
+  title: z.string(),
+  variantLabel: z.string().nullable(),
+  productHandle: z.string().nullable(),
+  thumbnail: z.string().nullable(),
+  quantity: z.number().int().positive(),
+  variantId: z.number().int().safe().nonnegative(),
+  variantSku: z.string().nullable(),
+  unitPrice: z.number(),
+  compareAtUnitPrice: z.number().nullable(),
+  bundleItems: z.array(StorefrontCartBundleItemSchema)
+});
+var StorefrontCartShippingMethodSchema = z.object({
+  id: z.string().uuid(),
+  shippingMethodId: z.string().uuid().nullable(),
+  rateId: z.string().uuid().nullable(),
+  name: z.string(),
+  description: z.string().nullable(),
+  total: z.number(),
+  locationId: z.string().uuid().nullable(),
+  estimatedDays: z.number().int().nullable(),
+  pickupPointId: z.string().uuid().nullable(),
+  scheduledDate: z.string().nullable(),
+  scheduledTime: z.string().nullable(),
+  serviceCode: z.string().nullable(),
+  sellerId: z.string().uuid().nullable(),
+  shippingProfileId: z.string().uuid().nullable()
+});
+var StorefrontCartTotalsSchema = z.object({
+  subtotal: z.number(),
+  discountTotal: z.number(),
+  shippingOriginalTotal: z.number(),
+  shippingTotal: z.number(),
+  taxTotal: z.number(),
+  warrantyTotal: z.number(),
+  total: z.number()
+});
+var StorefrontCartStatusSchema = z.enum([
+  "inProgress",
+  "pending",
+  "completed",
+  "abandoned",
+  "cancelled",
+  "expired",
+  "failed"
+]);
+var StorefrontCartSchema = z.object({
+  id: z.string().uuid(),
+  cartNumber: z.string(),
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  currencyCode: z.string(),
+  status: StorefrontCartStatusSchema,
+  completedAt: z.string().datetime({ offset: true }).nullable(),
+  shippingAddress: StorefrontAddressSchema.nullable(),
+  billingAddress: StorefrontAddressSchema.nullable(),
+  promotionCodes: z.array(z.string()),
+  items: z.array(StorefrontCartItemSchema),
+  shippingMethods: z.array(StorefrontCartShippingMethodSchema),
+  totals: StorefrontCartTotalsSchema
+});
+var CreateCartParamsSchema = z.object({
+  currencyCode: z.string().length(3),
+  salesChannelId: z.string().optional(),
+  email: z.string().email().optional()
+});
+var GetCartParamsSchema = z.object({
+  cartId: z.string().uuid()
+});
+var CartItemModifierSchema = z.object({
+  modifierGroupId: z.number().int().safe().positive(),
+  optionIds: z.array(z.number().int().safe().positive()).min(1)
+});
+var AddCartItemParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  variantId: z.number().int().safe().positive(),
+  quantity: z.number().int().positive(),
+  modifiers: z.array(CartItemModifierSchema).optional()
+});
+var UpdateCartItemQuantityParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  cartItemId: z.string().uuid(),
+  quantity: z.number().int().nonnegative()
+});
+var RemoveCartItemParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  cartItemId: 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 = z.object({
+  cartId: z.string().uuid(),
+  email: z.string().email(),
+  firstName: z.string().min(1),
+  lastName: z.string().min(1),
+  phone: z.string().min(1)
+});
+var CartAddressWriteSchema = z.object({
+  name: z.string().min(1),
+  address1: z.string().min(1),
+  city: z.string().min(1),
+  countryCode: z.string().length(2),
+  company: z.string().nullable().optional(),
+  address2: z.string().nullable().optional(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  geo: z.object({
+    departmentCode: z.string().nullable().optional(),
+    provinceCode: z.string().nullable().optional(),
+    districtCode: z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartAddressesParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  shippingAddress: CartAddressWriteSchema,
+  billingAddress: CartAddressWriteSchema
+});
+var CartPaymentMethodSchema = z.object({
+  code: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  kind: z.string(),
+  providerMethodCode: z.string().nullable().optional(),
+  isActive: z.boolean(),
+  isDefault: z.boolean(),
+  isManual: z.boolean(),
+  sortOrder: z.number(),
+  phoneNumber: z.string().nullable().optional(),
+  accountHolder: z.string().nullable().optional(),
+  qrImageUrl: z.string().nullable().optional()
+});
+var StorefrontOrderBumpSchema = z.object({
+  id: z.string(),
+  productPublicId: z.coerce.string(),
+  variantPublicId: z.coerce.string(),
+  productName: z.string(),
+  variantName: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  currencyCode: z.string(),
+  regularPrice: z.number(),
+  offerPrice: z.number(),
+  badgeLabel: z.string().nullable().optional(),
+  callToAction: z.string(),
+  description: z.string().nullable().optional()
+});
+var CartCheckoutReadParamsSchema = z.object({
+  cartId: z.string().uuid()
+});
+var CartCheckoutReadResponseSchema = z.object({
+  cart: StorefrontCartSchema,
+  paymentMethods: z.object({
+    methods: z.array(CartPaymentMethodSchema)
+  }),
+  orderBumps: z.array(StorefrontOrderBumpSchema).optional().default([])
+});
+var CartCheckoutPaymentActionSchema = z.object({
+  publicConfiguration: z.object({
+    publishableKey: z.string().nullable().optional(),
+    checkoutMode: z.string().nullable().optional(),
+    phoneNumber: z.string().nullable().optional(),
+    accountHolder: z.string().nullable().optional(),
+    qrImageUrl: z.string().nullable().optional()
+  }).passthrough().nullable().optional(),
+  url: z.string().nullable().optional(),
+  html: z.string().nullable().optional(),
+  clientSecret: z.string().nullable().optional(),
+  qrCode: z.string().nullable().optional(),
+  expiresAt: z.string().nullable().optional()
+}).passthrough();
+var CartCheckoutPaymentSchema = z.object({
+  transactionId: z.string(),
+  paymentMethodCode: z.string(),
+  providerId: z.string().nullable().optional(),
+  status: z.string(),
+  amount: z.number(),
+  reference: z.string(),
+  actionType: z.string(),
+  receiptUrl: z.string().nullable().optional(),
+  action: CartCheckoutPaymentActionSchema.nullable().optional()
+}).passthrough();
+var CartCheckoutResponseSchema = z.object({
+  publicKey: z.string().optional(),
+  publishableKey: z.string().optional(),
+  stripePublicKey: z.string().optional(),
+  clientSecret: z.string().optional(),
+  intentClientSecret: z.string().optional(),
+  orderId: z.coerce.string().optional(),
+  orderGroup: z.string().optional(),
+  orderIds: z.array(z.coerce.string()).optional(),
+  payment: CartCheckoutPaymentSchema.optional(),
+  cart: StorefrontCartSchema.optional()
+}).passthrough();
+var CartCheckoutParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  paymentMethodCode: z.string().min(1),
+  externalRef: z.string().min(1),
+  receiptUrl: z.string().min(1).optional()
+});
+var ShippingRateSchema = z.object({
+  shippingMethodId: z.string(),
+  name: z.string(),
+  displayName: z.string().optional(),
+  type: z.string().optional(),
+  price: z.number(),
+  currency: z.string().optional(),
+  sortOrder: z.number().optional(),
+  rateId: z.string(),
+  description: z.string().nullable().optional(),
+  deliveryLocationId: z.string().nullable().optional(),
+  deliveryLocationName: z.string().nullable().optional(),
+  estimatedDeliveryDays: z.number().nullable().optional(),
+  serviceCode: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var ShippingOptionGroupSchema = z.object({
+  sellerId: z.string(),
+  shippingProfileId: z.string().nullable().optional(),
+  orderAmount: z.number().optional(),
+  totalWeight: z.number().optional(),
+  itemIds: z.array(z.string()).optional(),
+  rates: z.array(ShippingRateSchema)
+}).passthrough();
+var ShippingOptionsResponseSchema = z.object({
+  groups: z.array(ShippingOptionGroupSchema)
+});
+var GetShippingOptionsParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  postalCode: z.string().min(1)
+});
+var PutShippingMethodParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  rateId: z.string().min(1),
+  shippingMethodId: z.string().min(1),
+  serviceCode: z.string().nullable().optional(),
+  sellerId: z.string().nullable().optional(),
+  shippingProfileId: z.string().nullable().optional(),
+  locationId: z.string().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional()
+});
+var CartPaymentReceiptResponseSchema = z.object({
+  id: z.string(),
+  url: z.string()
+});
+var CartPromotionCodeParamsSchema = z.object({
+  cartId: z.string().uuid(),
+  code: 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 = z.object({
+  code: z.string().length(2),
+  name: z.string().min(1)
+}).strict();
+var CountriesSchema = z.array(CountrySchema);
+var GeoDivisionTypeSchema = z.enum(["level1", "level2", "level3"]);
+var GeoDivisionSchema = z.object({
+  id: z.string().uuid(),
+  countryCode: z.string().length(2),
+  type: GeoDivisionTypeSchema,
+  code: z.string().min(1),
+  name: z.string().min(1),
+  parentId: z.string().uuid().nullable(),
+  source: z.string().min(1)
+}).strict();
+var DepartmentSchema = GeoDivisionSchema;
+var DepartmentsSchema = z.array(DepartmentSchema);
+var GetDepartmentsParamsSchema = z.object({
+  countryCode: z.string().length(2),
+  source: z.string().min(1).default("inei"),
+  search: z.string().default(""),
+  limit: z.number().int().positive().max(500).default(200)
+});
+var ProvinceSchema = GeoDivisionSchema;
+var ProvincesSchema = z.array(ProvinceSchema);
+var GetProvincesParamsSchema = z.object({
+  countryCode: z.string().length(2),
+  departmentCode: z.string().min(1),
+  source: z.string().min(1).default("inei"),
+  search: z.string().default(""),
+  limit: z.number().int().positive().max(500).default(200)
+});
+var DistrictSchema = GeoDivisionSchema;
+var DistrictsSchema = z.array(DistrictSchema);
+var GetDistrictsParamsSchema = z.object({
+  countryCode: z.string().length(2),
+  provinceCode: z.string().min(1),
+  source: z.string().min(1).default("inei"),
+  search: z.string().default(""),
+  limit: 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;
+var STOREFRONT_HTML_ALLOWLIST = {
+  allowedTags: [
+    "a",
+    "b",
+    "blockquote",
+    "br",
+    "code",
+    "col",
+    "colgroup",
+    "div",
+    "em",
+    "figcaption",
+    "figure",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "tr",
+    "u",
+    "ul"
+  ],
+  allowedAttributes: {
+    a: ["href", "rel", "target", "title"],
+    col: ["span"],
+    img: ["alt", "height", "loading", "src", "title", "width"],
+    td: ["colspan", "rowspan"],
+    th: ["colspan", "rowspan", "scope"]
+  },
+  allowedSchemes: ["http", "https", "mailto", "tel"],
+  allowedSchemesAppliedToAttributes: ["href", "src"],
+  allowProtocolRelative: false,
+  disallowedTagsMode: "discard",
+  enforceHtmlBoundary: true,
+  parseStyleAttributes: false,
+  transformTags: {
+    a: (tagName, attributes) => {
+      if (attributes.target !== "_blank") return { tagName, attribs: attributes };
+      return {
+        tagName,
+        attribs: {
+          ...attributes,
+          rel: "noopener noreferrer"
+        }
+      };
+    }
+  }
+};
+function sanitizeHtml(html) {
+  return sanitize(html, STOREFRONT_HTML_ALLOWLIST);
+}
+function stripHtml(html) {
+  return html.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+
+export { AddCartItemParamsSchema, ApiError, BundleItemSchema, CartAddressWriteSchema, CartAddressesParamsSchema, CartBuyerParamsSchema, CartCheckoutParamsSchema, CartCheckoutPaymentActionSchema, CartCheckoutPaymentSchema, CartCheckoutReadParamsSchema, CartCheckoutReadResponseSchema, CartCheckoutResponseSchema, CartItemModifierSchema, CartPaymentMethodSchema, CartPaymentReceiptResponseSchema, CartPromotionCodeParamsSchema, CmsBlockDtoSchema, CmsBrandingSettingsDtoSchema, CmsContactSettingsDtoSchema, CmsContentChannelSchema, CmsCustomScriptsDtoSchema, CmsMenuDtoSchema, CmsMenuItemSchema, CmsPageDetailsDtoSchema, CmsPageStatusSchema, CmsSectionDtoSchema, CmsSeoSettingsDtoSchema, CmsSiteSettingsDtoSchema, CmsSnapshotDtoSchema, CmsSocialLinksDtoSchema, CmsTrackingSettingsDtoSchema, CollectionSchema, CollectionsSchema, CountriesSchema, CountrySchema, CreateCartParamsSchema, CreateProductReviewParamsSchema, DEFAULT_API_BASE_URL, DEFAULT_API_VERSION, DepartmentSchema, DepartmentsSchema, DistrictSchema, DistrictsSchema, FacetItemSchema, FacetSchema, GeoDivisionSchema, GeoDivisionTypeSchema, GetCartParamsSchema, GetDepartmentsParamsSchema, GetDistrictsParamsSchema, GetProvincesParamsSchema, GetShippingOptionsParamsSchema, JsonElementSchema, ListProductReviewsParamsSchema, PriceTierSchema, ProductAutocompleteParamsSchema, ProductDetailParamsSchema, ProductDetailSchema, ProductImageSchema, ProductPriceTierSchema, ProductPublicIdSchema, ProductSchema, ProductSortSchema, ProductSuggestionSchema, ProductSuggestionsSchema, ProductSummariesSchema, ProductSummarySchema, ProductsParamsSchema, ProductsResponseSchema, ProvinceSchema, ProvincesSchema, PutShippingMethodParamsSchema, RelatedProductsParamsSchema, RemoveCartItemParamsSchema, SearchFilterSchema, ShippingOptionGroupSchema, ShippingOptionsResponseSchema, ShippingRateSchema, SizeGuideMeasurementSchema, SizeGuideRowSchema, SizeGuideSchema, SpecItemSchema, StoreCheckoutCartPageSettingsSchema, StoreCheckoutGeneralSettingsSchema, StoreCheckoutOrderBumpSettingsSchema, StoreCheckoutOrdersAndPaymentsSettingsSchema, StoreCheckoutSettingsSchema, StoreCheckoutShippingSettingsSchema, StoreFeatureFlagsSchema, StoreModelSchema, StoreSettingsSnapshotDtoSchema, StoreThemeSettingsSchema, StoreTypeSchema, StoreVisibilitySchema, StorefrontAddressSchema, StorefrontCartBundleItemSchema, StorefrontCartItemSchema, StorefrontCartSchema, StorefrontCartShippingMethodSchema, StorefrontCartStatusSchema, StorefrontCartTotalsSchema, StorefrontCheckoutSettingsSchema, StorefrontCmsBrandingSchema, StorefrontCmsContactSchema, StorefrontCmsCustomScriptsSchema, StorefrontCmsPageSchema, StorefrontCmsSeoSchema, StorefrontCmsSettingsSchema, StorefrontCmsSocialLinksSchema, StorefrontCmsTrackingSchema, StorefrontFeaturesEnabledSchema, StorefrontMenuItemSchema, StorefrontMenuSchema, StorefrontOrderBumpSchema, StorefrontReviewSchema, StorefrontReviewsSchema, StorefrontSettingsSchema, StorefrontStoreSchema, StorefrontStoreTypeSchema, StorefrontThemeConfigSchema, UpdateCartItemQuantityParamsSchema, VariantItemSchema, VariantOptionSchema, VariantSchema, addCartItem, addCartPromotionCode, autocompleteProducts, cartVariantIdFromProduct, checkoutCart, createApi, createCart, createClient, createProductReview, createStorefrontClient, getCart, getCartCheckout, getCountries, getDepartments, getDistricts, getMenuItems, getProductBySlug, getProducts, getProvinces, getRelatedProducts, getShippingOptions, listProductReviews, patchCartAddresses, patchCartBuyer, putCartShippingMethod, removeCartItem, removeCartPromotionCode, resolveApiBaseUrl, sanitizeHtml, stripHtml, updateCartItemQuantity, uploadPaymentReceipt };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map