@growupsell/commerce 0.0.0-stage → 1.0.0-alpha.1

package/dist/chunk-YZJTPFCH.js

@@ -0,0 +1,2789 @@
+// src/http/convert.ts
+var text = (value) => value == null || value.trim() === "" ? null : value;
+var amount = (value) => {
+  if (value == null || value === "") return null;
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : null;
+};
+
+// src/http/blog.ts
+var PUBLIC = { anonymous: true, business: "required" };
+var MERCHANT = { merchant: true, anonymous: true, business: "required" };
+function createBlogApi(request) {
+  return {
+    async list(options = {}) {
+      const categorySlug = options.categorySlug?.trim();
+      const rows = await request("GET", "/blog/list", {
+        ...PUBLIC,
+        query: categorySlug ? { category_slug: categorySlug } : void 0
+      });
+      return rows.map(toBlogPostSummary);
+    },
+    async get(slug) {
+      return toBlogPost(await request("GET", `/blog/get/${path(slug)}`, PUBLIC));
+    },
+    async updateBody(slug, body) {
+      const json = { body };
+      await request("PATCH", `/blog/update/${path(slug)}`, { ...MERCHANT, json });
+    }
+  };
+}
+function path(slug) {
+  if (!slug.trim()) throw new Error("blog: slug is required.");
+  return encodeURIComponent(slug.trim());
+}
+function toBlogPostSummary(wire) {
+  return summary(wire, wire.user);
+}
+function toBlogPost(wire) {
+  return {
+    ...summary(wire, wire.created_by),
+    body: Array.isArray(wire.body) ? wire.body.filter((s) => typeof s === "string") : [],
+    editor: EDITORS.includes(wire.editor_type) ? wire.editor_type : "quill"
+  };
+}
+var EDITORS = ["quill", "ckeditor", "froala"];
+function summary(wire, author) {
+  return {
+    id: wire.id,
+    slug: wire.slug,
+    title: wire.title,
+    shortDescription: text(wire.short_description),
+    image: text(wire.image),
+    category: wire.category ? toCategory(wire.category) : null,
+    tags: Array.isArray(wire.tags) ? wire.tags.filter((t) => typeof t === "string" && t.trim() !== "") : [],
+    author: author ? toAuthor(author) : null,
+    isPublished: wire.is_published ?? false,
+    createdAt: wire.created_at,
+    updatedAt: wire.updated_at
+  };
+}
+function toCategory(wire) {
+  return {
+    id: wire.id,
+    name: text(wire.name),
+    slug: wire.slug,
+    image: text(wire.image),
+    seoDescription: text(wire.seo_description)
+  };
+}
+function toAuthor(wire) {
+  return { id: wire.id, name: text(wire.name.trim()), photo: text(wire.photo) };
+}
+
+// src/http/business.ts
+var PUBLIC2 = { business: "required", anonymous: true };
+var MERCHANT2 = { merchant: true, anonymous: true };
+function createBusinessApi(request) {
+  return {
+    async detail(domain) {
+      const trimmed = domain.trim();
+      if (!trimmed) throw new Error("business.detail: domain is required.");
+      const wire = await request(
+        "GET",
+        `/business/detail/${encodeURIComponent(trimmed)}`,
+        { anonymous: true }
+      );
+      return toBusiness(wire);
+    },
+    async settings() {
+      return toBusinessSettings(
+        await request("GET", "/business/setting/get", PUBLIC2)
+      );
+    },
+    async media() {
+      return toBusinessMedia(
+        await request("GET", "/business/media/get", PUBLIC2)
+      );
+    },
+    async socialLinks() {
+      return toSocialLinks(
+        await request(
+          "GET",
+          "/business/social-media-link/get",
+          PUBLIC2
+        )
+      );
+    },
+    async bankTransferOptions() {
+      const wire = await request(
+        "GET",
+        "/business/direct/transfer/list",
+        {
+          business: "required"
+        }
+      );
+      return wire.filter((o) => !o.deleted).map(toBankTransferOption);
+    },
+    async themeSettings() {
+      return toThemeSettings(
+        await request("GET", "/business/theme/setting/get", PUBLIC2)
+      );
+    },
+    async updateThemeSettings(changes) {
+      const wire = await request(
+        "PATCH",
+        "/business/theme/setting/update",
+        { ...MERCHANT2, json: toThemeSettingWrite(changes) }
+      );
+      return toThemeSettings(wire);
+    }
+  };
+}
+function toBusiness(wire) {
+  const tag = wire.website_tag;
+  return {
+    id: wire.id,
+    name: wire.name ?? null,
+    description: wire.description ?? null,
+    legalName: wire.legal_name ?? null,
+    gstNumber: wire.gst_number ?? null,
+    panNumber: wire.pan_number ?? null,
+    isTemplate: wire.is_template ?? false,
+    category: wire.category ? { id: wire.category.id, name: wire.category.name, type: wire.category.type } : null,
+    legalForm: wire.legal_forms ? { id: wire.legal_forms.id, name: wire.legal_forms.name } : null,
+    features: wire.features.filter((f) => f.is_active !== false).map((f) => f.name),
+    googleTagManagerId: tag?.is_active && tag.gtm_container_id ? tag.gtm_container_id : null,
+    createdAt: wire.created_at,
+    updatedAt: wire.updated_at
+  };
+}
+function toBusinessSettings(wire) {
+  return {
+    currency: wire.currency ? { code: wire.currency.currency_code, symbol: wire.currency.currency_symbol } : null,
+    domain: text(wire.domain)
+  };
+}
+function toBusinessMedia(wire) {
+  return { logoSquare: text(wire.logo_square), logoRectangle: text(wire.logo_rectangle) };
+}
+function toSocialLinks(wire) {
+  return {
+    facebook: text(wire.facebook),
+    instagram: text(wire.instagram),
+    twitter: text(wire.twitter),
+    telegram: text(wire.telegram),
+    whatsapp: text(wire.whatsapp),
+    linkedin: text(wire.linkedin)
+  };
+}
+function toThemeSettings(wire) {
+  return {
+    id: wire.id,
+    // Required by the model; '#CCC' is its default.
+    primaryColor: text(wire.primary_color) ?? "#CCC",
+    accentColor: text(wire.accent_color),
+    fontFamily: text(wire.font_family),
+    websiteThemeId: themeId(wire.website_theme),
+    appThemeId: themeId(wire.app_theme)
+  };
+}
+var themeId = (theme) => typeof theme === "number" ? theme : theme?.id ?? null;
+function toThemeSettingWrite(changes) {
+  const body = {};
+  if (changes.primaryColor !== void 0) body.primary_color = changes.primaryColor;
+  if (changes.accentColor !== void 0) body.accent_color = changes.accentColor;
+  if (changes.fontFamily !== void 0) body.font_family = changes.fontFamily;
+  if (changes.websiteThemeId !== void 0) body.website_theme = changes.websiteThemeId;
+  if (changes.appThemeId !== void 0) body.app_theme = changes.appThemeId;
+  return body;
+}
+function toBankTransferOption(wire) {
+  return {
+    id: wire.id,
+    type: text(wire.type),
+    description: text(wire.description),
+    photo: text(wire.photo),
+    paymentMethodId: wire.payment_method ?? null
+  };
+}
+
+// src/http/cart.ts
+var SHOPPER = { business: "required", customerOrSession: "required" };
+function createCartApi(request) {
+  async function removeItem(lineId) {
+    await request("DELETE", `/order/cart/product/delete/${lineId}`, SHOPPER);
+  }
+  return {
+    async get() {
+      return toCart(await request("GET", "/order/cart/get", SHOPPER));
+    },
+    async addItem({ skuId, quantity, customData }) {
+      checkQuantity(quantity, 1);
+      const json = { sku: skuId, qty: quantity };
+      if (customData) json.custom_data = customData;
+      const wire = await request("POST", "/order/cart/product/create", {
+        ...SHOPPER,
+        json
+      });
+      return { lineId: wire.id };
+    },
+    async setQuantity(lineId, quantity) {
+      checkQuantity(quantity, 0);
+      if (quantity === 0) return removeItem(lineId);
+      await request("PATCH", `/order/cart/product/update/${lineId}`, {
+        ...SHOPPER,
+        json: { qty: quantity }
+      });
+    },
+    removeItem,
+    async setOrderType(type) {
+      const wire = await request("PATCH", "/order/cart/type/update", {
+        ...SHOPPER,
+        json: { type }
+      });
+      return {
+        subtotal: amount(wire.total_amount) ?? 0,
+        deliveryCharge: amount(wire.delivery_charge) ?? 0,
+        payable: amount(wire.final_payable_amount) ?? 0
+      };
+    },
+    async setAddresses({ shippingAddressId, billingAddressId }) {
+      if (shippingAddressId == null && billingAddressId == null) {
+        throw new TypeError("setAddresses: pass shippingAddressId, billingAddressId or both.");
+      }
+      const json = {};
+      if (shippingAddressId != null) json.shipping_address = shippingAddressId;
+      if (billingAddressId != null) json.billing_address = billingAddressId;
+      const wire = await request("PATCH", "/order/cart/address/update", {
+        business: "required",
+        customer: "required",
+        json
+      });
+      return {
+        shippingAddressId: wire.shipping_address ?? null,
+        billingAddressId: wire.billing_address ?? null
+      };
+    },
+    async applyOffer(offerId) {
+      const json = { offer: offerId };
+      await request("PATCH", "/order/cart/offer/update", { ...SHOPPER, json });
+    },
+    async applyPromoCode(promoCodeId) {
+      const json = { promo: promoCodeId };
+      await request("PATCH", "/order/cart/promo/update", { ...SHOPPER, json });
+    },
+    async setTaxDetails({ legalName, taxNumber }) {
+      const json = { legal_name: legalName, tax_number: taxNumber };
+      const wire = await request("PATCH", "/order/cart/tax/update", {
+        business: "required",
+        session: "required",
+        json
+      });
+      return { legalName: wire.legal_name, taxNumber: wire.tax_number };
+    },
+    async deliveryEstimate(cartId, options = {}) {
+      const wire = await request(
+        "GET",
+        `/order/cart/delivery/charge/info/get/${cartId}`,
+        // The backend calls Shiprocket synchronously; a blank pincode is left out.
+        { ...SHOPPER, timeoutMs: 3e4, query: { pincode: options.pincode?.trim() } }
+      );
+      return {
+        deliveryCharge: amount(wire.delivery_charge) ?? 0,
+        payable: amount(wire.final_payable_amount) ?? 0,
+        estimatedDelivery: text(wire.estimate_delivery_day)
+      };
+    }
+  };
+}
+function checkQuantity(quantity, min) {
+  if (!Number.isInteger(quantity) || quantity < min) {
+    throw new RangeError(`Cart quantity must be a whole number of at least ${min}: ${quantity}.`);
+  }
+}
+function toCart(wire) {
+  const lines = (wire.products ?? []).map(toCartLine);
+  const orderOffer = amount(wire.offer_redeem_amount) ?? 0;
+  return {
+    id: wire.id,
+    type: wire.type,
+    lines,
+    subtotal: amount(wire.total_amount) ?? 0,
+    // The backend stores the offer amount on the order for order-level offers, or on each line
+    // for product, category and brand offers (never both).
+    offerDiscount: orderOffer > 0 ? orderOffer : sum(lines.map((line) => line.offerDiscount)),
+    promoDiscount: amount(wire.promo_redeem_amount) ?? 0,
+    deliveryCharge: amount(wire.delivery_charge) ?? 0,
+    payable: amount(wire.final_payable_amount) ?? 0,
+    deliveryChargeType: wire.delivery_charge_type ?? null,
+    offer: wire.offers ? { id: wire.offers.id, name: wire.offers.name, couponCode: text(wire.offers.coupon_code) } : null,
+    promoCode: wire.promo ? toAppliedPromoCode(wire.promo) : null,
+    shippingAddressId: idOf(wire.shipping_address),
+    billingAddressId: idOf(wire.billing_address),
+    advanceAmount: amount(wire.advance_amount)
+  };
+}
+function toCartLine(wire) {
+  const { sku } = wire;
+  const mrp = sku ? amount(sku.mrp) : null;
+  return {
+    id: wire.id,
+    skuId: sku?.id ?? null,
+    productId: sku?.product.id ?? null,
+    name: wire.label ?? wire.name ?? "",
+    photo: text(wire.photo),
+    unitPrice: amount(wire.price) ?? 0,
+    // An MRP of 0 means "not set", as in products.
+    mrp: mrp && mrp > 0 ? mrp : null,
+    quantity: wire.qty,
+    lineTotal: amount(wire.total) ?? 0,
+    offerDiscount: amount(wire.offer_redeem_amount) ?? 0,
+    taxPercent: amount(wire.tax),
+    maxQuantity: sku ? wire.max_qty : null,
+    isDigital: wire.is_digital_product,
+    fulfillmentMode: text(wire.fulfillment_mode) ?? "none",
+    customData: wire.custom_data ?? null,
+    variantIds: sku?.selected_variants ?? []
+  };
+}
+function toAppliedPromoCode(wire) {
+  return {
+    id: wire.id,
+    code: wire.code ?? "",
+    type: wire.type ?? "percentage",
+    value: amount(wire.value) ?? 0
+  };
+}
+function idOf(value) {
+  if (value == null) return null;
+  return typeof value === "number" ? value : value.id;
+}
+function sum(values) {
+  return Math.round(values.reduce((total, value) => total + value, 0) * 100) / 100;
+}
+
+// src/http/catalog.ts
+var PUBLIC3 = { business: "required", anonymous: true };
+function createCatalogApi(request) {
+  return {
+    async categories(options = {}) {
+      const search = options.search?.trim();
+      const wire = await request("GET", "/product/category/list", {
+        ...PUBLIC3,
+        query: { search }
+      });
+      return wire.map(toCategoryTree);
+    },
+    async category(id) {
+      return toCategory2(
+        await request("GET", `/product/category/get/${id}`, {
+          anonymous: true
+        })
+      );
+    },
+    async categoriesByIds(ids) {
+      if (ids.length === 0) return [];
+      const wire = await request("GET", "/product/category/list/filter", {
+        ...PUBLIC3,
+        query: { ids }
+      });
+      return wire.map(toCategory2);
+    },
+    async brands(options = {}) {
+      const wire = await request("GET", "/product/brand/list", {
+        ...PUBLIC3,
+        query: { category_ids: options.categoryIds }
+      });
+      return wire.map(toBrand);
+    },
+    async settings() {
+      return toCatalogSettings(
+        await request("GET", "/product/business/setting/get", PUBLIC3)
+      );
+    }
+  };
+}
+function toCategory2(wire) {
+  return {
+    id: wire.id,
+    name: wire.name,
+    description: text(wire.description),
+    photo: text(wire.photo),
+    parentId: wire.parent ?? null,
+    productCount: wire.product_count
+  };
+}
+function toCategoryTree(wire) {
+  return { ...toCategory2(wire), children: wire.child.map(toCategoryTree) };
+}
+function toBrand(wire) {
+  return {
+    id: wire.id,
+    name: wire.name,
+    description: text(wire.description),
+    photo: text(wire.photo),
+    productCount: wire.product_count
+  };
+}
+function toCatalogSettings(wire) {
+  return {
+    reviews: wire.is_active_review ?? true,
+    brands: wire.is_active_brand ?? true,
+    categories: wire.is_active_category ?? true,
+    subscriptions: wire.is_active_subscription ?? true,
+    digitalDelivery: wire.enable_digital_delivery ?? false,
+    variants: wire.is_active_variants ?? true,
+    specifications: wire.is_active_specification ?? true,
+    unitTracking: wire.has_product_unit_tracking_info ?? false,
+    manufactureAndExpiryDates: wire.has_mfg_expiry_date ?? false
+  };
+}
+
+// src/http/faq.ts
+var PUBLIC4 = { business: "required", anonymous: true };
+var MERCHANT3 = { business: "required", merchant: true, anonymous: true };
+function createFaqApi(request) {
+  return {
+    async list() {
+      return (await request("GET", "/content/faq/list", PUBLIC4)).map(toFaq);
+    },
+    async create(input) {
+      const json = { question: input.question, answer: input.answer };
+      return toFaq(await request("POST", "/content/faq/create", { ...MERCHANT3, json }));
+    },
+    async update(id, changes) {
+      const json = {};
+      if (changes.question !== void 0) json.question = changes.question;
+      if (changes.answer !== void 0) json.answer = changes.answer;
+      return toFaq(
+        await request("PATCH", `/content/faq/update/${id}`, { ...MERCHANT3, json })
+      );
+    },
+    async move(id, direction) {
+      const json = { direction };
+      await request("PATCH", `/content/faq/update/${id}`, { ...MERCHANT3, json });
+    },
+    async remove(id) {
+      await request("DELETE", `/content/faq/delete/${id}`, MERCHANT3);
+    }
+  };
+}
+function toFaq(wire) {
+  return {
+    id: wire.id,
+    question: text(wire.question),
+    answer: text(wire.answer),
+    displayOrder: wire.display_order
+  };
+}
+
+// src/http/forms.ts
+var PUBLIC5 = { anonymous: true, business: "required" };
+var SUBMIT = { business: "required" };
+var MERCHANT4 = { merchant: true, anonymous: true, business: "required" };
+function createFormsApi(request) {
+  return {
+    async get(slug) {
+      return toPublicForm(
+        await request("GET", `/forms/public/${path2(slug)}`, PUBLIC5)
+      );
+    },
+    async submit(slug, values) {
+      const json = { data: values };
+      await request("POST", `/forms/submit/${path2(slug)}`, { ...SUBMIT, json });
+    },
+    async listForMerchant() {
+      const rows = await request("GET", "/forms/list", {
+        ...MERCHANT4,
+        query: { is_active: true }
+      });
+      return rows.map(toFormSummary);
+    }
+  };
+}
+function path2(slug) {
+  if (!slug.trim()) throw new Error("forms: slug is required.");
+  return encodeURIComponent(slug.trim());
+}
+function toPublicForm(wire) {
+  const fields = Array.isArray(wire.field_configuration) ? wire.field_configuration : [];
+  return {
+    id: wire.id,
+    slug: wire.slug,
+    name: wire.name,
+    description: text(wire.description),
+    successMessage: text(wire.success_message),
+    fields: fields.map(toFormField)
+  };
+}
+function toFormSummary(wire) {
+  return { id: wire.id, name: wire.name, slug: wire.slug };
+}
+function toFormField(wire) {
+  return {
+    name: wire.name,
+    // The backend only saves the ten known types (`validation.py:4-7`).
+    type: wire.type,
+    required: wire.required,
+    label: text(wire.label) ?? wire.name.replace(/_/g, " "),
+    options: wire.options?.map((o) => ({ label: o.label, value: o.value })) ?? []
+  };
+}
+
+// src/http/helpdesk.ts
+var CREATE = { business: "required" };
+function createHelpdeskApi(request) {
+  return {
+    async createInquiry(input) {
+      const title = input.subject.trim();
+      const description = input.message.trim();
+      if (!title || !description) {
+        throw new Error("helpdesk.createInquiry: subject and message are required.");
+      }
+      const json = { title, description };
+      const name = input.name?.trim();
+      const email = input.email?.trim();
+      const phone = input.phone?.trim();
+      if (name) json.name = name;
+      if (email) json.email = email;
+      if (phone) json.phone_number = phone;
+      await request("POST", "/helpdesk/inquiry/web/create", { ...CREATE, json });
+    }
+  };
+}
+
+// src/http/newsletter.ts
+var PUBLIC6 = { anonymous: true, business: "required" };
+function createNewsletterApi(request) {
+  return {
+    async subscribe(email) {
+      const json = { email: required(email, "email") };
+      await request("POST", "/subscribers/create/email", {
+        ...PUBLIC6,
+        json
+      });
+    },
+    async verify(email, otp) {
+      const json = { email: required(email, "email"), otp: required(otp, "otp") };
+      await request("PATCH", "/subscribers/email/verify", {
+        ...PUBLIC6,
+        json
+      });
+    }
+  };
+}
+function required(value, name) {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(`newsletter: ${name} is required.`);
+  return trimmed;
+}
+
+// src/http/live-support.ts
+var PUBLIC7 = { anonymous: true, business: "required" };
+function createLiveSupportApi(request) {
+  return {
+    async widget() {
+      return toLiveSupportWidget(
+        await request(
+          "GET",
+          "/website/live-support-widget/config/get",
+          PUBLIC7
+        )
+      );
+    }
+  };
+}
+function toLiveSupportWidget(wire) {
+  const number = text(wire.whatsapp_no)?.trim();
+  if (!wire.is_active || !number) return null;
+  return { channel: "whatsapp", whatsappNumber: number };
+}
+
+// src/http/policies.ts
+var TYPES = {
+  privacy_policy: "privacy",
+  terms_of_use: "terms-of-use",
+  cancellations_refunds_policy: "cancellation-refund",
+  shipping_policy: "shipping",
+  warranty_policy: "warranty"
+};
+var WIRE_TYPES = Object.fromEntries(
+  Object.entries(TYPES).map(([wire, type]) => [type, wire])
+);
+var PUBLIC8 = { business: "required", anonymous: true };
+var MERCHANT5 = { merchant: true, anonymous: true };
+function createPoliciesApi(request) {
+  return {
+    async list(options = {}) {
+      const wire = await request("GET", "/policy_and_terms/list", {
+        ...PUBLIC8,
+        query: { type: options.type && WIRE_TYPES[options.type] }
+      });
+      return wire.map(toPolicy).filter((p) => p !== null);
+    },
+    async create(input) {
+      const wire = await request("POST", "/policy_and_terms/create", {
+        ...MERCHANT5,
+        business: "required",
+        json: toWrite(input)
+      });
+      return required2(wire);
+    },
+    async createMany(inputs) {
+      if (inputs.length === 0) return [];
+      const wire = await request("POST", "/policy_and_terms/bulk/create", {
+        ...MERCHANT5,
+        json: inputs.map(toWrite)
+      });
+      return wire.map(required2);
+    },
+    async update(id, changes) {
+      const wire = await request("PUT", `/policy_and_terms/update/${id}`, {
+        ...MERCHANT5,
+        json: toWrite(changes)
+      });
+      return required2(wire);
+    },
+    async move(id, direction) {
+      const body = { direction };
+      await request("PUT", `/policy_and_terms/update/${id}`, {
+        ...MERCHANT5,
+        json: body
+      });
+    },
+    async remove(id) {
+      await request("DELETE", `/policy_and_terms/delete/${id}`, MERCHANT5);
+    }
+  };
+}
+function toWrite(input) {
+  const body = {};
+  if (input.type !== void 0) body.type = WIRE_TYPES[input.type];
+  if (input.heading !== void 0) body.heading = input.heading;
+  if (input.description !== void 0) body.description = input.description;
+  return body;
+}
+var required2 = (wire) => toPolicy(wire);
+function toPolicy(wire) {
+  const type = TYPES[wire.type];
+  if (!type) return null;
+  return {
+    id: wire.id,
+    type,
+    heading: wire.heading,
+    description: text(wire.description),
+    displayOrder: wire.display_order
+  };
+}
+
+// src/http/productPage.ts
+var PUBLIC9 = { business: "required", anonymous: true };
+var MERCHANT6 = { merchant: true, business: "required", anonymous: true };
+function targetFields(target) {
+  if (target === void 0) return {};
+  if (target === "all") return { selected_variants: [], variant: null };
+  if ("variantId" in target) return { variant: target.variantId };
+  return { selected_variants: target.variantIds, variant: null };
+}
+function createProductPageApi(request) {
+  const sentItem = (wire, target) => {
+    const item = toProductSectionItem(wire);
+    if (wire.sku != null && typeof target === "object" && "variantIds" in target) {
+      item.target = { skuId: wire.sku, variantIds: [...target.variantIds] };
+    }
+    return item;
+  };
+  return {
+    async sections(productId) {
+      const wire = await request(
+        "GET",
+        `/product/detail/list/${productId}`,
+        PUBLIC9
+      );
+      return wire.map(toProductSection);
+    },
+    async blocks(productId, options = {}) {
+      const wire = await request("GET", `/product/content/list/${productId}`, {
+        ...PUBLIC9,
+        query: { slug: options.slug }
+      });
+      return wire.map(toProductBlock);
+    },
+    async createSection({ productId, title }) {
+      return toProductSection(
+        await request("POST", "/product/detail/create", {
+          ...MERCHANT6,
+          json: { product: productId, title }
+        })
+      );
+    },
+    async deleteSection(id) {
+      await request("DELETE", `/product/detail/delete/${id}`, MERCHANT6);
+    },
+    async addSectionItem({ sectionId, data, target }) {
+      const wire = await request("POST", "/product/detail/content/create", {
+        ...MERCHANT6,
+        json: { product_detail: sectionId, data, ...targetFields(target) }
+      });
+      return sentItem(wire, target);
+    },
+    async updateSectionItem(id, { sectionId, data, target }) {
+      const wire = await request(
+        "PATCH",
+        `/product/detail/content/update/${id}`,
+        {
+          ...MERCHANT6,
+          json: {
+            product_detail: sectionId,
+            ...data === void 0 ? {} : { data },
+            ...targetFields(target)
+          }
+        }
+      );
+      return sentItem(wire, target);
+    },
+    async moveSectionItem(id, direction) {
+      await request("PATCH", `/product/detail/content/update/${id}`, {
+        ...MERCHANT6,
+        json: { direction }
+      });
+    },
+    async deleteSectionItem(id) {
+      await request("DELETE", `/product/detail/content/delete/${id}`, MERCHANT6);
+    },
+    async createBlock({ productId, slug, data }) {
+      return toProductBlock(
+        await request("POST", "/product/content/create", {
+          ...MERCHANT6,
+          json: { product: productId, slug, data }
+        })
+      );
+    },
+    async updateBlock(id, { slug, data }) {
+      return toProductBlock(
+        await request("PATCH", `/product/content/update/${id}`, {
+          ...MERCHANT6,
+          json: { slug, data }
+        })
+      );
+    },
+    async deleteBlock(id) {
+      await request("DELETE", `/product/content/delete/${id}`, MERCHANT6);
+    }
+  };
+}
+function toTarget(wire) {
+  if (wire.sku != null) {
+    const variants = wire.selected_variants ?? [];
+    return { skuId: wire.sku, variantIds: variants.length ? variants.map((v) => v.id) : null };
+  }
+  if (wire.variant != null) return { variantId: wire.variant };
+  return "all";
+}
+function toProductSectionItem(wire) {
+  return {
+    id: wire.id,
+    sectionId: wire.product_detail,
+    data: wire.data ?? null,
+    order: wire.display_order,
+    target: toTarget(wire)
+  };
+}
+function toProductSection(wire) {
+  return {
+    id: wire.id,
+    productId: wire.product,
+    title: wire.title,
+    // Already ordered by the backend; sorted again so the order never depends on it.
+    items: [...wire.content].sort((a, b) => a.display_order - b.display_order).map(toProductSectionItem)
+  };
+}
+function toProductBlock(wire) {
+  return {
+    id: wire.id,
+    productId: wire.product,
+    slug: wire.slug,
+    data: wire.data ?? null,
+    order: wire.display_order
+  };
+}
+
+// src/http/products.ts
+var DEFAULT_LIMIT = 20;
+var SORT = {
+  "price-low-to-high": "low_to_high",
+  "price-high-to-low": "high_to_low",
+  newest: "newest_first",
+  popularity: "popularity",
+  category: "category"
+};
+var PUBLIC10 = { business: "required", anonymous: true };
+function createProductsApi(request) {
+  return {
+    async search(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT;
+      const offset = options.offset ?? 0;
+      const page = await request(
+        "GET",
+        "/product/sku/list/search",
+        {
+          ...PUBLIC10,
+          session: "required",
+          query: {
+            status: "available",
+            search: options.search?.trim(),
+            category_ids: options.categoryIds,
+            brand_ids: options.brandIds,
+            variants: options.variantLabels,
+            specifications: options.specifications?.length ? JSON.stringify(options.specifications) : void 0,
+            min_price: options.minPrice,
+            max_price: options.maxPrice,
+            min_discount: options.minDiscountPercent,
+            min_rating: options.minRating,
+            sort_by: options.sortBy ? SORT[options.sortBy] : void 0,
+            limit,
+            offset
+          }
+        }
+      );
+      return { items: page.results.map(toProductListItem), total: page.count, offset, limit };
+    },
+    async list(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT;
+      const offset = options.offset ?? 0;
+      const page = await request("GET", "/product/base/list", {
+        ...PUBLIC10,
+        // The backend does not hide drafts here by itself; the old storefront never asked it to.
+        query: {
+          status: "available",
+          ids: options.ids,
+          category_ids: options.categoryIds,
+          limit,
+          offset
+        }
+      });
+      return { items: page.results.map(toProductOverview), total: page.count, offset, limit };
+    },
+    async detail(id) {
+      return toProductDetail(
+        await request("GET", `/product/details/${id}`, PUBLIC10)
+      );
+    },
+    async filterConfig(options = {}) {
+      const wire = await request("GET", "/product/filter/config", {
+        ...PUBLIC10,
+        query: { category: options.categoryId }
+      });
+      return {
+        price: { min: wire.price.min, max: wire.price.max },
+        specifications: wire.specifications.map((s) => ({
+          id: s.id,
+          name: s.name,
+          type: s.data_type,
+          options: s.options
+        }))
+      };
+    },
+    async variantFilters(categoryIds) {
+      if (categoryIds.length === 0) return [];
+      const wire = await request("GET", "/product/category/filter/variant", {
+        ...PUBLIC10,
+        query: { category_ids: categoryIds }
+      });
+      return wire.map(toVariantGroup);
+    },
+    async suggestions(query) {
+      const word = query.trim();
+      if (!word) return [];
+      const wire = await request(
+        "GET",
+        `/product/search/${encodeURIComponent(word)}`,
+        PUBLIC10
+      );
+      return wire.map(
+        (s) => s.type === "product" ? {
+          type: "product",
+          id: s.id,
+          name: s.name,
+          categoryName: text(s.category),
+          image: text(s.image)
+        } : { type: "category", id: s.id, name: s.name }
+      );
+    }
+  };
+}
+var mrpOf = (value) => {
+  const n = amount(value);
+  return n && n > 0 ? n : null;
+};
+function toVariantGroup(wire) {
+  return {
+    id: wire.variant_type.id,
+    name: wire.variant_type.type,
+    options: wire.variants.filter((v) => !v.deleted).map((v) => ({ id: v.id, label: v.label, available: v.sku_available ?? true }))
+  };
+}
+function toSku(wire) {
+  return {
+    id: wire.id,
+    code: wire.sku,
+    slug: wire.url_slug,
+    price: amount(wire.selling_price) ?? 0,
+    mrp: mrpOf(wire.mrp),
+    stockQty: wire.stock_qty ?? 0,
+    active: wire.is_active !== false,
+    variantIds: wire.selected_variants ?? []
+  };
+}
+function toImage(wire) {
+  return {
+    id: wire.id,
+    url: wire.photo,
+    originalUrl: text(wire.original_photo),
+    variantId: wire.variant ?? null,
+    order: wire.display_order
+  };
+}
+var liveSkus = (skus) => skus.filter((s) => !s.deleted && !s.invalid);
+var liveImages = (images) => images.filter((i) => !i.deleted).sort((a, b) => a.display_order - b.display_order);
+function toProductListItem(wire) {
+  const tax = amount(wire.tax);
+  return {
+    skuId: wire.id,
+    productId: wire.product,
+    name: wire.name,
+    slug: wire.url_slug,
+    skuCode: wire.sku,
+    photos: wire.photo,
+    price: amount(wire.selling_price) ?? 0,
+    mrp: mrpOf(wire.mrp),
+    stockQty: wire.stock_qty ?? 0,
+    taxPercent: tax,
+    unit: text(wire.unit),
+    variantGroups: (wire.variant ?? []).map(toVariantGroup),
+    selectedVariantIds: wire.selected_variants,
+    fulfillmentMode: wire.fulfillment_mode,
+    hasDigitalDelivery: wire.has_digital_delivery,
+    advanceAmount: amount(wire.advance_amount)
+  };
+}
+function toSpecifications(wire) {
+  return Object.entries(wire ?? {}).map(([name, items]) => ({
+    name: text(name),
+    items: items.filter((i) => !i.deleted && i.key).map((i) => ({
+      key: i.key.name,
+      value: i.value,
+      appliesTo: i.sku ? { type: "sku", skuId: i.sku.id } : i.variant ? { type: "variant", variantId: i.variant.id } : { type: "all" }
+    }))
+  })).filter((g) => g.items.length > 0);
+}
+function toProductDetail(wire) {
+  const policies = wire.product_policies;
+  return {
+    id: wire.id,
+    name: wire.name,
+    slug: wire.url_slug,
+    description: text(wire.description),
+    descriptionFormat: text(wire.description_editor_type),
+    categoryId: wire.category ?? null,
+    categoryName: text(wire.category_name),
+    brandId: wire.brand ?? null,
+    taxPercent: amount(wire.tax_percent),
+    rating: wire.rating ?? 0,
+    reviewCount: wire.total_review ?? 0,
+    hasVariants: wire.has_variant ?? (wire.variant ?? []).length > 0,
+    images: liveImages(wire.images).map(toImage),
+    variantGroups: (wire.variant ?? []).map(toVariantGroup),
+    skus: liveSkus(wire.sku).map(toSku),
+    specifications: toSpecifications(wire.specification),
+    policies: policies ? {
+      returnDays: policies.return_days,
+      replacementDays: policies.replacement_days,
+      exchangeDays: policies.exchange_days,
+      exchangeEnabled: policies.exchange_enabled,
+      warrantyMonths: policies.warranty_months,
+      guaranteeMonths: policies.guarantee_months
+    } : null,
+    availableForSubscription: wire.available_for_subscription ?? false,
+    hasDigitalDelivery: wire.has_digital_delivery ?? false,
+    fulfillmentMode: wire.fulfillment_mode ?? "none",
+    advanceAmount: amount(wire.advance_amount)
+  };
+}
+function toProductOverview(wire) {
+  return {
+    id: wire.id,
+    name: wire.name,
+    slug: wire.url_slug,
+    categoryName: text(wire.category_name),
+    images: liveImages(wire.images).map(toImage),
+    variantGroups: (wire.variant ?? []).map(toVariantGroup),
+    skus: liveSkus(wire.sku).map(toSku),
+    priceFrom: amount(wire.starting_from),
+    unit: text(wire.unit)
+  };
+}
+
+// src/http/errors.ts
+var GrowupsellApiError = class extends Error {
+  kind;
+  /** HTTP status; undefined when no response arrived (network, timeout). */
+  status;
+  /** Validation messages per field, as returned by the backend (`non_field_errors` included). */
+  fieldErrors;
+  /** The parsed response body, for anything the fields above don't cover. */
+  body;
+  constructor(init) {
+    super(init.message);
+    this.name = "GrowupsellApiError";
+    this.kind = init.kind;
+    this.status = init.status;
+    this.fieldErrors = init.fieldErrors ?? {};
+    this.body = init.body;
+  }
+};
+function messageFromBody(body) {
+  if (typeof body === "string") {
+    const text2 = body.trim();
+    return text2 && !text2.startsWith("<") ? text2 : void 0;
+  }
+  if (Array.isArray(body)) return body.length > 0 ? messageFromBody(body[0]) : void 0;
+  if (body && typeof body === "object") {
+    const record = body;
+    for (const key of ["detail", "message"]) {
+      if (typeof record[key] === "string" && record[key]) return record[key];
+    }
+    for (const value of Object.values(record)) {
+      if (typeof value === "boolean" || typeof value === "number" || value == null) continue;
+      const found = messageFromBody(value);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function fieldErrorsFromBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return {};
+  const errors = {};
+  for (const [field, value] of Object.entries(body)) {
+    if (field === "detail" || field === "message") continue;
+    if (typeof value === "string") errors[field] = [value];
+    else if (Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string")) {
+      errors[field] = value;
+    }
+  }
+  return errors;
+}
+
+// src/http/promotions.ts
+var DEFAULT_LIMIT2 = 20;
+var PUBLIC_BUSINESS = { anonymous: true, business: "required" };
+var SHOPPER2 = { business: "required", customerOrSession: "required" };
+function createPromotionsApi(request) {
+  return {
+    async offers(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT2;
+      const offset = options.offset ?? 0;
+      const page = await request("GET", "/offer/list", {
+        ...PUBLIC_BUSINESS,
+        query: { limit, offset }
+      });
+      return { items: page.results.map(toOffer), total: page.count, offset, limit };
+    },
+    async eligibleOffers() {
+      const wire = await request("GET", "/offer/eligibility/list", SHOPPER2);
+      return wire.map(toOffer);
+    },
+    async promoCode(code) {
+      const normalized = code.trim().toUpperCase();
+      if (!normalized) return null;
+      try {
+        const wire = await request("GET", "/promocode/get", {
+          ...SHOPPER2,
+          query: { code: normalized }
+        });
+        return toPromoCode(wire);
+      } catch (error) {
+        if (isNotFoundJson(error)) return null;
+        throw error;
+      }
+    },
+    async validateGiftCard({ code, pin }) {
+      const wire = await request("POST", "/giftcard/validate", {
+        business: "required",
+        json: { code: code.trim(), pin: pin.trim() }
+      });
+      return toGiftCard(wire);
+    },
+    async rewardPointSettings() {
+      return toRewardPointSettings(
+        await request(
+          "GET",
+          "/reward_points/business/setting/get",
+          PUBLIC_BUSINESS
+        )
+      );
+    }
+  };
+}
+function isNotFoundJson(error) {
+  return error instanceof GrowupsellApiError && error.status === 404 && typeof error.body === "object" && error.body !== null;
+}
+function toOffer(wire) {
+  return {
+    id: wire.id,
+    name: wire.name,
+    description: text(wire.description),
+    image: text(wire.image),
+    type: wire.type ?? "percentage",
+    percentOff: amount(wire.percentage_of) ?? 0,
+    amountOff: amount(wire.discount_upto_price) ?? 0,
+    minOrderAmount: amount(wire.min_order_amount) ?? 0,
+    startsAt: wire.start_date ?? "",
+    endsAt: wire.end_date ?? "",
+    couponCode: text(wire.coupon_code),
+    scope: wire.only_for ?? "order",
+    isActive: wire.is_active ?? false
+  };
+}
+function toPromoCode(wire) {
+  return {
+    id: wire.id,
+    code: wire.code ?? "",
+    description: text(wire.description),
+    type: wire.type ?? "percentage",
+    value: amount(wire.value) ?? 0,
+    expiresAt: wire.expire_date,
+    status: wire.status
+  };
+}
+function toGiftCard(wire) {
+  return {
+    id: wire.id,
+    code: wire.code,
+    amount: amount(wire.amount) ?? 0,
+    usedAmount: amount(wire.used_amount) ?? 0,
+    issuedAt: wire.created_at
+  };
+}
+function toRewardPointSettings(wire) {
+  return {
+    // Points work on orders only when both switches are on.
+    enabled: !!wire.is_active && !!wire.is_active_order_reward,
+    pointsPerCurrencyUnit: amount(wire.order_credit_multiplier) ?? 0,
+    currencyPerPoint: amount(wire.order_debit_multiplier) ?? 0,
+    signupPoints: amount(wire.signup_points) ?? 0
+  };
+}
+
+// src/http/multipart.ts
+var runtime = globalThis;
+function multipart(fields, files, caller = "This upload") {
+  if (!runtime.FormData) {
+    throw new Error(`${caller}: sending a file needs FormData, which this runtime lacks.`);
+  }
+  const form = new runtime.FormData();
+  for (const [name, value] of Object.entries(fields)) {
+    if (value !== void 0) form.append(name, String(value));
+  }
+  for (const [name, entry] of Object.entries(files)) {
+    if (!entry) continue;
+    if (entry.fileName === void 0) form.append(name, entry.file);
+    else form.append(name, entry.file, entry.fileName);
+  }
+  return form;
+}
+
+// src/http/reviews.ts
+var DEFAULT_LIMIT3 = 20;
+var PUBLIC11 = { anonymous: true };
+var PUBLIC_BUSINESS2 = { anonymous: true, business: "required" };
+var CUSTOMER = { customer: "required" };
+function createReviewsApi(request) {
+  function body(fields, photo) {
+    if (photo === void 0) {
+      return {
+        json: Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== void 0))
+      };
+    }
+    return { formData: multipart(fields, { photo: { file: photo } }, "Review photo") };
+  }
+  return {
+    async forProduct(productId) {
+      const wire = await request(
+        "GET",
+        `/product/review/list/${productId}`,
+        PUBLIC11
+      );
+      return wire.map(toReviewListItem);
+    },
+    async latest(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT3;
+      const offset = options.offset ?? 0;
+      const page = await request("GET", "/product/review/list", {
+        ...PUBLIC_BUSINESS2,
+        query: {
+          rating_gt: options.minRating,
+          search: options.search?.trim() || void 0,
+          limit,
+          offset
+        }
+      });
+      return { items: page.results.map(toReviewListItem), total: page.count, offset, limit };
+    },
+    async summary(productId) {
+      return toReviewSummary(
+        await request(
+          "GET",
+          `/product/review/conclusion/${productId}`,
+          PUBLIC_BUSINESS2
+        )
+      );
+    },
+    async eligibility(productId) {
+      const wire = await request(
+        "GET",
+        `/product/can/i/review/${productId}`,
+        CUSTOMER
+      );
+      return wire.can_i_review ? { canReview: true, orderProductId: wire.order_product } : { canReview: false, orderProductId: null };
+    },
+    async create(input) {
+      const wire = await request("POST", "/product/review/create", {
+        ...CUSTOMER,
+        ...body(
+          {
+            customer: input.customerId,
+            product: input.productId,
+            order_product: input.orderProductId,
+            title: input.title,
+            message: input.message,
+            ratting: input.rating
+          },
+          input.photo
+        )
+      });
+      return toReview(wire);
+    },
+    async update(reviewId, changes) {
+      const wire = await request("PATCH", `/product/review/update/${reviewId}`, {
+        ...CUSTOMER,
+        ...body(
+          { title: changes.title, message: changes.message, ratting: changes.rating },
+          changes.photo
+        )
+      });
+      return toReview(wire);
+    },
+    async remove(reviewId) {
+      await request("DELETE", `/product/review/customer/delete/${reviewId}`, {
+        ...CUSTOMER,
+        business: "required"
+      });
+    }
+  };
+}
+function toReview(wire) {
+  return {
+    id: wire.id,
+    productId: wire.product,
+    customerId: wire.customer,
+    title: wire.title,
+    message: text(wire.message),
+    photo: text(wire.photo),
+    rating: amount(wire.ratting),
+    createdAt: wire.created_at
+  };
+}
+function toReviewListItem(wire) {
+  const reply = wire.reply;
+  return {
+    ...toReview(wire),
+    productName: wire.product_name,
+    customerName: text(wire.customer_name),
+    customerPhoto: text(wire.customer_photo),
+    // The backend also sends the replying staff member's email and phone; not passed on.
+    reply: reply ? {
+      id: reply.id,
+      message: reply.message,
+      authorName: text(reply.user_name),
+      authorPhoto: text(reply.user_photo)
+    } : null
+  };
+}
+function toReviewSummary(wire) {
+  const average = amount(wire.average_rating) ?? 0;
+  return {
+    reviewCount: wire.total_reviews,
+    averageRating: Math.round(average * 10) / 10,
+    starCounts: {
+      1: wire.total_one_star_reviews,
+      2: wire.total_two_star_reviews,
+      3: wire.total_three_star_reviews,
+      4: wire.total_four_star_reviews,
+      5: wire.total_five_star_reviews
+    }
+  };
+}
+
+// src/http/wishlist.ts
+var CUSTOMER2 = { customer: "required" };
+function createWishlistApi(request) {
+  return {
+    async list() {
+      const wire = await request("GET", "/product/wishlist/list/", CUSTOMER2);
+      return wire.map(toWishlistItem);
+    },
+    async add(skuId) {
+      const wire = await request("POST", "/product/wishlist/create", {
+        ...CUSTOMER2,
+        json: { sku: skuId }
+      });
+      return { id: wire.id, productId: wire.product };
+    },
+    async remove(wishlistId) {
+      await request("DELETE", `/product/wishlist/delete/${wishlistId}`, CUSTOMER2);
+    }
+  };
+}
+function toWishlistItem(wire) {
+  const { product, sku } = wire;
+  const mrp = sku ? amount(sku.mrp) : null;
+  return {
+    id: wire.id,
+    name: wire.label,
+    photo: text(wire.photo),
+    productId: product.id,
+    productSlug: product.url_slug,
+    sku: sku ? {
+      id: sku.id,
+      code: sku.sku,
+      slug: sku.url_slug,
+      price: amount(sku.selling_price) ?? 0,
+      // An MRP of 0 means "not set".
+      mrp: mrp && mrp > 0 ? mrp : null,
+      stockQty: sku.stock_qty,
+      // As in products: only an explicit `false` deactivates a SKU.
+      active: sku.is_active !== false,
+      variantIds: sku.selected_variants
+    } : null,
+    // The backend lists entries whose product or SKU is gone or hidden. Same rule as the
+    // storefront listing (ProductSKUSearchView with a guest session).
+    available: !!sku && !sku.deleted && !sku.invalid && product.is_active && !product.is_draft && !product.deleted && product.available_on.includes("website"),
+    fulfillmentMode: text(wire.fulfillment_mode) ?? "none",
+    advanceAmount: amount(wire.advance_amount),
+    hasDigitalDelivery: wire.has_digital_delivery
+  };
+}
+
+// src/http/theme-content.ts
+var USAGES = {
+  banner: "banner",
+  slider: "slider",
+  header_logo: "header-logo",
+  footer_logo: "footer-logo",
+  other: "other"
+};
+var WIRE_USAGES = Object.fromEntries(
+  Object.entries(USAGES).map(([wire, usage]) => [usage, wire])
+);
+var PUBLIC12 = { business: "required", anonymous: true };
+var MERCHANT7 = { business: "required", merchant: true, anonymous: true };
+function createThemeContentApi(request) {
+  async function getMany(themeId2, slugs) {
+    const keys = slugs.map(listSlug);
+    if (keys.length === 0) return [];
+    const wire = await request("GET", `/content/get/${themeId2}/v2`, {
+      ...PUBLIC12,
+      query: { slug: [...new Set(keys)] }
+    });
+    if (!Array.isArray(wire)) {
+      throw new GrowupsellApiError({
+        kind: "parse",
+        message: "Expected a list of theme content sections.",
+        body: wire
+      });
+    }
+    const bySlug = new Map(wire.flatMap((row) => row ? [[row.slug, toThemeContent(row)]] : []));
+    return keys.map((key) => bySlug.get(key) ?? null);
+  }
+  return {
+    // The return types are proven by the tests; the implementation works on plain lists.
+    getMany,
+    async get(themeId2, slug) {
+      if (slug === "v2") return (await getMany(themeId2, [slug]))[0];
+      const wire = await request(
+        "GET",
+        `/content/get/${themeId2}/${segment(slug)}`,
+        PUBLIC12
+      );
+      return toThemeContent(wire);
+    },
+    async update(themeId2, slug, content) {
+      const json = { slug, platform: content.platform, data: content.data };
+      const wire = await request(
+        "PUT",
+        `/content/update/${themeId2}/${segment(slug)}`,
+        { ...MERCHANT7, json }
+      );
+      return toThemeContent(wire);
+    },
+    async uploadImage(upload) {
+      if (upload.file == null) throw new Error("themeContent.uploadImage needs a file.");
+      upload.form.append("image", upload.file, upload.fileName);
+      if (upload.usage) upload.form.append("related", WIRE_USAGES[upload.usage]);
+      const wire = await request("POST", "/content/images/create", {
+        ...MERCHANT7,
+        formData: upload.form
+      });
+      return toContentImage(wire);
+    }
+  };
+}
+function segment(slug) {
+  if (slug.trim() === "") throw new Error("themeContent: slug is required.");
+  return encodeURIComponent(slug);
+}
+function listSlug(slug) {
+  const trimmed = slug.trim();
+  if (trimmed === "") throw new Error("themeContent: slug is required.");
+  if (trimmed.includes(",")) throw new Error(`themeContent: slug "${slug}" contains a comma.`);
+  return trimmed;
+}
+function toThemeContent(wire) {
+  if (!("id" in wire)) return null;
+  return {
+    id: wire.id,
+    themeId: wire.theme,
+    slug: wire.slug,
+    platform: wire.platform,
+    data: wire.data
+  };
+}
+function toContentImage(wire) {
+  if (!wire.image) {
+    throw new GrowupsellApiError({
+      kind: "parse",
+      message: "The upload was accepted but no file was stored.",
+      body: wire
+    });
+  }
+  return {
+    id: wire.id,
+    url: wire.image,
+    usage: wire.related ? USAGES[wire.related] ?? null : null
+  };
+}
+
+// src/http/customPages.ts
+var PUBLIC13 = { business: "required", anonymous: true };
+var MERCHANT8 = { merchant: true, anonymous: true };
+var HERO_BLOCK_SLUG = "__hero_slider";
+function createCustomPagesApi(request) {
+  return {
+    async byPath(path3) {
+      const urlPath = normalizePath(path3);
+      try {
+        const wire = await request("GET", "/website/custom-page/public", {
+          ...PUBLIC13,
+          query: { url_path: urlPath }
+        });
+        return toCustomPage(wire);
+      } catch (error) {
+        if (error instanceof GrowupsellApiError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    async content(pageId) {
+      const wire = await request(
+        "GET",
+        contentPath(pageId, "content"),
+        MERCHANT8
+      );
+      return toCustomPageContent(wire);
+    },
+    async updateContent(pageId, input) {
+      const path3 = contentPath(pageId, "updateContent");
+      const json = toContentWrite(input);
+      const wire = await request("PATCH", path3, { ...MERCHANT8, json });
+      return toCustomPageContent(wire);
+    }
+  };
+}
+function normalizePath(path3) {
+  const segments = path3.trim().replace(/\\/g, "/").split("/");
+  const normalized = segments.filter((s) => s.trim() !== "").join("/");
+  if (!normalized) throw new Error("customPages.byPath: path is required.");
+  return normalized;
+}
+function contentPath(pageId, method) {
+  if (!Number.isInteger(pageId) || pageId <= 0) {
+    throw new Error(`customPages.${method}: page id must be a positive integer.`);
+  }
+  return `/website/custom-page/${pageId}/content`;
+}
+function toHero(raw) {
+  if (Array.isArray(raw)) return raw.length > 0 ? { type: "slider", data: raw } : null;
+  if (!isObject(raw)) return null;
+  const { type, data } = raw;
+  return typeof type === "string" && type !== "" ? { type, data } : null;
+}
+function toDocument(heroContent, blocks) {
+  const objects = (blocks ?? []).filter(isObject);
+  const hero = heroContent != null ? toHero(heroContent) : toHero(objects.find((b) => b.slug === HERO_BLOCK_SLUG)?.content);
+  return { hero, sections: objects.filter((b) => b.slug !== HERO_BLOCK_SLUG) };
+}
+function toCustomPage(wire) {
+  return {
+    id: wire.id,
+    title: wire.title,
+    path: wire.url_path,
+    seoTitle: text(wire.seo_title),
+    seoDescription: text(wire.seo_description),
+    seoKeywords: (wire.seo_keywords ?? []).flatMap(
+      (k) => typeof k === "string" && k.trim() !== "" ? [k.trim()] : []
+    ),
+    ...toDocument(wire.hero_content, wire.contents)
+  };
+}
+function toCustomPageContent(wire) {
+  return {
+    id: wire.id,
+    pageId: wire.page,
+    ...toDocument(wire.hero_content, wire.content),
+    createdAt: wire.created_at,
+    updatedAt: wire.updated_at
+  };
+}
+function toContentWrite(input) {
+  const { hero } = input;
+  if (hero && hero.type.trim() === "") {
+    throw new Error("customPages.updateContent: the hero type is required.");
+  }
+  return {
+    content: input.sections.filter((s) => isObject(s) && s.slug !== HERO_BLOCK_SLUG),
+    hero_content: hero ? { type: hero.type, data: hero.data } : null
+  };
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/http/session.ts
+function createSessionApi(request) {
+  return {
+    async create() {
+      const wire = await request("POST", "/session/create", {
+        anonymous: true,
+        session: "omit",
+        json: {}
+      });
+      return toGuestSession(wire);
+    }
+  };
+}
+function toGuestSession(wire) {
+  return { id: wire.id, token: wire.session_token };
+}
+
+// src/http/lookup.ts
+var PUBLIC14 = { anonymous: true };
+function createLookupApi(request) {
+  return {
+    async countries(search) {
+      const wire = await request("GET", "/lookup/country/list", {
+        ...PUBLIC14,
+        query: { search }
+      });
+      return wire.data.map(toCountry);
+    },
+    async states(countryCode) {
+      const wire = await request("GET", "/lookup/country/state/list", {
+        ...PUBLIC14,
+        query: { country: countryCode }
+      });
+      return wire.map(toCountryState);
+    }
+  };
+}
+function toCountry(wire) {
+  return { code: wire.code, name: wire.name };
+}
+function toCountryState(wire) {
+  return {
+    id: wire.id,
+    name: wire.name,
+    shortName: wire.short_name,
+    code: wire.code,
+    country: wire.country
+  };
+}
+
+// src/http/auth.ts
+var SIGNED_OUT = { anonymous: true };
+var BUSINESS = { ...SIGNED_OUT, business: "required" };
+function createAuthApi(request) {
+  return {
+    async settings() {
+      const wire = await request("GET", "/customer/setting/get", BUSINESS);
+      return toSettings(wire);
+    },
+    async login({ username, password }) {
+      const wire = await request("POST", "/customer/login", {
+        ...BUSINESS,
+        session: "required",
+        json: { username, password }
+      });
+      return toAuthResult(wire, username);
+    },
+    async verifyOtp({ customerId, otp }) {
+      const wire = await request("POST", "/customer/otp/verify", {
+        ...SIGNED_OUT,
+        json: { otp, customer: customerId }
+      });
+      return toSignedIn(wire, wire.token);
+    },
+    async register(input) {
+      const wire = await request(
+        "POST",
+        "/customer/register",
+        { ...BUSINESS, session: "required", json: fromRegisterInput(input) }
+      );
+      return toAuthResult(wire);
+    },
+    async sendOtp(username) {
+      const { message } = await request("POST", "/customer/otp/resend", {
+        ...BUSINESS,
+        json: { username }
+      });
+      return { message };
+    },
+    async resetPassword({ username, otp, newPassword, confirmPassword }) {
+      const { message } = await request("POST", "/customer/password/reset", {
+        ...BUSINESS,
+        json: { username, otp, new_password: newPassword, confirm_password: confirmPassword }
+      });
+      return { message };
+    }
+  };
+}
+function fromRegisterInput(input) {
+  return {
+    ...input.email !== void 0 && { email: input.email },
+    ...input.phone !== void 0 && { phone: input.phone },
+    password: input.password,
+    type: input.type,
+    first_name: input.firstName ?? null,
+    last_name: input.lastName ?? null,
+    business_name: input.businessName ?? null,
+    tax_number: input.taxNumber ?? null,
+    ...input.referralCode && { referral_code: input.referralCode }
+  };
+}
+function toSettings(wire) {
+  return {
+    authType: wire.authentication_type ?? "email",
+    allowBusinessSignup: wire.allow_business_signup ?? false,
+    requireVerification: wire.require_customer_verification ?? true,
+    lastNameRequired: wire.is_last_name_required ?? false
+  };
+}
+function toCustomerProfile(wire) {
+  const photo = text(wire.photo);
+  return {
+    id: wire.id,
+    type: wire.type ?? "individual",
+    firstName: text(wire.first_name),
+    lastName: text(wire.last_name),
+    email: text(wire.email),
+    // Sign-up without verification sends `str(None)` for a missing phone.
+    phone: wire.phone === "None" ? null : text(wire.phone),
+    businessName: text(wire.business_name),
+    taxNumber: text(wire.tax_number),
+    // The login dump sends the storage path, not a URL; only a URL is usable.
+    photo: photo && /^https?:\/\//.test(photo) ? photo : null,
+    isActive: wire.is_active ?? false,
+    emailVerified: wire.email_verified ?? false,
+    phoneVerified: wire.phone_verified ?? false
+  };
+}
+function toAuthResult(wire, username) {
+  if (wire.is_active && typeof wire.token === "string") {
+    return { status: "signed-in", session: toSignedIn(wire, wire.token) };
+  }
+  const profile = toCustomerProfile(wire);
+  return {
+    status: "verification-required",
+    customerId: wire.id,
+    contact: username ?? profile.phone ?? profile.email
+  };
+}
+function toSignedIn(wire, token) {
+  return {
+    customer: toCustomerProfile(wire),
+    token,
+    rewardPoints: wire.reward_points ?? null
+  };
+}
+
+// src/http/customer.ts
+var CUSTOMER3 = { customer: "required" };
+var CUSTOMER_BUSINESS = { ...CUSTOMER3, business: "required" };
+function createCustomerApi(request) {
+  return {
+    async updateProfile(id, input) {
+      const wire = await request("PATCH", `/customer/update/${id}`, {
+        ...CUSTOMER_BUSINESS,
+        json: fromProfileInput(input)
+      });
+      return toCustomerProfile(wire);
+    },
+    async changePassword({ oldPassword, newPassword, confirmPassword }) {
+      const { message } = await request("PUT", "/customer/password/update", {
+        ...CUSTOMER3,
+        json: {
+          old_password: oldPassword,
+          new_password: newPassword,
+          confirm_password: confirmPassword
+        }
+      });
+      return { message };
+    },
+    async requestEmailChange(email) {
+      await request("POST", "/customer/email/change/request", {
+        ...CUSTOMER_BUSINESS,
+        json: { email }
+      });
+    },
+    async confirmEmailChange({ email, otp }) {
+      const wire = await request("PUT", "/customer/email/change/verify", {
+        ...CUSTOMER3,
+        json: { email, otp }
+      });
+      return { message: wire.message, newEmail: wire.new_email };
+    },
+    async requestPhoneChange(phone) {
+      await request("POST", "/customer/phone/change/request", {
+        ...CUSTOMER_BUSINESS,
+        json: { phone }
+      });
+    },
+    async confirmPhoneChange({ phone, otp }) {
+      const wire = await request("PUT", "/customer/phone/change/verify", {
+        ...CUSTOMER3,
+        json: { phone, otp }
+      });
+      return { message: wire.message, newPhone: wire.new_phone };
+    }
+  };
+}
+function fromProfileInput(input) {
+  const body = {};
+  if (input.firstName !== void 0) body.first_name = input.firstName;
+  if (input.lastName !== void 0) body.last_name = input.lastName;
+  if (input.businessName !== void 0) body.business_name = input.businessName;
+  if (input.taxNumber !== void 0) body.tax_number = input.taxNumber;
+  return body;
+}
+
+// src/http/addresses.ts
+var CUSTOMER4 = { customer: "required" };
+function createAddressesApi(request) {
+  return {
+    async list() {
+      const wire = await request("GET", "/customer/address/list", CUSTOMER4);
+      return wire.map(toAddress);
+    },
+    async create(input) {
+      const wire = await request("POST", "/customer/address/create", {
+        ...CUSTOMER4,
+        json: fromAddressInput(input)
+      });
+      return toAddress(wire);
+    },
+    async update(id, input) {
+      const wire = await request("PUT", `/customer/address/update/${id}`, {
+        ...CUSTOMER4,
+        json: fromAddressInput(input)
+      });
+      return toAddress(wire);
+    },
+    async remove(id) {
+      await request("DELETE", `/customer/address/delete/${id}`, {
+        ...CUSTOMER4,
+        business: "required"
+      });
+    }
+  };
+}
+function toAddress(wire) {
+  return {
+    id: wire.id,
+    addressLine1: wire.address_line_1,
+    addressLine2: wire.address_line_2,
+    postalCode: text(wire.postal_code),
+    city: wire.city,
+    type: wire.type,
+    country: text(wire.country),
+    state: wire.state ?? null,
+    stateName: text(wire.state_name),
+    landmark: wire.landmark,
+    contactNo: text(wire.contact_no),
+    latitude: amount(wire.latitude),
+    longitude: amount(wire.longitude),
+    isDefault: wire.default ?? false,
+    isUsed: wire.is_used
+  };
+}
+function fromAddressInput(input) {
+  return {
+    address_line_1: input.addressLine1,
+    address_line_2: input.addressLine2,
+    postal_code: input.postalCode ?? "",
+    city: input.city,
+    type: input.type,
+    country: input.country ?? null,
+    state: input.state ?? null,
+    landmark: input.landmark,
+    contact_no: input.contactNo ?? null,
+    latitude: input.latitude ?? null,
+    longitude: input.longitude ?? null,
+    default: input.isDefault ?? false
+  };
+}
+
+// src/http/checkout.ts
+var PUBLIC_BUSINESS3 = { anonymous: true, business: "required" };
+var CUSTOMER_BUSINESS2 = { business: "required", customer: "required" };
+var PLACE_ORDER_TIMEOUT_MS = 6e4;
+function createCheckoutApi(request) {
+  const placing = /* @__PURE__ */ new Map();
+  async function charge(cartId, options) {
+    const body = {
+      giftcard: [...options.giftCardIds ?? []],
+      use_reward_points: options.useRewardPoints ?? false
+    };
+    const wire = await request("POST", `/order/charge/delivery/${cartId}`, {
+      ...CUSTOMER_BUSINESS2,
+      timeoutMs: PLACE_ORDER_TIMEOUT_MS,
+      json: body
+    });
+    if (wire.action === "done" || wire.payment.type === "cod") {
+      return { status: "placed", orderId: cartId };
+    }
+    return { status: "payment-required", orderId: cartId, payment: toPendingPayment(wire.payment) };
+  }
+  return {
+    async settings() {
+      return toCheckoutSettings(
+        await request(
+          "GET",
+          "/order/business/setting/get",
+          PUBLIC_BUSINESS3
+        )
+      );
+    },
+    placeOrder(cartId, options = {}) {
+      const inFlight = placing.get(cartId);
+      if (inFlight) return inFlight;
+      if ((options.giftCardIds?.length ?? 0) > 0 && options.useRewardPoints) {
+        return Promise.reject(
+          new Error(
+            "placeOrder: gift cards and reward points cannot be combined; choose one (backend issue W36)."
+          )
+        );
+      }
+      const promise = charge(cartId, options).finally(() => placing.delete(cartId));
+      placing.set(cartId, promise);
+      return promise;
+    },
+    async createAdvanceOrder(input) {
+      const body = {
+        product: input.productId,
+        sku: input.skuId,
+        custom_data: input.customData,
+        qty: 1,
+        type: input.type,
+        shipping_address: input.shippingAddressId,
+        billing_address: input.billingAddressId
+      };
+      const wire = await request(
+        "POST",
+        "/order/custom-advance/create",
+        { ...CUSTOMER_BUSINESS2, timeoutMs: PLACE_ORDER_TIMEOUT_MS, json: body }
+      );
+      return { orderId: wire.order_id, payment: toPendingPayment(wire.payment) };
+    }
+  };
+}
+function toCheckoutSettings(wire) {
+  return {
+    allowCashOnDelivery: wire.allow_cash_on_delivery ?? false,
+    allowCancellation: wire.allow_cancellation_from_customer ?? false,
+    autoAccept: wire.auto_accept ?? false,
+    onlineOrdersEnabled: wire.enable_online_order ?? false,
+    deliveryChargeEnabled: wire.delivery_charge ?? false,
+    maxQuantityIndividual: wire.max_allowed_qty_for_individual ?? 0,
+    maxQuantityBusiness: wire.max_allowed_qty_for_business ?? 0
+  };
+}
+function toPendingPayment(wire) {
+  const method = wire.payment_method?.type ?? null;
+  return {
+    id: wire.id,
+    amount: amount(wire.amount) ?? 0,
+    method,
+    publicKey: text(wire.payment_method?.payment_key),
+    providerOrderId: text(wire.payment_order_key),
+    // `payment_key` means something else for every provider; only Stripe's is a client secret.
+    clientSecret: method === "stripe" ? text(wire.payment_key) : null,
+    // Razorpay and Stripe rows carry links too, to pages the SDK flows do not use.
+    redirectUrl: method === "phonepe" ? text(wire.payment_url) : null
+  };
+}
+
+// src/http/payments.ts
+var PUBLIC_BUSINESS4 = { anonymous: true, business: "required" };
+var CUSTOMER_BUSINESS3 = { customer: "required", business: "required" };
+var STRIPE_VERIFICATION_FAILED = "Payment verification failed";
+function createPaymentsApi(request) {
+  const inFlight = /* @__PURE__ */ new Map();
+  function once(key, run) {
+    const existing = inFlight.get(key);
+    if (existing) return existing;
+    const promise = run().finally(() => inFlight.delete(key));
+    inFlight.set(key, promise);
+    return promise;
+  }
+  return {
+    confirmPhonePe(paymentId) {
+      return once(`phonepe:${paymentId}`, async () => {
+        const wire = await request(
+          "GET",
+          `/payment/phonepe/order/web/success/${paymentId}`,
+          PUBLIC_BUSINESS4
+        );
+        return { status: wire.payment_status === "paid" ? "paid" : "unpaid" };
+      });
+    },
+    confirmStripe(payment) {
+      const intentId = payment.providerOrderId;
+      if (!intentId) {
+        return Promise.reject(
+          new TypeError("confirmStripe: the payment has no providerOrderId (PaymentIntent id).")
+        );
+      }
+      return once(`stripe:${payment.id}`, async () => {
+        const json = { payment_intent_id: intentId };
+        try {
+          await request(
+            "POST",
+            `/payment/stripe/order/web/success/${payment.id}`,
+            { ...PUBLIC_BUSINESS4, json }
+          );
+          return { status: "paid" };
+        } catch (error) {
+          if (isStripeVerificationFailure(error)) return { status: "unpaid" };
+          throw error;
+        }
+      });
+    },
+    confirmRazorpay(payment, result) {
+      return once(`razorpay:${payment.id}`, async () => {
+        const json = {
+          razorpay_payment_id: result.razorpayPaymentId,
+          razorpay_order_id: result.razorpayOrderId,
+          razorpay_signature: result.razorpaySignature
+        };
+        await request(
+          "POST",
+          `/payment/razorpay/order/web/success/${payment.id}`,
+          { ...PUBLIC_BUSINESS4, json }
+        );
+      });
+    },
+    submitTransferProof(paymentId, screenshot) {
+      return once(`transfer:${paymentId}`, async () => {
+        const formData = multipart(
+          {},
+          { verification_screenshot: { file: screenshot } },
+          "Transfer proof"
+        );
+        await request("PATCH", `/payment/status/update/${paymentId}`, {
+          ...CUSTOMER_BUSINESS3,
+          formData
+        });
+      });
+    }
+  };
+}
+function isStripeVerificationFailure(error) {
+  return error instanceof GrowupsellApiError && error.status === 400 && error.body?.message === STRIPE_VERIFICATION_FAILED;
+}
+
+// src/http/custom-manufacturing.ts
+var CUSTOMER_BUSINESS4 = { customer: "required", business: "required" };
+function createCustomManufacturingApi(request) {
+  return {
+    async uploadFile(file, fileName) {
+      if (file == null) throw new Error("customManufacturing.uploadFile needs a file.");
+      const wire = await request(
+        "POST",
+        "/manufacture/custom-request/customer/upload",
+        {
+          ...CUSTOMER_BUSINESS4,
+          formData: multipart({}, { file: { file, fileName } }, "customManufacturing.uploadFile")
+        }
+      );
+      if (!wire.url)
+        throw new Error("customManufacturing.uploadFile: the backend returned no URL.");
+      return { id: wire.id, url: wire.url };
+    }
+  };
+}
+
+// src/http/subscriptions.ts
+var DEFAULT_LIMIT4 = 20;
+var CUSTOMER5 = { customer: "required", business: "required" };
+function createSubscriptionsApi(request) {
+  return {
+    async list(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT4;
+      const offset = options.offset ?? 0;
+      const page = await request("GET", "/subscription/list", {
+        ...CUSTOMER5,
+        query: { limit, offset }
+      });
+      return { items: page.results.map(toSubscription), total: page.count, offset, limit };
+    },
+    async detail(id) {
+      return toSubscription(
+        await request("GET", `/subscription/detail/${id}`, CUSTOMER5)
+      );
+    },
+    async deliveries(id) {
+      const wire = await request(
+        "GET",
+        `/subscription/delivery/list/${id}`,
+        CUSTOMER5
+      );
+      return wire.map(toSubscriptionDelivery);
+    },
+    async holds(id) {
+      const wire = await request(
+        "GET",
+        `/subscription/hold/history/list/${id}`,
+        CUSTOMER5
+      );
+      return wire.map(toSubscriptionHold);
+    },
+    async invoices(id) {
+      const wire = await request(
+        "GET",
+        `/subscription/invoice/list/${id}`,
+        CUSTOMER5
+      );
+      return wire.map(toSubscriptionInvoice);
+    },
+    async payInvoice(invoiceId) {
+      return toInvoicePayment(
+        await request(
+          "GET",
+          `/subscription/invoice/get/${invoiceId}`,
+          CUSTOMER5
+        )
+      );
+    },
+    async create(input) {
+      const body = toCreateBody(input);
+      return toSubscription(
+        await request("POST", "/subscription/create", {
+          ...CUSTOMER5,
+          json: body
+        })
+      );
+    },
+    hold: (id) => updateStatus(id, { action: "hold" }),
+    resume: (id) => updateStatus(id, { action: "resume" }),
+    async cancel(id, reason) {
+      const trimmed = reason?.trim();
+      if (!trimmed) throw new Error("subscriptions.cancel needs a reason.");
+      return updateStatus(id, { action: "cancel", decline_message: trimmed });
+    }
+  };
+  async function updateStatus(id, body) {
+    return toSubscription(
+      await request("POST", `/subscription/status/update/${id}`, {
+        ...CUSTOMER5,
+        json: body
+      })
+    );
+  }
+}
+var WIRE_INTERVAL = {
+  daily: "daily",
+  "alternate-day": "alternate_day",
+  weekly: "weekly",
+  monthly: "monthly"
+};
+function toCreateBody(input) {
+  const fail = (message) => {
+    throw new Error(`subscriptions.create: ${message}`);
+  };
+  if (!Number.isInteger(input.quantity) || input.quantity < 1) {
+    fail("quantity must be a whole number of at least 1.");
+  }
+  if (input.endDate < input.startDate) fail("endDate is before startDate.");
+  const body = {
+    customer: input.customerId,
+    address: input.addressId,
+    start_date: input.startDate,
+    end_date: input.endDate,
+    interval: WIRE_INTERVAL[input.interval],
+    products: [{ id: input.skuId, quantity: input.quantity, price: input.price }]
+  };
+  if (input.interval === "weekly") {
+    if (!input.weekdays?.length) fail("weekly needs at least one weekday.");
+    body.selected_days = input.weekdays;
+  }
+  if (input.interval === "monthly") {
+    if (!input.monthDay)
+      fail("monthly needs monthDay (an ISO date whose day is the delivery day).");
+    body.month_day = input.monthDay;
+  }
+  return body;
+}
+var STATUS = {
+  created: "created",
+  accepted: "accepted",
+  paid: "paid",
+  "in-progress": "in-progress",
+  hold: "hold",
+  completed: "completed",
+  cancelled: "cancelled",
+  decline: "declined"
+};
+var INTERVAL = {
+  daily: "daily",
+  alternate_day: "alternate-day",
+  weekly: "weekly",
+  monthly: "monthly"
+};
+function weekdays(value) {
+  if (value == null) return [];
+  const names = Array.isArray(value) ? value : value.split(",");
+  return names.map((name) => name.trim()).filter((name) => name !== "");
+}
+function toSubscription(wire) {
+  const address = wire.address;
+  return {
+    id: wire.id,
+    number: text(wire.subscription_no),
+    // The model defaults to `created`; null only for rows written outside the API.
+    status: wire.status ? STATUS[wire.status] : "created",
+    interval: wire.interval ? INTERVAL[wire.interval] : null,
+    startDate: wire.start_date,
+    endDate: wire.end_date,
+    weekdays: weekdays(wire.weekly_days),
+    monthDay: wire.month_day,
+    // The list sends the address id, the detail the address row.
+    addressId: typeof address === "object" ? address?.id ?? null : address ?? null,
+    reason: text(wire.decline_message),
+    createdAt: wire.created_at
+  };
+}
+function toSubscriptionDelivery(wire) {
+  return {
+    id: wire.id,
+    date: wire.date,
+    status: wire.status,
+    items: wire.products.map((p) => ({
+      id: p.id,
+      skuId: p.sku,
+      name: p.product_name,
+      quantity: p.qty,
+      unit: text(p.unit),
+      price: amount(p.price),
+      status: p.status,
+      removed: p.deleted
+    }))
+  };
+}
+function toSubscriptionHold(wire) {
+  return { id: wire.id, startDate: wire.start_date ?? null, endDate: wire.end_date ?? null };
+}
+function toInvoicePayment(wire) {
+  return wire.action === "done" ? { status: "paid" } : { status: "payment-required", payment: toPendingPayment(wire.payment) };
+}
+function toSubscriptionInvoice(wire) {
+  return {
+    id: wire.id,
+    orderId: wire.order,
+    invoiceNumber: text(wire.invoice_number),
+    invoiceDate: wire.invoice_date,
+    dueDate: wire.due_date ?? null,
+    billingPeriod: wire.billing_period,
+    amount: amount(wire.amount),
+    paymentStatus: wire.payment?.status ?? "unpaid"
+  };
+}
+
+// src/http/orders.ts
+var CUSTOMER6 = { business: "required", customer: "required" };
+var DEFAULT_LIMIT5 = 10;
+var TRACKING_TIMEOUT_MS = 3e4;
+var DOCUMENT_TIMEOUT_MS = 6e4;
+function createOrdersApi(request) {
+  function pdf(path3, options = {}) {
+    return request("POST", path3, {
+      ...CUSTOMER6,
+      query: { send_to_customer: false, invoice_type: options.format ?? "a4" },
+      responseType: "binary",
+      timeoutMs: DOCUMENT_TIMEOUT_MS
+    });
+  }
+  async function email(path3, options = {}) {
+    await request("POST", path3, {
+      ...CUSTOMER6,
+      query: { send_to_customer: true, invoice_type: options.format ?? "a4" },
+      timeoutMs: DOCUMENT_TIMEOUT_MS
+    });
+  }
+  return {
+    async list(options = {}) {
+      const limit = options.limit ?? DEFAULT_LIMIT5;
+      const offset = options.offset ?? 0;
+      const wire = await request("GET", "/order/list", {
+        ...CUSTOMER6,
+        query: { limit, offset, status: options.status, search: options.search }
+      });
+      return { items: wire.results.map(toOrderListItem), total: wire.count, offset, limit };
+    },
+    async detail(orderId) {
+      return toOrderDetail(
+        await request("GET", `/order/detail/${orderId}`, CUSTOMER6)
+      );
+    },
+    async summary(orderId) {
+      return toOrderSummary(
+        await request("GET", `/order/ecommerce/detail/${orderId}`, CUSTOMER6)
+      );
+    },
+    async shipments(orderId) {
+      const wire = await request(
+        "GET",
+        `/order/product/delivery/info/list/${orderId}`,
+        CUSTOMER6
+      );
+      return wire.map(toShipment);
+    },
+    async tracking(trackingNumber) {
+      const wire = await request(
+        "GET",
+        `/delivery/order/tracking/info/${encodeURIComponent(trackingNumber)}`,
+        { ...CUSTOMER6, timeoutMs: TRACKING_TIMEOUT_MS }
+      );
+      return { trackingUrl: text(wire.tracking_url), events: wire.data };
+    },
+    invoice: (orderId, options) => pdf(`/order/invoice/pdf/send/${orderId}`, options),
+    emailInvoice: (orderId, options) => email(`/order/invoice/pdf/send/${orderId}`, options),
+    creditNote: (returnId, options) => pdf(`/order/credit/note/pdf/${returnId}`, options),
+    emailCreditNote: (returnId, options) => email(`/order/credit/note/pdf/${returnId}`, options),
+    async cancelCodItems({ orderId, items, reason }) {
+      if (items.length === 0) throw new TypeError("cancelCodItems: items must not be empty.");
+      if (items.some((item) => !(item.quantity >= 1))) {
+        throw new RangeError("cancelCodItems: every quantity must be at least 1.");
+      }
+      if (reason.trim() === "") throw new TypeError("cancelCodItems: reason must not be blank.");
+      await request("POST", "/order/cancel/cod", {
+        ...CUSTOMER6,
+        json: {
+          order: orderId,
+          order_products: items.map((item) => ({ id: item.orderLineId, qty: item.quantity })),
+          status_message: reason
+        }
+      });
+    }
+  };
+}
+var status = (value) => value ?? "created";
+function toOrderListItem(wire) {
+  return {
+    id: wire.id,
+    orderNumber: text(wire.order_no),
+    type: wire.type,
+    status: status(wire.status),
+    payable: amount(wire.final_payable_amount) ?? 0,
+    placedAt: wire.created_at
+  };
+}
+function toOrderLine(wire) {
+  return {
+    id: wire.id,
+    skuId: wire.sku?.id ?? null,
+    productId: wire.sku?.product?.id ?? null,
+    name: wire.label ?? wire.name ?? "",
+    photo: text(wire.photo),
+    unitPrice: amount(wire.price) ?? 0,
+    quantity: wire.qty,
+    lineTotal: amount(wire.total) ?? 0,
+    offerDiscount: amount(wire.offer_redeem_amount) ?? 0,
+    taxPercent: amount(wire.tax),
+    isDigital: wire.is_digital_product,
+    customData: wire.custom_data,
+    canReplace: wire.can_replace,
+    canExchange: wire.can_exchange,
+    maxReplaceOrExchangeQuantity: wire.max_qty_for_replace_or_exchange
+  };
+}
+function toOrderAddress(wire) {
+  return {
+    id: wire.id,
+    line1: text(wire.address_line_1),
+    line2: text(wire.address_line_2),
+    landmark: text(wire.landmark),
+    city: text(wire.city),
+    state: text(wire.state_name),
+    postalCode: text(wire.postal_code),
+    country: text(wire.country),
+    type: text(wire.type)
+  };
+}
+function toOrderPaymentEntry(wire) {
+  return {
+    id: wire.id,
+    type: text(wire.type),
+    amount: amount(wire.amount) ?? 0,
+    status: wire.status,
+    method: wire.payment_method?.type ?? null,
+    label: wire.payment_method_label
+  };
+}
+function toOrderDetail(wire) {
+  const lines = (wire.products ?? []).map(toOrderLine);
+  const orderOffer = amount(wire.offer_redeem_amount) ?? 0;
+  const offerDiscount = orderOffer > 0 ? orderOffer : lines.reduce((sum2, line) => sum2 + line.offerDiscount, 0);
+  return {
+    id: wire.id,
+    orderNumber: text(wire.order_no),
+    invoiceNumber: text(wire.invoice_number),
+    type: wire.type,
+    status: status(wire.status),
+    statusMessage: text(wire.status_message),
+    placedAt: wire.created_at,
+    lines,
+    subtotal: amount(wire.total_amount) ?? 0,
+    offerDiscount,
+    promoDiscount: amount(wire.promo_redeem_amount) ?? 0,
+    deliveryCharge: amount(wire.delivery_charge) ?? 0,
+    payable: amount(wire.final_payable_amount) ?? 0,
+    shippingAddress: wire.shipping_address ? toOrderAddress(wire.shipping_address) : null,
+    billingAddress: wire.billing_address ? toOrderAddress(wire.billing_address) : null,
+    payments: (wire.payment_history ?? []).map(toOrderPaymentEntry),
+    hasExchangeOrReplacement: wire.has_exchange_or_replacement
+  };
+}
+function toOrderSummary(wire) {
+  return {
+    id: wire.id,
+    orderNumber: text(wire.order_no),
+    invoiceNumber: text(wire.invoice_number),
+    status: status(wire.status),
+    subtotal: amount(wire.total_amount) ?? 0,
+    payable: amount(wire.order_total) ?? 0,
+    placedAt: wire.placed_at,
+    items: wire.order_products.map((item) => ({
+      name: item.product_name ?? "",
+      variant: text(item.variant_name),
+      photo: text(item.photo),
+      quantity: item.qty,
+      unitPrice: amount(item.price) ?? 0
+    })),
+    deliveryAddress: wire.delivery_address ? toOrderAddress(wire.delivery_address) : null,
+    payment: wire.payment ? {
+      id: wire.payment.id,
+      status: wire.payment.status ?? "unpaid",
+      amount: wire.payment.order_amount ?? 0,
+      mode: text(wire.payment.mode)
+    } : null
+  };
+}
+function toShipment(wire) {
+  const info = wire.delivery_info;
+  return {
+    id: info.id,
+    partner: text(info.label) ?? "Self",
+    trackingNumber: text(info.tracking_number),
+    status: info.status,
+    createdAt: info.created_at,
+    items: wire.products.map((item) => ({
+      orderLineId: item.order_product,
+      name: item.product_name ?? "",
+      photo: text(item.photo),
+      quantity: item.qty
+    }))
+  };
+}
+
+// src/http/returns.ts
+var CUSTOMER7 = { business: "required", customer: "required" };
+function createReturnsApi(request) {
+  return {
+    async eligibleItems(orderId) {
+      const wire = await request(
+        "GET",
+        `/order/return/eligible/products/${orderId}/`,
+        CUSTOMER7
+      );
+      return wire.map(toReturnableItem);
+    },
+    async list(orderId) {
+      const wire = await request(
+        "GET",
+        `/order/return/order/list/${orderId}`,
+        CUSTOMER7
+      );
+      return wire.map(toReturnRequest);
+    },
+    async create({ orderId, reason, items }) {
+      if (items.length === 0) throw new TypeError("returns.create: items must not be empty.");
+      if (items.some((item) => !(item.quantity >= 1))) {
+        throw new RangeError("returns.create: every quantity must be at least 1.");
+      }
+      if (reason.trim() === "") throw new TypeError("returns.create: reason must not be blank.");
+      const wire = await request("POST", "/order/return/customer/create", {
+        ...CUSTOMER7,
+        json: {
+          order: orderId,
+          requested_message: reason,
+          order_products: items.map((item) => ({
+            id: item.orderLineId,
+            qty: item.quantity,
+            ...item.unitTrackingIds ? { tracking_info_ids: item.unitTrackingIds } : {}
+          }))
+        }
+      });
+      return { id: wire.id };
+    }
+  };
+}
+function toReturnableItem(wire) {
+  return {
+    orderLineId: wire.id,
+    name: wire.product_name ?? "",
+    photo: text(wire.product_photo),
+    unitPrice: amount(wire.price) ?? 0,
+    maxQuantity: wire.max_returnable_qty,
+    unitTrackingIds: wire.unit_tracking_infos.map((unit) => unit.id)
+  };
+}
+function toReturnRequest(wire) {
+  return {
+    id: wire.id,
+    status: wire.status,
+    createdAt: wire.created_at,
+    amount: amount(wire.final_amount) ?? 0,
+    items: (wire.products ?? []).map((item) => ({
+      id: item.id,
+      name: item.product_name ?? "",
+      quantity: item.qty,
+      status: item.status
+    }))
+  };
+}
+
+// src/http/exchanges.ts
+var CUSTOMER8 = { business: "required", customer: "required" };
+function createExchangesApi(request) {
+  return {
+    async create(input) {
+      const wire = await request(
+        "POST",
+        "/order/exchange-replacement/customer/create",
+        { ...CUSTOMER8, ...exchangeBody(input) }
+      );
+      return toExchangeResult(wire);
+    },
+    async list(orderId) {
+      const wire = await request(
+        "GET",
+        `/order/exchange-replacement/list/by/order/${orderId}`,
+        CUSTOMER8
+      );
+      return wire.map(toExchangeListItem);
+    },
+    async detail(exchangeId) {
+      return toExchangeDetail(
+        await request(
+          "GET",
+          `/order/exchange-replacement/detail/${exchangeId}`,
+          CUSTOMER8
+        )
+      );
+    }
+  };
+}
+function exchangeBody({ orderId, type, reason, items }) {
+  if (items.length === 0) throw new TypeError("exchanges.create: items must not be empty.");
+  if (items.some((item) => !(item.quantity >= 1))) {
+    throw new RangeError("exchanges.create: every quantity must be at least 1.");
+  }
+  if (type === "exchange" && items.some((item) => item.targetSkuId === void 0)) {
+    throw new TypeError("exchanges.create: every exchange item needs a targetSkuId.");
+  }
+  const products = items.map((item) => ({
+    order_product_id: item.orderLineId,
+    qty: item.quantity,
+    ...type === "exchange" ? { target_sku_id: item.targetSkuId } : {},
+    ...item.reason !== void 0 ? { requested_message: item.reason } : {}
+  }));
+  if (items.every((item) => item.photo === void 0)) {
+    return { json: { order_id: orderId, type, requested_message: reason, products } };
+  }
+  const files = Object.fromEntries(
+    items.map((item, index) => [
+      `request_media_${index}`,
+      item.photo === void 0 ? void 0 : { file: item.photo }
+    ])
+  );
+  return {
+    formData: multipart(
+      { order_id: orderId, type, requested_message: reason, products: JSON.stringify(products) },
+      files,
+      "Exchange photo"
+    )
+  };
+}
+function toExchangeResult(wire) {
+  if (wire.action === "pay" && wire.payment.type !== "cod") {
+    return { status: "payment-required", id: wire.id, payment: toPendingPayment(wire.payment) };
+  }
+  return { status: "submitted", id: wire.id, message: text(wire.message) };
+}
+function toExchangeListItem(wire) {
+  return {
+    id: wire.id,
+    type: wire.type,
+    status: wire.status,
+    createdAt: wire.created_at,
+    paymentId: wire.payment_id,
+    itemCount: wire.products_count
+  };
+}
+function toExchangeDetail(wire) {
+  return {
+    ...toExchangeListItem({ ...wire, products_count: wire.products.length }),
+    items: wire.products.map((row) => ({
+      orderLineId: row.order_product,
+      name: text(row.original_sku?.product_name),
+      targetSkuId: row.target_sku,
+      quantity: row.qty,
+      priceDifference: amount(row.price_difference) ?? 0,
+      status: row.status
+    }))
+  };
+}
+
+// src/http/query.ts
+function buildQuery(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const [key, raw] of Object.entries(query)) {
+    if (raw === void 0 || raw === null || raw === "") continue;
+    let value;
+    if (Array.isArray(raw)) {
+      if (raw.length === 0) continue;
+      value = raw.join(",");
+    } else {
+      value = String(raw);
+    }
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  }
+  return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var runtime2 = globalThis;
+function createClient(options) {
+  if (!options.baseURL) throw new Error("createClient: baseURL is required.");
+  if (!options.fetch && typeof runtime2.fetch !== "function") {
+    throw new Error("createClient: no global fetch in this runtime; pass the `fetch` option.");
+  }
+  const baseURL = options.baseURL.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const doFetch = options.fetch ? (url, init) => options.fetch(url, init) : (url, init) => runtime2.fetch(url, init);
+  const reported = {};
+  async function request(method, path3, opts = {}) {
+    const credentials = await options.credentials?.() ?? {};
+    if (opts.business === "required" && (credentials.businessId == null || credentials.businessId === "")) {
+      throw new Error(
+        `${method} ${path3} needs the business: return businessId from credentials().`
+      );
+    }
+    if (opts.session === "required" && !credentials.sessionToken) {
+      throw new Error(
+        `${method} ${path3} needs a guest session: return sessionToken from credentials().`
+      );
+    }
+    if (opts.customer === "required" && !credentials.customerToken) {
+      throw new Error(
+        `${method} ${path3} needs a logged-in customer: return customerToken from credentials().`
+      );
+    }
+    if (opts.merchant && !credentials.merchantToken) {
+      throw new Error(
+        `${method} ${path3} is a merchant request: return merchantToken from credentials().`
+      );
+    }
+    const headers = buildHeaders(credentials, opts);
+    const binary = opts.responseType === "binary";
+    if (binary) headers.accept = "*/*";
+    if (opts.customerOrSession === "required" && !headers["x-customer-token"] && !headers["x-session-token"]) {
+      throw new Error(
+        `${method} ${path3} needs a customer or a guest session: return customerToken or sessionToken from credentials().`
+      );
+    }
+    const init = { method, headers };
+    if (opts.formData) {
+      init.body = opts.formData;
+    } else if (opts.json !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(opts.json);
+    }
+    const url = `${baseURL}/${path3.replace(/^\/+/, "")}${buildQuery(opts.query)}`;
+    const { status: status2, ok, text: text2, data } = await send(url, init, opts.timeoutMs ?? timeoutMs, binary);
+    if (data) return data;
+    const body = parseBody(text2, ok, status2);
+    if (ok) return body;
+    if (status2 === 401) reportUnauthorized(headers);
+    if (isDeadSession(status2, body, headers)) report("session", headers["x-session-token"]);
+    throw new GrowupsellApiError({
+      kind: "http",
+      status: status2,
+      message: messageFromBody(body) ?? `Request failed with status ${status2}`,
+      fieldErrors: fieldErrorsFromBody(body),
+      body
+    });
+  }
+  async function send(url, init, ms, binary) {
+    const controller = runtime2.AbortController ? new runtime2.AbortController() : void 0;
+    if (controller) init.signal = controller.signal;
+    let timedOut = false;
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = runtime2.setTimeout(() => {
+        timedOut = true;
+        controller?.abort();
+        reject(timeoutError(ms));
+      }, ms);
+    });
+    try {
+      return await Promise.race([
+        doFetch(url, init).then(async (res) => ({
+          status: res.status,
+          ok: res.ok,
+          // Error responses are read as text even for binary requests: they carry the message.
+          text: binary && res.ok ? "" : await res.text(),
+          data: binary && res.ok ? await readBinary(res) : void 0
+        })),
+        timeout
+      ]);
+    } catch (error) {
+      if (timedOut) throw timeoutError(ms);
+      if (error instanceof GrowupsellApiError) throw error;
+      throw new GrowupsellApiError({
+        kind: "network",
+        message: error instanceof Error ? error.message : "Network request failed"
+      });
+    } finally {
+      runtime2.clearTimeout(timer);
+    }
+  }
+  function reportUnauthorized(headers) {
+    const merchant = headers.authorization?.replace(/^Token /, "");
+    const customer = headers["x-customer-token"];
+    const kind = merchant ? "merchant" : customer ? "customer" : void 0;
+    if (!kind) return;
+    report(kind, kind === "merchant" ? merchant : customer);
+  }
+  function report(kind, token) {
+    if (reported[kind] === token) return;
+    reported[kind] = token;
+    options.onUnauthorized?.({ kind });
+  }
+  return {
+    request,
+    business: createBusinessApi(request),
+    catalog: createCatalogApi(request),
+    products: createProductsApi(request),
+    reviews: createReviewsApi(request),
+    wishlist: createWishlistApi(request),
+    policies: createPoliciesApi(request),
+    faq: createFaqApi(request),
+    themeContent: createThemeContentApi(request),
+    productPage: createProductPageApi(request),
+    customPages: createCustomPagesApi(request),
+    session: createSessionApi(request),
+    lookup: createLookupApi(request),
+    auth: createAuthApi(request),
+    customer: createCustomerApi(request),
+    addresses: createAddressesApi(request),
+    checkout: createCheckoutApi(request),
+    payments: createPaymentsApi(request),
+    blog: createBlogApi(request),
+    forms: createFormsApi(request),
+    helpdesk: createHelpdeskApi(request),
+    newsletter: createNewsletterApi(request),
+    liveSupport: createLiveSupportApi(request),
+    customManufacturing: createCustomManufacturingApi(request),
+    subscriptions: createSubscriptionsApi(request),
+    cart: createCartApi(request),
+    promotions: createPromotionsApi(request),
+    orders: createOrdersApi(request),
+    returns: createReturnsApi(request),
+    exchanges: createExchangesApi(request)
+  };
+}
+function buildHeaders(credentials, opts) {
+  const headers = { accept: "application/json" };
+  if (credentials.businessId != null && credentials.businessId !== "") {
+    headers.business = String(credentials.businessId);
+  }
+  if (credentials.customerToken && !opts.anonymous) {
+    headers["x-customer-token"] = credentials.customerToken;
+  }
+  if (credentials.sessionToken && opts.session !== "omit") {
+    headers["x-session-token"] = credentials.sessionToken;
+  }
+  if (opts.merchant && credentials.merchantToken) {
+    headers.authorization = `Token ${credentials.merchantToken}`;
+  }
+  return headers;
+}
+function isDeadSession(status2, body, headers) {
+  return status2 === 404 && typeof body === "string" && !!headers["x-session-token"];
+}
+function parseBody(text2, ok, status2) {
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    if (!ok) return text2;
+    throw new GrowupsellApiError({
+      kind: "parse",
+      status: status2,
+      message: "The server returned a response that is not valid JSON.",
+      body: text2
+    });
+  }
+}
+async function readBinary(res) {
+  if (!res.arrayBuffer) {
+    throw new GrowupsellApiError({
+      kind: "parse",
+      status: res.status,
+      message: "This fetch cannot read binary responses."
+    });
+  }
+  return { contentType: res.headers?.get("content-type") ?? null, data: await res.arrayBuffer() };
+}
+function timeoutError(ms) {
+  return new GrowupsellApiError({ kind: "timeout", message: `Request timed out after ${ms} ms` });
+}
+
+export {
+  GrowupsellApiError,
+  createClient
+};
+//# sourceMappingURL=chunk-YZJTPFCH.js.map