@xbstracts/medusa-coupons 0.0.1

package/.medusa/server/src/admin/index.mjs

@@ -0,0 +1,3253 @@
+// src/admin/i18n/en.json
+var en_default = {
+  coupons: {
+    menu: "Coupons",
+    productsMenu: "Coupon Products"
+  }
+};
+
+// src/admin/i18n/index.ts
+var i18n_default = {
+  en: {
+    translation: en_default
+  }
+};
+
+// src/admin/routes/coupons/page.tsx
+import { ReceiptPercent } from "@medusajs/icons";
+
+// src/dashboard/coupons/coupon-manager.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useState as useState2
+} from "react";
+import {
+  ArrowPath as ArrowPath2,
+  PencilSquare as PencilSquare2,
+  Plus as Plus2,
+  ShoppingCart,
+  Trash as Trash2,
+  TriangleRightMini
+} from "@medusajs/icons";
+import {
+  Button as Button2,
+  Container as Container2,
+  Copy,
+  CurrencyInput as CurrencyInput2,
+  FocusModal as FocusModal2,
+  Heading as Heading2,
+  Input as Input2,
+  Label as Label2,
+  ProgressTabs as ProgressTabs2,
+  Select as Select2,
+  StatusBadge as StatusBadge2,
+  Switch as Switch2,
+  Table as Table2,
+  Tabs,
+  Text as Text3,
+  Textarea as Textarea2,
+  toast as toast2,
+  usePrompt as usePrompt2
+} from "@medusajs/ui";
+
+// src/dashboard/coupons/coupon-products-page.tsx
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import {
+  Adjustments,
+  ArrowPath,
+  ArrowUpTray,
+  InformationCircle,
+  PencilSquare,
+  Plus,
+  TaxExclusive,
+  TaxInclusive,
+  Trash,
+  XMarkMini
+} from "@medusajs/icons";
+import {
+  Button,
+  Checkbox,
+  Container,
+  CurrencyInput,
+  Divider,
+  DropdownMenu,
+  Drawer,
+  FocusModal,
+  Heading,
+  Input,
+  Label,
+  ProgressTabs,
+  RadioGroup,
+  Select,
+  StatusBadge,
+  Switch,
+  Table,
+  Text as Text2,
+  Textarea,
+  Tooltip,
+  toast,
+  usePrompt
+} from "@medusajs/ui";
+
+// src/dashboard/coupons/empty-state.tsx
+import { Text } from "@medusajs/ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+function CouponEmptyState({
+  description,
+  title
+}) {
+  return /* @__PURE__ */ jsx("div", { className: "flex w-full flex-1 flex-col overflow-hidden", children: /* @__PURE__ */ jsx("div", { className: "flex min-h-[250px] w-full flex-1 flex-col items-center justify-center px-6 py-4", children: /* @__PURE__ */ jsxs("div", { className: "flex size-full flex-col items-center justify-center gap-2 text-center", children: [
+    /* @__PURE__ */ jsx(Text, { weight: "plus", children: title }),
+    description ? /* @__PURE__ */ jsx(Text, { children: description }) : null
+  ] }) }) });
+}
+
+// src/dashboard/coupons/coupon-products-page.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var NONE = "__none__";
+var allSteps = ["details", "organize", "campaign", "prices"];
+var conditionAttributes = [
+  { value: "customer.groups.id", label: "Customer Group" },
+  { value: "region.id", label: "Region" },
+  { value: "shipping_address.country_code", label: "Country" },
+  { value: "sales_channel_id", label: "Sales Channel" },
+  { value: "currency_code", label: "Currency Code" }
+];
+var conditionOperators = [
+  { value: "in", label: "In" },
+  { value: "eq", label: "Equals" },
+  { value: "ne", label: "Not In" }
+];
+var typeChoices = [
+  {
+    value: "amount_off_products",
+    label: "Amount off products",
+    description: "Discount specific products or a collection of products"
+  },
+  {
+    value: "amount_off_order",
+    label: "Amount off order",
+    description: "Discount the total order amount"
+  },
+  {
+    value: "percentage_off_product",
+    label: "Percentage off product",
+    description: "Discount a percentage off selected products"
+  },
+  {
+    value: "percentage_off_order",
+    label: "Percentage off order",
+    description: "Discount a percentage off the total order amount"
+  },
+  {
+    value: "buy_x_get_y",
+    label: "Buy X Get Y",
+    description: "Issue a Buy X Get Y coupon entitlement"
+  },
+  {
+    value: "free_shipping",
+    label: "Free shipping",
+    description: "Apply a 100% discount to shipping fees"
+  }
+];
+var statusChoices = [
+  {
+    value: "draft",
+    label: "Draft",
+    description: "Customers will not be able to use the code yet"
+  },
+  {
+    value: "active",
+    label: "Active",
+    description: "Customers will be able to use the code"
+  },
+  {
+    value: "inactive",
+    label: "Inactive",
+    description: "Keep the promotion unavailable until reactivated"
+  }
+];
+function backendUrl() {
+  return typeof __BACKEND_URL__ === "string" ? __BACKEND_URL__.replace(/\/$/, "") : "";
+}
+function apiErrorMessage(payload, fallback) {
+  return [payload?.message, payload?.error?.message, payload?.error].find(
+    (candidate) => typeof candidate === "string" && candidate.trim()
+  ) || fallback || "Request failed";
+}
+async function apiFetch(path, options = {}) {
+  const response = await fetch(`${backendUrl()}${path}`, {
+    ...options,
+    credentials: "include",
+    headers: {
+      ...options.body ? { "Content-Type": "application/json" } : {},
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const payload = await response.json().catch(() => null);
+    throw new Error(apiErrorMessage(payload, response.statusText));
+  }
+  return response.json();
+}
+function optionLabel(option) {
+  return option.name || option.title || option.value || option.handle || option.id;
+}
+function numberOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function nonNegativeNumberOrNull(value) {
+  if (!value.trim()) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+function toDateTimeLocal(value) {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  const localDate = new Date(date.getTime() - date.getTimezoneOffset() * 6e4);
+  return localDate.toISOString().slice(0, 16);
+}
+function currencyDecimalDigits(code) {
+  try {
+    return new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: code.toUpperCase()
+    }).resolvedOptions().maximumFractionDigits;
+  } catch {
+    return 2;
+  }
+}
+function currencySymbol(code) {
+  if (!code) return "";
+  try {
+    return new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: code.toUpperCase(),
+      currencyDisplay: "narrowSymbol"
+    }).formatToParts(0).find((part) => part.type === "currency")?.value || code.toUpperCase();
+  } catch {
+    return code.toUpperCase();
+  }
+}
+function couponTypeFromConfig(config3) {
+  if (config3.benefit_type === "percentage") {
+    return config3.promotion_template?.application_method?.target_type === "order" ? "percentage_off_order" : "percentage_off_product";
+  }
+  if (config3.benefit_type === "buy_get") return "buy_x_get_y";
+  if (config3.benefit_type === "free_shipping") return "free_shipping";
+  return config3.promotion_template?.application_method?.target_type === "order" ? "amount_off_order" : "amount_off_products";
+}
+function benefitTypeFromCouponType(type) {
+  if (type === "percentage_off_product" || type === "percentage_off_order") return "percentage";
+  if (type === "buy_x_get_y") return "buy_get";
+  if (type === "free_shipping") return "free_shipping";
+  return "fixed_amount";
+}
+function couponTypeLabel(config3) {
+  return typeChoices.find(
+    (choice) => choice.value === couponTypeFromConfig(config3)
+  )?.label;
+}
+function couponStatusColor(status) {
+  if (status === "active") return "green";
+  if (status === "inactive") return "orange";
+  return "grey";
+}
+function productStatusFromCouponStatus(status) {
+  return status === "active" ? "published" : "draft";
+}
+function campaignLabel(config3) {
+  const name = config3.campaign_snapshot?.name;
+  return typeof name === "string" && name ? name : config3.campaign_id || "None";
+}
+function defaultCurrency(options) {
+  return options.currencies?.find((currency) => currency.is_default)?.code || options.currencies?.[0]?.code || "";
+}
+function conditionKey(prefix = "condition") {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function isAmountCouponType(type) {
+  return type === "amount_off_products" || type === "amount_off_order";
+}
+function effectiveCouponCurrencies(conditions, currencies) {
+  const condition = conditions.find(
+    (item) => item.attribute === "currency_code"
+  );
+  if (!condition || !condition.operator) return [];
+  const selected = new Set(condition.values);
+  const supported = currencies.map((currency) => currency.code);
+  return condition.operator === "ne" ? supported.filter((code) => !selected.has(code)) : supported.filter((code) => selected.has(code));
+}
+function reconcileCouponAmounts(current, currencyCodes) {
+  const byCurrency = Object.fromEntries(
+    current.map((row) => [row.currency_code, row])
+  );
+  return currencyCodes.map((currencyCode) => ({
+    key: byCurrency[currencyCode]?.key || conditionKey("coupon-value"),
+    currency_code: currencyCode,
+    amount: byCurrency[currencyCode]?.amount || ""
+  }));
+}
+function defaultPurchaseConditions(options) {
+  const currencyCode = defaultCurrency(options);
+  return currencyCode ? [
+    {
+      key: conditionKey("currency"),
+      attribute: "currency_code",
+      operator: "eq",
+      values: [currencyCode]
+    }
+  ] : [];
+}
+function emptyProduct(options) {
+  return {
+    title: "",
+    subtitle: "",
+    handle: "",
+    description: "",
+    media: [],
+    sku: "",
+    price_amounts: Object.fromEntries(
+      (options.currencies || []).map((currency) => [currency.code, ""])
+    ),
+    status: "draft",
+    discountable: false,
+    seller_id: "",
+    type_id: "",
+    collection_id: "",
+    category_id: "",
+    tag_id: ""
+  };
+}
+function emptyCoupon(options) {
+  const currencyCode = defaultCurrency(options);
+  const purchaseConditions = defaultPurchaseConditions(options);
+  return {
+    enabled: true,
+    type: "amount_off_products",
+    purchase_conditions: purchaseConditions,
+    amounts: currencyCode ? [
+      {
+        key: "coupon-value-default",
+        currency_code: currencyCode,
+        amount: ""
+      }
+    ] : [],
+    percentage: "",
+    allocation: "each",
+    code_strategy: "unique_code",
+    code_prefix: "COUPON",
+    shared_code: "",
+    expiration_type: "duration",
+    expiration_days: "30",
+    expiration_date: "",
+    expiration_cap_by_campaign: true,
+    expiration_cap_at: "",
+    max_issuance_per_order_item: "1",
+    promotion_mirror_mode: "none",
+    promotion_status: "draft"
+  };
+}
+var emptyCampaign = {
+  mode: "none",
+  campaign_id: "",
+  name: "",
+  campaign_identifier: "",
+  starts_at: "",
+  ends_at: ""
+};
+function formsFromRow(row, options) {
+  const product = row.product;
+  const config3 = row.coupon_product_config;
+  const variant = product.variants?.[0];
+  const prices = Object.fromEntries(
+    (variant?.prices || []).filter((price) => price.currency_code).map((price) => [
+      String(price.currency_code).toLowerCase(),
+      price.amount == null ? "" : String(price.amount)
+    ])
+  );
+  const media = Array.from(
+    new Map(
+      [
+        ...product.thumbnail ? [
+          {
+            url: product.thumbnail,
+            asset_id: product.thumbnail_asset_id || void 0
+          }
+        ] : [],
+        ...(product.images || []).filter((image) => image.url).map((image) => ({
+          url: String(image.url),
+          asset_id: image.asset_id || void 0
+        }))
+      ].map((item) => [item.url, item])
+    ).values()
+  );
+  const configuredAmounts = Array.isArray(config3.amounts) && config3.amounts.length ? config3.amounts : config3.amount != null && config3.currency_code ? [{ amount: config3.amount, currency_code: config3.currency_code }] : [];
+  const configuredConditions = (config3.purchase_conditions || []).map(
+    (condition, index) => ({
+      key: `condition-${index}`,
+      attribute: condition.attribute,
+      operator: condition.operator,
+      values: condition.values.map(
+        (value) => condition.attribute === "currency_code" || condition.attribute === "shipping_address.country_code" ? value.toLowerCase() : value
+      )
+    })
+  );
+  if (!configuredConditions.some(
+    (condition) => condition.attribute === "currency_code"
+  ) && config3.benefit_type === "fixed_amount" && configuredAmounts.length) {
+    configuredConditions.push({
+      key: "condition-legacy-currency",
+      attribute: "currency_code",
+      operator: configuredAmounts.length === 1 ? "eq" : "in",
+      values: configuredAmounts.map(
+        (amount) => amount.currency_code.toLowerCase()
+      )
+    });
+  }
+  if (!configuredConditions.some(
+    (condition) => condition.attribute === "sales_channel_id"
+  ) && product.sales_channels?.length) {
+    configuredConditions.push({
+      key: "condition-legacy-sales-channel",
+      attribute: "sales_channel_id",
+      operator: product.sales_channels.length === 1 ? "eq" : "in",
+      values: product.sales_channels.map((channel) => channel.id)
+    });
+  }
+  const expirationPolicy = config3.expiration_policy;
+  const configuredAmountRows = configuredAmounts.map((row2, index) => ({
+    key: `coupon-value-${index}`,
+    amount: String(row2.amount),
+    currency_code: row2.currency_code.toLowerCase()
+  }));
+  const amountRows = config3.benefit_type === "fixed_amount" ? reconcileCouponAmounts(
+    configuredAmountRows,
+    effectiveCouponCurrencies(configuredConditions, options.currencies || [])
+  ) : configuredAmountRows;
+  return {
+    product: {
+      ...emptyProduct(options),
+      title: product.title || "",
+      subtitle: product.subtitle || "",
+      handle: product.handle || "",
+      description: product.description || "",
+      media,
+      sku: variant?.sku || "",
+      price_amounts: {
+        ...emptyProduct(options).price_amounts,
+        ...prices
+      },
+      status: product.status || "draft",
+      discountable: Boolean(product.discountable),
+      type_id: product.type_id || "",
+      collection_id: product.collection_id || "",
+      category_id: product.categories?.[0]?.id || "",
+      tag_id: product.tags?.[0]?.id || ""
+    },
+    coupon: {
+      ...emptyCoupon(options),
+      enabled: config3.enabled,
+      type: couponTypeFromConfig(config3),
+      purchase_conditions: configuredConditions,
+      amounts: config3.benefit_type === "fixed_amount" ? amountRows : amountRows.length ? amountRows : emptyCoupon(options).amounts,
+      percentage: config3.percentage == null ? "" : String(config3.percentage),
+      allocation: config3.promotion_template?.application_method?.allocation === "once" ? "once" : "each",
+      code_strategy: config3.code_strategy,
+      code_prefix: config3.code_prefix || "",
+      shared_code: config3.shared_code || "",
+      expiration_type: config3.expiration_policy?.type || "duration",
+      expiration_days: config3.expiration_policy?.type === "duration" ? String(config3.expiration_policy.duration_days) : "30",
+      expiration_date: config3.expiration_policy?.type === "fixed" ? toDateTimeLocal(config3.expiration_policy.expires_at) : "",
+      expiration_cap_by_campaign: expirationPolicy.type === "none" || expirationPolicy.cap_by_campaign !== false,
+      expiration_cap_at: expirationPolicy.type === "none" ? "" : toDateTimeLocal(expirationPolicy.cap_at),
+      max_issuance_per_order_item: String(
+        config3.max_issuance_per_order_item || 1
+      ),
+      promotion_mirror_mode: config3.promotion_mirror_mode || "none",
+      promotion_status: config3.promotion_status || "draft"
+    },
+    campaign: {
+      ...emptyCampaign,
+      mode: config3.campaign_id ? "existing" : "none",
+      campaign_id: config3.campaign_id || ""
+    }
+  };
+}
+var modalContentStyle = {
+  display: "flex",
+  flexDirection: "column",
+  overflow: "hidden"
+};
+var modalWizardStyle = {
+  display: "flex",
+  flex: "1 1 auto",
+  flexDirection: "column",
+  minHeight: 0,
+  overflow: "hidden"
+};
+var visuallyHiddenStyle = {
+  clip: "rect(0 0 0 0)",
+  clipPath: "inset(50%)",
+  height: 1,
+  overflow: "hidden",
+  position: "absolute",
+  whiteSpace: "nowrap",
+  width: 1
+};
+var modalBodyStyle = {
+  flex: "1 1 auto",
+  minHeight: 0,
+  padding: 0
+};
+var modalScrollStyle = {
+  height: "100%",
+  overflowY: "auto",
+  padding: "64px 24px 112px",
+  width: "100%"
+};
+var modalFormStyle = {
+  margin: "0 auto",
+  maxWidth: 720,
+  width: "min(720px, 100%)"
+};
+var stackStyle = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 24
+};
+var twoColumnGridStyle = {
+  display: "grid",
+  gap: 16,
+  gridTemplateColumns: "repeat(auto-fit, minmax(260px, 1fr))"
+};
+var threeColumnGridStyle = {
+  display: "grid",
+  gap: 16,
+  gridTemplateColumns: "repeat(auto-fit, minmax(180px, 1fr))"
+};
+var panelStyle = {
+  border: "1px solid var(--border-base)",
+  borderRadius: 8,
+  padding: 16
+};
+function Field({
+  children,
+  label,
+  optional,
+  tooltip
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-y-1", style: { minWidth: 0 }, children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-x-1", children: [
+      /* @__PURE__ */ jsx2(Label, { children: label }),
+      tooltip && /* @__PURE__ */ jsx2(Tooltip, { content: tooltip, children: /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          "aria-label": `${label} information`,
+          className: "text-ui-fg-muted",
+          children: /* @__PURE__ */ jsx2(InformationCircle, {})
+        }
+      ) }),
+      optional && /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: "(Optional)" })
+    ] }),
+    children
+  ] });
+}
+function Section({
+  children,
+  description,
+  title
+}) {
+  return /* @__PURE__ */ jsxs2("section", { className: "flex flex-col gap-y-4", children: [
+    /* @__PURE__ */ jsxs2("div", { children: [
+      /* @__PURE__ */ jsx2(Heading, { level: "h2", children: title }),
+      description && /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: description })
+    ] }),
+    children
+  ] });
+}
+function OptionSelect({
+  onChange,
+  options,
+  value
+}) {
+  return /* @__PURE__ */ jsxs2(
+    Select,
+    {
+      value: value || NONE,
+      onValueChange: (next) => onChange(next === NONE ? "" : next),
+      children: [
+        /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, {}) }),
+        /* @__PURE__ */ jsxs2(Select.Content, { children: [
+          /* @__PURE__ */ jsx2(Select.Item, { value: NONE, children: "None" }),
+          options.map((option) => /* @__PURE__ */ jsx2(Select.Item, { value: option.id, children: optionLabel(option) }, option.id))
+        ] })
+      ]
+    }
+  );
+}
+function CurrencyAmountField({
+  currencies,
+  currencyCode,
+  onChange,
+  value
+}) {
+  const currency = currencies.find((item) => item.code === currencyCode);
+  const code = currencyCode.toUpperCase();
+  const decimals = currencyDecimalDigits(code || "USD");
+  return /* @__PURE__ */ jsx2(
+    CurrencyInput,
+    {
+      code: code || "USD",
+      symbol: currency?.symbol_native || currency?.symbol || currencySymbol(code || "USD"),
+      min: 0,
+      decimalScale: decimals,
+      decimalsLimit: decimals,
+      value,
+      disabled: !currencyCode,
+      onValueChange: (nextValue) => onChange(nextValue || "")
+    }
+  );
+}
+function PercentageInput({
+  onChange,
+  value
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex w-full items-stretch", style: { width: "100%" }, children: [
+    /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className: "bg-ui-bg-field text-ui-fg-muted flex items-center border",
+        style: {
+          borderColor: "var(--border-base)",
+          borderRadius: "6px 0 0 6px",
+          borderRight: 0,
+          padding: "0 12px"
+        },
+        children: "%"
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className: "min-w-0 flex-1",
+        style: { flex: "1 1 0%", minWidth: 0 },
+        children: /* @__PURE__ */ jsx2(
+          Input,
+          {
+            className: "w-full",
+            type: "number",
+            min: 1,
+            max: 100,
+            value,
+            style: {
+              borderRadius: "0 6px 6px 0",
+              width: "100%"
+            },
+            onChange: (event) => onChange(event.target.value)
+          }
+        )
+      }
+    )
+  ] });
+}
+function HandleInput({
+  onChange,
+  value
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
+    /* @__PURE__ */ jsx2("div", { className: "text-ui-fg-muted pointer-events-none absolute inset-y-0 left-0 z-10 flex min-w-8 items-center justify-center border-r px-2.5", children: /* @__PURE__ */ jsx2("span", { className: "txt-compact-small font-medium", children: "/" }) }),
+    /* @__PURE__ */ jsx2(
+      Input,
+      {
+        value,
+        placeholder: "winter-jacket",
+        style: { paddingLeft: 34 },
+        onChange: (event) => onChange(event.target.value)
+      }
+    )
+  ] });
+}
+function MediaUpload({
+  isUploading,
+  media,
+  onRemove,
+  onUpload
+}) {
+  const inputRef = useRef(null);
+  const accept = "image/jpeg,image/png,image/gif,image/webp,image/heic,image/svg+xml";
+  const handleFiles = (files) => {
+    if (!files?.length) return;
+    onUpload(Array.from(files));
+  };
+  const handleDrop = (event) => {
+    event.preventDefault();
+    handleFiles(event.dataTransfer.files);
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-y-3", children: [
+    media.length > 0 && /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className: "grid gap-3",
+        style: {
+          gridTemplateColumns: "repeat(auto-fill, minmax(120px, 1fr))"
+        },
+        children: media.map((item, index) => /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: "relative overflow-hidden rounded-md border",
+            children: [
+              /* @__PURE__ */ jsx2(
+                "img",
+                {
+                  src: item.url,
+                  alt: "",
+                  className: "h-32 w-full object-cover",
+                  style: { height: 128 }
+                }
+              ),
+              /* @__PURE__ */ jsxs2("div", { className: "absolute inset-x-0 bottom-0 flex items-center justify-between bg-black/60 px-2 py-1", children: [
+                /* @__PURE__ */ jsx2(Text2, { size: "xsmall", style: { color: "white" }, children: index === 0 ? "Thumbnail" : `Image ${index + 1}` }),
+                /* @__PURE__ */ jsx2(
+                  "button",
+                  {
+                    type: "button",
+                    "aria-label": "Remove image",
+                    style: { color: "white" },
+                    onClick: () => onRemove(item),
+                    children: /* @__PURE__ */ jsx2(XMarkMini, {})
+                  }
+                )
+              ] })
+            ]
+          },
+          item.asset_id || item.url
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      "input",
+      {
+        ref: inputRef,
+        type: "file",
+        hidden: true,
+        multiple: true,
+        accept,
+        onChange: (event) => {
+          handleFiles(event.target.files);
+          event.target.value = "";
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        type: "button",
+        disabled: isUploading,
+        className: "text-ui-fg-muted flex w-full flex-col items-center justify-center gap-y-2 rounded-md border border-dashed p-8",
+        style: { minHeight: 148 },
+        onClick: () => inputRef.current?.click(),
+        onDragOver: (event) => event.preventDefault(),
+        onDrop: handleDrop,
+        children: [
+          /* @__PURE__ */ jsxs2("span", { className: "text-ui-fg-base flex items-center gap-x-2", children: [
+            /* @__PURE__ */ jsx2(ArrowUpTray, {}),
+            isUploading ? "Uploading images..." : "Upload images"
+          ] }),
+          /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: "Drag and drop images here or click to upload." })
+        ]
+      }
+    )
+  ] });
+}
+function conditionValueOptions(attribute, options) {
+  if (attribute === "currency_code") {
+    return (options.currencies || []).map((currency) => ({
+      value: currency.code,
+      label: `${currency.name} (${currency.code.toUpperCase()})`
+    }));
+  }
+  if (attribute === "shipping_address.country_code") {
+    return (options.countries || []).map((country) => ({
+      value: String(country.iso_2 || country.id).toLowerCase(),
+      label: country.display_name || country.name || country.id
+    }));
+  }
+  const records = attribute === "customer.groups.id" ? options.customer_groups : attribute === "region.id" ? options.regions : attribute === "sales_channel_id" ? options.sales_channels : [];
+  return (records || []).map((record) => ({
+    value: record.id,
+    label: optionLabel(record)
+  }));
+}
+function MultiConditionValues({
+  attribute,
+  onChange,
+  options,
+  value
+}) {
+  const [open, setOpen] = useState(false);
+  const [draft, setDraft] = useState(value);
+  const [search, setSearch] = useState("");
+  const labels = Object.fromEntries(options.map((option) => [option.value, option.label]));
+  const filtered = options.filter(
+    (option) => option.label.toLowerCase().includes(search.trim().toLowerCase())
+  );
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx2(
+      Button,
+      {
+        type: "button",
+        variant: "secondary",
+        className: "w-full justify-start",
+        onClick: () => {
+          setDraft(value);
+          setSearch("");
+          setOpen(true);
+        },
+        children: value.length ? value.length === 1 ? labels[value[0]] || value[0] : `${value.length} values selected` : "Select values"
+      }
+    ),
+    value.length > 0 && /* @__PURE__ */ jsx2("div", { className: "mt-2 flex flex-wrap gap-1", children: value.map((item) => /* @__PURE__ */ jsxs2(
+      "span",
+      {
+        className: "bg-ui-bg-component text-ui-fg-subtle flex items-center gap-x-1 rounded-md border px-2 py-1 text-xs",
+        children: [
+          labels[item] || item,
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              "aria-label": `Remove ${labels[item] || item}`,
+              onClick: () => onChange(value.filter((entry) => entry !== item)),
+              children: /* @__PURE__ */ jsx2(XMarkMini, {})
+            }
+          )
+        ]
+      },
+      item
+    )) }),
+    /* @__PURE__ */ jsx2(Drawer, { open, onOpenChange: setOpen, children: /* @__PURE__ */ jsxs2(Drawer.Content, { children: [
+      /* @__PURE__ */ jsx2(Drawer.Header, { children: /* @__PURE__ */ jsxs2(Drawer.Title, { children: [
+        "Select ",
+        conditionAttributes.find((item) => item.value === attribute)?.label
+      ] }) }),
+      /* @__PURE__ */ jsxs2(Drawer.Body, { className: "flex flex-col gap-y-3 overflow-y-auto", children: [
+        /* @__PURE__ */ jsx2(
+          Input,
+          {
+            value: search,
+            placeholder: "Search values",
+            onChange: (event) => setSearch(event.target.value)
+          }
+        ),
+        filtered.length ? filtered.map((option) => /* @__PURE__ */ jsxs2(
+          "label",
+          {
+            className: "flex cursor-pointer items-center gap-x-3 rounded-md border p-3",
+            children: [
+              /* @__PURE__ */ jsx2(
+                Checkbox,
+                {
+                  checked: draft.includes(option.value),
+                  onCheckedChange: (checked) => setDraft(
+                    (current) => checked ? Array.from(/* @__PURE__ */ new Set([...current, option.value])) : current.filter((value2) => value2 !== option.value)
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx2(Text2, { children: option.label })
+            ]
+          },
+          option.value
+        )) : /* @__PURE__ */ jsx2(Text2, { className: "text-ui-fg-muted", children: "No matching values." })
+      ] }),
+      /* @__PURE__ */ jsxs2(Drawer.Footer, { children: [
+        /* @__PURE__ */ jsx2(Button, { type: "button", variant: "secondary", onClick: () => setOpen(false), children: "Cancel" }),
+        /* @__PURE__ */ jsx2(
+          Button,
+          {
+            type: "button",
+            disabled: !draft.length,
+            onClick: () => {
+              onChange(draft);
+              setOpen(false);
+            },
+            children: "Apply"
+          }
+        )
+      ] })
+    ] }) })
+  ] });
+}
+function PurchaseConditionsField({
+  fixedAmount,
+  onChange,
+  options,
+  value
+}) {
+  const selectedAttributes = new Set(
+    value.map((condition) => condition.attribute).filter(Boolean)
+  );
+  const replace = (key, update) => onChange(
+    value.map(
+      (condition) => condition.key === key ? { ...condition, ...update } : condition
+    )
+  );
+  return /* @__PURE__ */ jsx2(
+    Section,
+    {
+      title: "Who can purchase this coupon?",
+      description: "Coupon products can be purchased by all customers when no conditions are configured. Conditions are combined with AND.",
+      children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-y-3", children: [
+        value.map((condition, index) => {
+          const values = conditionValueOptions(condition.attribute, options);
+          const currencyRequired = fixedAmount && condition.attribute === "currency_code";
+          return /* @__PURE__ */ jsxs2("div", { children: [
+            index > 0 && /* @__PURE__ */ jsx2("div", { className: "text-ui-fg-muted flex h-8 items-center text-xs font-medium", children: "AND" }),
+            /* @__PURE__ */ jsxs2("div", { style: panelStyle, className: "relative flex flex-col gap-y-3", children: [
+              /* @__PURE__ */ jsxs2("div", { className: "flex items-start gap-x-2", children: [
+                /* @__PURE__ */ jsx2("div", { className: "flex-1", children: /* @__PURE__ */ jsxs2(
+                  Select,
+                  {
+                    value: condition.attribute || void 0,
+                    disabled: currencyRequired,
+                    onValueChange: (attribute) => replace(condition.key, {
+                      attribute,
+                      operator: "",
+                      values: []
+                    }),
+                    children: [
+                      /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, { placeholder: "Select attribute" }) }),
+                      /* @__PURE__ */ jsx2(Select.Content, { children: conditionAttributes.filter(
+                        (attribute) => attribute.value === condition.attribute || !selectedAttributes.has(attribute.value)
+                      ).map((attribute) => /* @__PURE__ */ jsx2(Select.Item, { value: attribute.value, children: attribute.label }, attribute.value)) })
+                    ]
+                  }
+                ) }),
+                /* @__PURE__ */ jsx2(
+                  Button,
+                  {
+                    type: "button",
+                    size: "small",
+                    variant: "transparent",
+                    disabled: currencyRequired,
+                    "aria-label": "Remove condition",
+                    onClick: () => onChange(value.filter((item) => item.key !== condition.key)),
+                    children: /* @__PURE__ */ jsx2(XMarkMini, {})
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                /* @__PURE__ */ jsxs2(
+                  Select,
+                  {
+                    value: condition.operator || void 0,
+                    disabled: !condition.attribute,
+                    onValueChange: (operator) => replace(condition.key, {
+                      operator,
+                      values: operator === "eq" ? condition.values.slice(0, 1) : condition.values
+                    }),
+                    children: [
+                      /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, { placeholder: "Select operator" }) }),
+                      /* @__PURE__ */ jsx2(Select.Content, { children: conditionOperators.map((operator) => /* @__PURE__ */ jsx2(Select.Item, { value: operator.value, children: operator.label }, operator.value)) })
+                    ]
+                  }
+                ),
+                condition.attribute && condition.operator === "eq" ? /* @__PURE__ */ jsxs2(
+                  Select,
+                  {
+                    value: condition.values[0] || void 0,
+                    onValueChange: (selected) => replace(condition.key, { values: [selected] }),
+                    children: [
+                      /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, { placeholder: "Select value" }) }),
+                      /* @__PURE__ */ jsx2(Select.Content, { children: values.map((option) => /* @__PURE__ */ jsx2(Select.Item, { value: option.value, children: option.label }, option.value)) })
+                    ]
+                  }
+                ) : condition.attribute && condition.operator ? /* @__PURE__ */ jsx2(
+                  MultiConditionValues,
+                  {
+                    attribute: condition.attribute,
+                    options: values,
+                    value: condition.values,
+                    onChange: (values2) => replace(condition.key, { values: values2 })
+                  }
+                ) : /* @__PURE__ */ jsx2(Button, { type: "button", variant: "secondary", disabled: true, className: "w-full", children: "Select values" })
+              ] })
+            ] })
+          ] }, condition.key);
+        }),
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-x-2", children: [
+          /* @__PURE__ */ jsxs2(
+            Button,
+            {
+              type: "button",
+              variant: "secondary",
+              disabled: selectedAttributes.size >= conditionAttributes.length,
+              onClick: () => onChange([
+                ...value,
+                { key: conditionKey(), attribute: "", operator: "", values: [] }
+              ]),
+              children: [
+                /* @__PURE__ */ jsx2(Plus, {}),
+                " Add condition"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Button,
+            {
+              type: "button",
+              variant: "transparent",
+              onClick: () => onChange(fixedAmount ? defaultPurchaseConditions(options) : []),
+              children: "Clear all"
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
+function ProductPricesTable({
+  currencies,
+  couponValue,
+  onChange,
+  prices
+}) {
+  const [visibleCurrencies, setVisibleCurrencies] = useState(
+    () => currencies.map((currency) => currency.code)
+  );
+  useEffect(() => {
+    setVisibleCurrencies((current) => {
+      const available = new Set(currencies.map((currency) => currency.code));
+      const retained = current.filter((code) => available.has(code));
+      const added = currencies.map((currency) => currency.code).filter((code) => !current.includes(code));
+      return [...retained, ...added];
+    });
+  }, [currencies]);
+  const shownCurrencies = currencies.filter(
+    (currency) => visibleCurrencies.includes(currency.code)
+  );
+  return /* @__PURE__ */ jsx2("div", { className: "flex size-full flex-col divide-y overflow-hidden", children: /* @__PURE__ */ jsxs2("div", { className: "bg-ui-bg-subtle flex size-full flex-col", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "bg-ui-bg-base flex items-center justify-between border-b p-4", children: [
+      /* @__PURE__ */ jsx2("div", { className: "flex items-center gap-x-2", children: /* @__PURE__ */ jsxs2(DropdownMenu, { children: [
+        /* @__PURE__ */ jsx2(DropdownMenu.Trigger, { asChild: true, children: /* @__PURE__ */ jsxs2(Button, { type: "button", size: "small", variant: "secondary", children: [
+          /* @__PURE__ */ jsx2(Adjustments, {}),
+          "View"
+        ] }) }),
+        /* @__PURE__ */ jsx2(DropdownMenu.Content, { align: "start", children: currencies.map((currency) => /* @__PURE__ */ jsxs2(
+          DropdownMenu.CheckboxItem,
+          {
+            checked: visibleCurrencies.includes(currency.code),
+            onCheckedChange: (checked) => setVisibleCurrencies(
+              (current) => checked ? Array.from(/* @__PURE__ */ new Set([...current, currency.code])) : current.filter((code) => code !== currency.code)
+            ),
+            children: [
+              "Price ",
+              currency.code.toUpperCase()
+            ]
+          },
+          currency.code
+        )) })
+      ] }) }),
+      /* @__PURE__ */ jsx2("div", { className: "flex items-center gap-x-2" })
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "size-full overflow-auto", children: [
+      /* @__PURE__ */ jsxs2(
+        Table,
+        {
+          style: {
+            borderCollapse: "collapse",
+            tableLayout: "fixed",
+            width: "max-content"
+          },
+          children: [
+            /* @__PURE__ */ jsx2(Table.Header, { style: { borderTop: "none" }, children: /* @__PURE__ */ jsxs2(Table.Row, { style: { height: 40 }, children: [
+              /* @__PURE__ */ jsx2(
+                Table.HeaderCell,
+                {
+                  style: {
+                    background: "var(--bg-base)",
+                    borderBottom: "1px solid var(--border-base)",
+                    borderRight: "1px solid var(--border-base)",
+                    height: 40,
+                    left: 0,
+                    maxWidth: 200,
+                    minWidth: 200,
+                    padding: "0 16px",
+                    position: "sticky",
+                    width: 200,
+                    zIndex: 1
+                  },
+                  children: "Coupon Value"
+                }
+              ),
+              shownCurrencies.map((currency) => /* @__PURE__ */ jsx2(
+                Table.HeaderCell,
+                {
+                  style: {
+                    background: "var(--bg-base)",
+                    borderBottom: "1px solid var(--border-base)",
+                    borderRight: "1px solid var(--border-base)",
+                    height: 40,
+                    maxWidth: 200,
+                    minWidth: 200,
+                    padding: "0 16px",
+                    width: 200
+                  },
+                  children: /* @__PURE__ */ jsxs2("div", { className: "flex w-full items-center justify-between gap-3", children: [
+                    /* @__PURE__ */ jsxs2("span", { className: "truncate", title: `Price ${currency.code.toUpperCase()}`, children: [
+                      "Price ",
+                      currency.code.toUpperCase()
+                    ] }),
+                    currency.is_tax_inclusive ? /* @__PURE__ */ jsx2(TaxInclusive, { className: "text-ui-fg-muted shrink-0" }) : /* @__PURE__ */ jsx2(TaxExclusive, { className: "text-ui-fg-muted shrink-0" })
+                  ] })
+                },
+                currency.code
+              ))
+            ] }) }),
+            /* @__PURE__ */ jsx2(Table.Body, { children: /* @__PURE__ */ jsxs2(Table.Row, { className: "bg-ui-bg-subtle", style: { height: 40 }, children: [
+              /* @__PURE__ */ jsx2(
+                Table.Cell,
+                {
+                  style: {
+                    background: "var(--bg-subtle)",
+                    borderBottom: "1px solid var(--border-base)",
+                    borderRight: "1px solid var(--border-base)",
+                    height: 40,
+                    left: 0,
+                    maxWidth: 200,
+                    minWidth: 200,
+                    padding: "0 16px",
+                    position: "sticky",
+                    width: 200,
+                    zIndex: 1
+                  },
+                  children: /* @__PURE__ */ jsx2("span", { className: "block truncate", children: couponValue })
+                }
+              ),
+              shownCurrencies.map((currency) => /* @__PURE__ */ jsx2(
+                Table.Cell,
+                {
+                  style: {
+                    background: "var(--bg-base)",
+                    borderBottom: "1px solid var(--border-base)",
+                    borderRight: "1px solid var(--border-base)",
+                    height: 40,
+                    maxWidth: 200,
+                    minWidth: 200,
+                    padding: 0,
+                    width: 200
+                  },
+                  children: /* @__PURE__ */ jsx2(
+                    TablePriceInput,
+                    {
+                      currency,
+                      value: prices[currency.code] || "",
+                      onChange: (value) => onChange(currency.code, value)
+                    }
+                  )
+                },
+                currency.code
+              ))
+            ] }) })
+          ]
+        }
+      ),
+      !currencies.length && /* @__PURE__ */ jsx2("div", { className: "p-4", children: /* @__PURE__ */ jsx2(Text2, { className: "text-ui-fg-muted", children: "Add a supported currency to the store before setting prices." }) })
+    ] })
+  ] }) });
+}
+function formatCouponValue(coupon, currencies) {
+  if (coupon.type === "amount_off_products" || coupon.type === "amount_off_order") {
+    const defaultCode = currencies.find((currency) => currency.is_default)?.code || currencies[0]?.code;
+    const primary = coupon.amounts.find((row) => row.currency_code === defaultCode) || coupon.amounts[0];
+    const amount = numberOrNull(primary?.amount);
+    if (amount == null) return "\u2014";
+    const additional = Math.max(0, coupon.amounts.length - 1);
+    const formatted = `${amount}${primary.currency_code.toUpperCase()}`;
+    return additional ? `${formatted} +${additional}` : formatted;
+  }
+  if (coupon.type === "percentage_off_product" || coupon.type === "percentage_off_order") {
+    const percentage = numberOrNull(coupon.percentage);
+    if (percentage == null) return "\u2014";
+    return coupon.type === "percentage_off_order" ? `${percentage}% off order` : `${percentage}% off products`;
+  }
+  return coupon.type === "free_shipping" ? "Free shipping" : "Buy X Get Y";
+}
+function TablePriceInput({
+  currency,
+  onChange,
+  value
+}) {
+  const symbol = currency.symbol_native || currency.symbol || currencySymbol(currency.code || "USD");
+  return /* @__PURE__ */ jsxs2(
+    "label",
+    {
+      className: "bg-ui-bg-base hover:bg-ui-bg-subtle focus-within:shadow-borders-interactive-with-active text-ui-fg-base",
+      style: {
+        alignItems: "center",
+        borderRadius: 0,
+        display: "flex",
+        height: 40,
+        margin: 0,
+        overflow: "hidden",
+        width: 200
+      },
+      children: [
+        /* @__PURE__ */ jsx2(
+          "span",
+          {
+            className: "text-ui-fg-muted",
+            "aria-hidden": "true",
+            style: { flex: "0 0 40px", paddingLeft: 16 },
+            children: symbol
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            "aria-label": `Price ${currency.code.toUpperCase()}`,
+            inputMode: "decimal",
+            value,
+            onChange: (event) => onChange(event.target.value),
+            style: {
+              appearance: "none",
+              background: "transparent",
+              border: 0,
+              borderRadius: 0,
+              flex: "1 1 auto",
+              height: "100%",
+              margin: 0,
+              minWidth: 0,
+              outline: "none",
+              padding: "0 16px 0 0",
+              textAlign: "right"
+            },
+            type: "text"
+          }
+        )
+      ]
+    }
+  );
+}
+function CouponProductModal({
+  allowPromotionMirror,
+  apiBase,
+  onOpenChange,
+  onSaved,
+  open,
+  options,
+  row
+}) {
+  const [activeStep, setActiveStep] = useState("details");
+  const [product, setProduct] = useState(
+    () => emptyProduct(options)
+  );
+  const [coupon, setCoupon] = useState(
+    () => emptyCoupon(options)
+  );
+  const [campaign, setCampaign] = useState(emptyCampaign);
+  const [saving, setSaving] = useState(false);
+  const [uploading, setUploading] = useState(false);
+  const [furthestStepIndex, setFurthestStepIndex] = useState(0);
+  const visibleSteps = useMemo(
+    () => allowPromotionMirror ? allSteps : allSteps.filter((step) => step !== "campaign"),
+    [allowPromotionMirror]
+  );
+  const currentStepIndex = visibleSteps.indexOf(activeStep);
+  const currencies = options.currencies || [];
+  const supportedCurrencyCodes = useMemo(
+    () => new Set(currencies.map((currency) => currency.code)),
+    [currencies]
+  );
+  const isAmountType = coupon.type === "amount_off_products" || coupon.type === "amount_off_order";
+  const isPercentageType = coupon.type === "percentage_off_product" || coupon.type === "percentage_off_order";
+  const isItemScopedDiscount = coupon.type === "amount_off_products" || coupon.type === "percentage_off_product";
+  const effectiveCurrencies = useMemo(
+    () => effectiveCouponCurrencies(coupon.purchase_conditions, currencies),
+    [coupon.purchase_conditions, currencies]
+  );
+  const productPrices = currencies.flatMap((currency) => {
+    const value = product.price_amounts[currency.code] || "";
+    const amount = nonNegativeNumberOrNull(value);
+    return amount == null ? [] : [{ currency_code: currency.code, amount }];
+  });
+  useEffect(() => {
+    if (!open) return;
+    const forms = row ? formsFromRow(row, options) : {
+      product: emptyProduct(options),
+      coupon: emptyCoupon(options),
+      campaign: emptyCampaign
+    };
+    setProduct(forms.product);
+    setCoupon(forms.coupon);
+    setCampaign(forms.campaign);
+    setActiveStep("details");
+    setFurthestStepIndex(0);
+  }, [open, row, options]);
+  const updatePurchaseConditions = (purchaseConditions) => {
+    setCoupon((current) => ({
+      ...current,
+      purchase_conditions: purchaseConditions,
+      amounts: isAmountCouponType(current.type) ? reconcileCouponAmounts(
+        current.amounts,
+        effectiveCouponCurrencies(purchaseConditions, currencies)
+      ) : current.amounts
+    }));
+  };
+  const updateCouponType = (type) => {
+    setCoupon((current) => {
+      let purchaseConditions = current.purchase_conditions;
+      if (isAmountCouponType(type) && !purchaseConditions.some(
+        (condition) => condition.attribute === "currency_code"
+      )) {
+        purchaseConditions = [
+          ...purchaseConditions,
+          ...defaultPurchaseConditions(options)
+        ];
+      }
+      return {
+        ...current,
+        type,
+        purchase_conditions: purchaseConditions,
+        amounts: isAmountCouponType(type) ? reconcileCouponAmounts(
+          current.amounts,
+          effectiveCouponCurrencies(purchaseConditions, currencies)
+        ) : current.amounts,
+        promotion_mirror_mode: type === "buy_x_get_y" ? "none" : current.promotion_mirror_mode
+      };
+    });
+  };
+  const uploadMedia = async (files) => {
+    if (!files.length) return;
+    const formData = new FormData();
+    files.forEach((file) => formData.append("files", file));
+    if (apiBase === "/admin" && product.seller_id) {
+      formData.append("seller_id", product.seller_id);
+    }
+    setUploading(true);
+    try {
+      const response = await fetch(
+        `${backendUrl()}${apiBase}/coupon-products/uploads`,
+        {
+          method: "POST",
+          body: formData,
+          credentials: "include"
+        }
+      );
+      if (!response.ok) {
+        const payload2 = await response.json().catch(() => null);
+        throw new Error(apiErrorMessage(payload2, response.statusText));
+      }
+      const payload = await response.json();
+      const uploaded = (payload.files || []).filter(
+        (file) => Boolean(file.asset_id && file.url)
+      ).map((file) => ({ asset_id: file.asset_id, url: file.url }));
+      if (!uploaded.length)
+        throw new Error("The upload did not return an image URL");
+      setProduct((current) => ({
+        ...current,
+        media: Array.from(
+          new Map(
+            [...current.media, ...uploaded].map((item) => [item.url, item])
+          ).values()
+        )
+      }));
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Image upload failed"
+      );
+    } finally {
+      setUploading(false);
+    }
+  };
+  const detailsComplete = useMemo(() => {
+    if (!product.title.trim()) return false;
+    if (!currencies.length) return false;
+    const attributes = /* @__PURE__ */ new Set();
+    for (const condition of coupon.purchase_conditions) {
+      if (!condition.attribute || !condition.operator || !condition.values.length || condition.operator === "eq" && condition.values.length !== 1 || attributes.has(condition.attribute)) {
+        return false;
+      }
+      attributes.add(condition.attribute);
+    }
+    if (isAmountType) {
+      if (!attributes.has("currency_code")) return false;
+      if (!coupon.amounts.length) return false;
+      if (coupon.amounts.length !== effectiveCurrencies.length) return false;
+      const seen = /* @__PURE__ */ new Set();
+      for (const row2 of coupon.amounts) {
+        if (!supportedCurrencyCodes.has(row2.currency_code)) return false;
+        if (seen.has(row2.currency_code)) return false;
+        if (numberOrNull(row2.amount) == null) return false;
+        seen.add(row2.currency_code);
+      }
+    }
+    if (isPercentageType) {
+      const value = numberOrNull(coupon.percentage);
+      if (value == null || value > 100) return false;
+    }
+    if (coupon.code_strategy === "shared_code" && !coupon.shared_code.trim()) {
+      return false;
+    }
+    if (coupon.expiration_type === "duration") {
+      const days = Number(coupon.expiration_days);
+      if (!Number.isInteger(days) || days < 1) return false;
+    } else if (coupon.expiration_type === "fixed") {
+      const expiration = new Date(coupon.expiration_date);
+      if (!coupon.expiration_date || Number.isNaN(expiration.getTime())) {
+        return false;
+      }
+    }
+    if (coupon.expiration_type !== "none" && coupon.expiration_cap_at) {
+      const cap = new Date(coupon.expiration_cap_at);
+      if (Number.isNaN(cap.getTime())) return false;
+    }
+    const maxIssuance = Number(coupon.max_issuance_per_order_item);
+    return Number.isInteger(maxIssuance) && maxIssuance > 0;
+  }, [
+    coupon,
+    currencies.length,
+    effectiveCurrencies.length,
+    isAmountType,
+    isPercentageType,
+    product.title,
+    supportedCurrencyCodes
+  ]);
+  const campaignComplete = useMemo(() => {
+    if (!allowPromotionMirror || campaign.mode === "none") return true;
+    if (campaign.mode === "existing") return Boolean(campaign.campaign_id);
+    if (!campaign.name.trim() || !campaign.campaign_identifier.trim()) {
+      return false;
+    }
+    return [campaign.starts_at, campaign.ends_at].every((value) => {
+      if (!value) return true;
+      return !Number.isNaN(new Date(value).getTime());
+    });
+  }, [allowPromotionMirror, campaign]);
+  const pricesComplete = useMemo(() => {
+    if (!currencies.length || !productPrices.length) return false;
+    return currencies.every((currency) => {
+      const value = product.price_amounts[currency.code] || "";
+      return !value.trim() || nonNegativeNumberOrNull(value) != null;
+    });
+  }, [currencies, product.price_amounts, productPrices.length]);
+  const stepValidity = useMemo(
+    () => ({
+      details: detailsComplete,
+      organize: true,
+      campaign: campaignComplete,
+      prices: pricesComplete
+    }),
+    [campaignComplete, detailsComplete, pricesComplete]
+  );
+  const activeStepComplete = stepValidity[activeStep];
+  useEffect(() => {
+    if (!open || !activeStepComplete) return;
+    setFurthestStepIndex(
+      (current) => Math.max(
+        current,
+        Math.min(currentStepIndex + 1, visibleSteps.length - 1)
+      )
+    );
+  }, [activeStepComplete, currentStepIndex, open, visibleSteps.length]);
+  const isStepDisabled = (index) => index > furthestStepIndex || visibleSteps.slice(0, index).some((previous) => !stepValidity[previous]);
+  const validate = () => {
+    if (!product.title.trim()) throw new Error("Product title is required");
+    if (!currencies.length) {
+      throw new Error("Add a supported currency to the store before continuing");
+    }
+    const invalidPrice = currencies.some((currency) => {
+      const value = product.price_amounts[currency.code] || "";
+      return value.trim() && nonNegativeNumberOrNull(value) == null;
+    });
+    if (invalidPrice) {
+      throw new Error("Product prices must be 0 or more");
+    }
+    if (!productPrices.length) {
+      throw new Error("Add at least one product price");
+    }
+    if (isAmountType) {
+      if (!coupon.amounts.length) {
+        throw new Error("Add at least one coupon value");
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const currencyCondition = coupon.purchase_conditions.find(
+        (condition) => condition.attribute === "currency_code"
+      );
+      if (!currencyCondition) {
+        throw new Error("Add a Currency Code purchase condition");
+      }
+      if (coupon.amounts.length !== effectiveCurrencies.length) {
+        throw new Error(
+          "Coupon values must match every effective currency condition value"
+        );
+      }
+      for (const row2 of coupon.amounts) {
+        if (!supportedCurrencyCodes.has(row2.currency_code)) {
+          throw new Error("Select an available coupon currency");
+        }
+        if (seen.has(row2.currency_code)) {
+          throw new Error("Coupon value currencies cannot be duplicated");
+        }
+        if (numberOrNull(row2.amount) == null) {
+          throw new Error("Coupon values must be greater than 0");
+        }
+        seen.add(row2.currency_code);
+      }
+    }
+    const seenAttributes = /* @__PURE__ */ new Set();
+    for (const condition of coupon.purchase_conditions) {
+      if (!condition.attribute || !condition.operator) {
+        throw new Error("Complete every purchase condition");
+      }
+      if (!condition.values.length) {
+        throw new Error("Select at least one value for every purchase condition");
+      }
+      if (condition.operator === "eq" && condition.values.length !== 1) {
+        throw new Error("Equals conditions require exactly one value");
+      }
+      if (seenAttributes.has(condition.attribute)) {
+        throw new Error("Purchase condition attributes cannot be duplicated");
+      }
+      seenAttributes.add(condition.attribute);
+    }
+    if (isPercentageType) {
+      const value = numberOrNull(coupon.percentage);
+      if (value == null || value > 100) {
+        throw new Error("Coupon value must be between 1 and 100 percent");
+      }
+    }
+    if (coupon.code_strategy === "shared_code" && !coupon.shared_code.trim()) {
+      throw new Error("A shared coupon code is required");
+    }
+    if (coupon.expiration_type === "fixed") {
+      const expiration = new Date(coupon.expiration_date);
+      if (!coupon.expiration_date || Number.isNaN(expiration.getTime())) {
+        throw new Error("A valid fixed expiration date is required");
+      }
+    }
+    if (coupon.expiration_type !== "none" && coupon.expiration_cap_at) {
+      const cap = new Date(coupon.expiration_cap_at);
+      if (Number.isNaN(cap.getTime())) {
+        throw new Error("A valid expiration cap date is required");
+      }
+    }
+    if (campaign.mode === "existing" && !campaign.campaign_id) {
+      throw new Error("Select an existing campaign");
+    }
+    if (campaign.mode === "new" && (!campaign.name.trim() || !campaign.campaign_identifier.trim())) {
+      throw new Error("Campaign name and identifier are required");
+    }
+  };
+  const save = async () => {
+    setSaving(true);
+    try {
+      validate();
+      const benefitType = benefitTypeFromCouponType(coupon.type);
+      const targetType = coupon.type === "amount_off_order" || coupon.type === "percentage_off_order" ? "order" : "items";
+      const payload = {
+        product: {
+          title: product.title.trim(),
+          subtitle: product.subtitle.trim() || null,
+          handle: product.handle.trim() || null,
+          description: product.description.trim() || null,
+          status: productStatusFromCouponStatus(coupon.promotion_status),
+          thumbnail: product.media[0]?.url || null,
+          thumbnail_asset_id: product.media[0]?.asset_id || null,
+          images: product.media.slice(1).map((media) => ({
+            url: media.url,
+            ...media.asset_id ? { asset_id: media.asset_id } : {}
+          })),
+          discountable: product.discountable,
+          type_id: product.type_id || null,
+          collection_id: product.collection_id || null,
+          categories: product.category_id ? [{ id: product.category_id }] : [],
+          tags: product.tag_id ? [{ id: product.tag_id }] : [],
+          variants: [
+            {
+              title: "Default",
+              sku: product.sku.trim() || null,
+              manage_inventory: false,
+              allow_backorder: true,
+              prices: productPrices
+            }
+          ]
+        },
+        coupon: {
+          enabled: coupon.enabled,
+          benefit_type: benefitType,
+          purchase_conditions: coupon.purchase_conditions.map((condition) => ({
+            attribute: condition.attribute,
+            operator: condition.operator,
+            values: condition.values
+          })),
+          amounts: isAmountType ? coupon.amounts.map((row2) => ({
+            amount: numberOrNull(row2.amount),
+            currency_code: row2.currency_code
+          })) : null,
+          amount: null,
+          percentage: isPercentageType ? numberOrNull(coupon.percentage) : null,
+          currency_code: null,
+          code_strategy: coupon.code_strategy,
+          code_prefix: coupon.code_strategy === "unique_code" ? coupon.code_prefix.trim() || "COUPON" : null,
+          shared_code: coupon.code_strategy === "shared_code" ? coupon.shared_code.trim() : null,
+          expiration_policy: coupon.expiration_type === "none" ? { type: "none" } : coupon.expiration_type === "fixed" ? {
+            type: "fixed",
+            expires_at: new Date(coupon.expiration_date).toISOString(),
+            cap_by_campaign: coupon.expiration_cap_by_campaign,
+            cap_at: coupon.expiration_cap_at ? new Date(coupon.expiration_cap_at).toISOString() : null
+          } : {
+            type: "duration",
+            duration_days: Number(coupon.expiration_days) || 30,
+            cap_by_campaign: coupon.expiration_cap_by_campaign,
+            cap_at: coupon.expiration_cap_at ? new Date(coupon.expiration_cap_at).toISOString() : null
+          },
+          max_issuance_per_order_item: Number(coupon.max_issuance_per_order_item) || 1,
+          promotion_template: benefitType === "fixed_amount" || benefitType === "percentage" ? {
+            application_method: {
+              target_type: targetType,
+              allocation: targetType === "order" ? "across" : coupon.allocation
+            }
+          } : null,
+          promotion_status: coupon.promotion_status,
+          ...allowPromotionMirror ? {
+            promotion_mirror_mode: benefitType === "buy_get" || benefitType === "fixed_amount" && coupon.amounts.length > 1 ? "none" : coupon.promotion_mirror_mode
+          } : {}
+        },
+        campaign: allowPromotionMirror ? campaign.mode === "existing" ? { mode: "existing", campaign_id: campaign.campaign_id } : campaign.mode === "new" ? {
+          mode: "new",
+          campaign: {
+            name: campaign.name,
+            campaign_identifier: campaign.campaign_identifier,
+            starts_at: campaign.starts_at ? new Date(campaign.starts_at).toISOString() : null,
+            ends_at: campaign.ends_at ? new Date(campaign.ends_at).toISOString() : null
+          }
+        } : { mode: "none" } : void 0,
+        seller_id: product.seller_id || null,
+        variant_overrides: []
+      };
+      await apiFetch(
+        row ? `${apiBase}/coupon-products/${row.product.id}` : `${apiBase}/coupon-products`,
+        {
+          method: row ? "PATCH" : "POST",
+          body: JSON.stringify(payload)
+        }
+      );
+      toast.success(row ? "Coupon product updated" : "Coupon product created");
+      onOpenChange(false);
+      await onSaved();
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Failed to save coupon product"
+      );
+    } finally {
+      setSaving(false);
+    }
+  };
+  const stepStatus = (step) => {
+    const index = visibleSteps.indexOf(step);
+    if (index < currentStepIndex && stepValidity[step]) {
+      return "completed";
+    }
+    if (index === currentStepIndex) return "in-progress";
+    return "not-started";
+  };
+  return /* @__PURE__ */ jsx2(FocusModal, { open, onOpenChange, children: /* @__PURE__ */ jsxs2(FocusModal.Content, { style: modalContentStyle, children: [
+    /* @__PURE__ */ jsx2(FocusModal.Title, { style: visuallyHiddenStyle, children: row ? "Edit Coupon Product" : "Create Coupon Product" }),
+    /* @__PURE__ */ jsxs2(
+      ProgressTabs,
+      {
+        value: activeStep,
+        onValueChange: (value) => {
+          const step = value;
+          const index = visibleSteps.indexOf(step);
+          if (!isStepDisabled(index)) setActiveStep(step);
+        },
+        style: modalWizardStyle,
+        children: [
+          /* @__PURE__ */ jsx2(FocusModal.Header, { children: /* @__PURE__ */ jsx2("div", { className: "-my-2 w-full border-l", children: /* @__PURE__ */ jsx2(ProgressTabs.List, { className: "justify-start-start flex w-full items-center", children: visibleSteps.map((step, index) => /* @__PURE__ */ jsx2(
+            ProgressTabs.Trigger,
+            {
+              value: step,
+              status: stepStatus(step),
+              disabled: isStepDisabled(index),
+              className: "max-w-[200px] truncate",
+              children: step[0].toUpperCase() + step.slice(1)
+            },
+            step
+          )) }) }) }),
+          /* @__PURE__ */ jsx2(FocusModal.Body, { className: "overflow-hidden p-0", style: modalBodyStyle, children: /* @__PURE__ */ jsx2(
+            "div",
+            {
+              style: activeStep === "prices" ? { height: "100%", overflow: "hidden", width: "100%" } : modalScrollStyle,
+              children: /* @__PURE__ */ jsxs2(
+                "div",
+                {
+                  style: activeStep === "prices" ? { height: "100%", width: "100%" } : modalFormStyle,
+                  children: [
+                    activeStep === "details" && /* @__PURE__ */ jsxs2(ProgressTabs.Content, { value: "details", style: stackStyle, children: [
+                      /* @__PURE__ */ jsx2(Heading, { level: "h1", children: row ? "Edit Coupon Product" : "Create Coupon Product" }),
+                      /* @__PURE__ */ jsx2(Divider, {}),
+                      /* @__PURE__ */ jsxs2(Section, { title: "General", children: [
+                        /* @__PURE__ */ jsxs2("div", { style: threeColumnGridStyle, children: [
+                          /* @__PURE__ */ jsx2(Field, { label: "Title", children: /* @__PURE__ */ jsx2(
+                            Input,
+                            {
+                              value: product.title,
+                              placeholder: "Winter jacket",
+                              onChange: (event) => setProduct((current) => ({
+                                ...current,
+                                title: event.target.value
+                              }))
+                            }
+                          ) }),
+                          /* @__PURE__ */ jsx2(Field, { label: "Subtitle", optional: true, children: /* @__PURE__ */ jsx2(
+                            Input,
+                            {
+                              value: product.subtitle,
+                              placeholder: "Warm and cozy",
+                              onChange: (event) => setProduct((current) => ({
+                                ...current,
+                                subtitle: event.target.value
+                              }))
+                            }
+                          ) }),
+                          /* @__PURE__ */ jsx2(
+                            Field,
+                            {
+                              label: "Handle",
+                              optional: true,
+                              tooltip: "The URL-friendly identifier for this product. If left empty, Medusa generates it from the title.",
+                              children: /* @__PURE__ */ jsx2(
+                                HandleInput,
+                                {
+                                  value: product.handle,
+                                  onChange: (handle) => setProduct((current) => ({ ...current, handle }))
+                                }
+                              )
+                            }
+                          )
+                        ] }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Description", optional: true, children: /* @__PURE__ */ jsx2(
+                          Textarea,
+                          {
+                            value: product.description,
+                            placeholder: "A warm and cozy jacket",
+                            onChange: (event) => setProduct((current) => ({
+                              ...current,
+                              description: event.target.value
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Media", optional: true, children: /* @__PURE__ */ jsx2(
+                          MediaUpload,
+                          {
+                            isUploading: uploading,
+                            media: product.media,
+                            onUpload: (files) => void uploadMedia(files),
+                            onRemove: (media) => setProduct((current) => ({
+                              ...current,
+                              media: current.media.filter(
+                                (item) => media.asset_id && item.asset_id !== media.asset_id || !media.asset_id && item.url !== media.url
+                              )
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "SKU", optional: true, children: /* @__PURE__ */ jsx2(
+                          Input,
+                          {
+                            value: product.sku,
+                            placeholder: "COUPON-001",
+                            onChange: (event) => setProduct((current) => ({
+                              ...current,
+                              sku: event.target.value
+                            }))
+                          }
+                        ) })
+                      ] }),
+                      /* @__PURE__ */ jsx2(Divider, {}),
+                      /* @__PURE__ */ jsx2(
+                        PurchaseConditionsField,
+                        {
+                          fixedAmount: isAmountType,
+                          options,
+                          value: coupon.purchase_conditions,
+                          onChange: updatePurchaseConditions
+                        }
+                      )
+                    ] }),
+                    activeStep === "organize" && /* @__PURE__ */ jsx2(ProgressTabs.Content, { value: "organize", style: stackStyle, children: /* @__PURE__ */ jsxs2(Section, { title: "Organize", children: [
+                      /* @__PURE__ */ jsx2("div", { style: panelStyle, children: /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between gap-x-4", children: [
+                        /* @__PURE__ */ jsxs2("div", { children: [
+                          /* @__PURE__ */ jsx2(Text2, { weight: "plus", children: "Discountable" }),
+                          /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: "Allow promotions to discount this product's sale price." })
+                        ] }),
+                        /* @__PURE__ */ jsx2(
+                          Switch,
+                          {
+                            checked: product.discountable,
+                            onCheckedChange: (discountable) => setProduct((current) => ({
+                              ...current,
+                              discountable: Boolean(discountable)
+                            }))
+                          }
+                        )
+                      ] }) }),
+                      /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                        allowPromotionMirror && /* @__PURE__ */ jsx2(Field, { label: "Seller", optional: true, children: /* @__PURE__ */ jsx2(
+                          OptionSelect,
+                          {
+                            value: product.seller_id,
+                            options: options.sellers || [],
+                            onChange: (seller_id) => setProduct((current) => ({ ...current, seller_id }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Type", optional: true, children: /* @__PURE__ */ jsx2(
+                          OptionSelect,
+                          {
+                            value: product.type_id,
+                            options: options.product_types || [],
+                            onChange: (type_id) => setProduct((current) => ({ ...current, type_id }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Collection", optional: true, children: /* @__PURE__ */ jsx2(
+                          OptionSelect,
+                          {
+                            value: product.collection_id,
+                            options: options.product_collections || [],
+                            onChange: (collection_id) => setProduct((current) => ({
+                              ...current,
+                              collection_id
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Category", optional: true, children: /* @__PURE__ */ jsx2(
+                          OptionSelect,
+                          {
+                            value: product.category_id,
+                            options: options.product_categories || [],
+                            onChange: (category_id) => setProduct((current) => ({ ...current, category_id }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Tag", optional: true, children: /* @__PURE__ */ jsx2(
+                          OptionSelect,
+                          {
+                            value: product.tag_id,
+                            options: options.product_tags || [],
+                            onChange: (tag_id) => setProduct((current) => ({ ...current, tag_id }))
+                          }
+                        ) })
+                      ] })
+                    ] }) }),
+                    activeStep === "details" && /* @__PURE__ */ jsxs2("div", { style: { ...stackStyle, marginTop: 24 }, children: [
+                      /* @__PURE__ */ jsx2(Divider, {}),
+                      /* @__PURE__ */ jsxs2(
+                        Section,
+                        {
+                          title: "Coupon",
+                          description: "Configure the coupon issued when this product is purchased.",
+                          children: [
+                            /* @__PURE__ */ jsx2("div", { style: panelStyle, children: /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between gap-x-4", children: [
+                              /* @__PURE__ */ jsxs2("div", { children: [
+                                /* @__PURE__ */ jsx2(Text2, { weight: "plus", children: "Coupon issuance" }),
+                                /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: "Issue coupons when customers purchase this product." })
+                              ] }),
+                              /* @__PURE__ */ jsx2(
+                                Switch,
+                                {
+                                  checked: coupon.enabled,
+                                  onCheckedChange: (enabled) => setCoupon((current) => ({
+                                    ...current,
+                                    enabled: Boolean(enabled)
+                                  }))
+                                }
+                              )
+                            ] }) }),
+                            /* @__PURE__ */ jsx2(Section, { title: "Type", children: /* @__PURE__ */ jsx2(
+                              RadioGroup,
+                              {
+                                value: coupon.type,
+                                onValueChange: (type) => updateCouponType(type),
+                                className: "flex flex-col gap-y-3",
+                                children: typeChoices.map((choice) => /* @__PURE__ */ jsx2(
+                                  RadioGroup.ChoiceBox,
+                                  {
+                                    value: choice.value,
+                                    label: choice.label,
+                                    description: choice.description
+                                  },
+                                  choice.value
+                                ))
+                              }
+                            ) }),
+                            /* @__PURE__ */ jsx2(Section, { title: "Status", children: /* @__PURE__ */ jsx2(
+                              RadioGroup,
+                              {
+                                value: coupon.promotion_status,
+                                onValueChange: (promotion_status) => setCoupon((current) => ({
+                                  ...current,
+                                  promotion_status
+                                })),
+                                style: twoColumnGridStyle,
+                                children: statusChoices.map((choice) => /* @__PURE__ */ jsx2(
+                                  RadioGroup.ChoiceBox,
+                                  {
+                                    value: choice.value,
+                                    label: choice.label,
+                                    description: choice.description
+                                  },
+                                  choice.value
+                                ))
+                              }
+                            ) }),
+                            (isAmountType || isPercentageType) && /* @__PURE__ */ jsx2(Section, { title: isAmountType ? "Coupon Values" : "Value", children: isAmountType ? /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-y-2", children: [
+                              coupon.amounts.map((row2, rowIndex) => {
+                                const currency = currencies.find(
+                                  (item) => item.code === row2.currency_code
+                                );
+                                return /* @__PURE__ */ jsx2(
+                                  "div",
+                                  {
+                                    className: "shadow-elevation-card-rest bg-ui-bg-component rounded-md px-4 py-3",
+                                    children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-y-2", children: [
+                                      /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between", children: [
+                                        /* @__PURE__ */ jsxs2(Label, { children: [
+                                          row2.currency_code.toUpperCase(),
+                                          " Coupon Value"
+                                        ] }),
+                                        /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: currency?.name || row2.currency_code.toUpperCase() })
+                                      ] }),
+                                      /* @__PURE__ */ jsx2("div", { children: /* @__PURE__ */ jsx2(
+                                        CurrencyAmountField,
+                                        {
+                                          currencies,
+                                          currencyCode: row2.currency_code,
+                                          value: row2.amount,
+                                          onChange: (amount) => setCoupon((current) => ({
+                                            ...current,
+                                            amounts: current.amounts.map(
+                                              (item, index) => index === rowIndex ? { ...item, amount } : item
+                                            )
+                                          }))
+                                        }
+                                      ) })
+                                    ] })
+                                  },
+                                  row2.key
+                                );
+                              }),
+                              !coupon.amounts.length && /* @__PURE__ */ jsx2(Text2, { className: "text-ui-fg-muted", children: "Select at least one effective Currency Code condition value." })
+                            ] }) : /* @__PURE__ */ jsx2(Field, { label: "Coupon Value", children: /* @__PURE__ */ jsx2(
+                              PercentageInput,
+                              {
+                                value: coupon.percentage,
+                                onChange: (percentage) => setCoupon((current) => ({
+                                  ...current,
+                                  percentage
+                                }))
+                              }
+                            ) }) }),
+                            isItemScopedDiscount && /* @__PURE__ */ jsx2(Section, { title: "Allocation", children: /* @__PURE__ */ jsxs2(
+                              RadioGroup,
+                              {
+                                value: coupon.allocation,
+                                onValueChange: (allocation) => setCoupon((current) => ({
+                                  ...current,
+                                  allocation
+                                })),
+                                style: twoColumnGridStyle,
+                                children: [
+                                  /* @__PURE__ */ jsx2(
+                                    RadioGroup.ChoiceBox,
+                                    {
+                                      value: "each",
+                                      label: "Each",
+                                      description: "Applies value on each item"
+                                    }
+                                  ),
+                                  /* @__PURE__ */ jsx2(
+                                    RadioGroup.ChoiceBox,
+                                    {
+                                      value: "once",
+                                      label: "Once",
+                                      description: "Limit discount to max quantity"
+                                    }
+                                  )
+                                ]
+                              }
+                            ) }),
+                            /* @__PURE__ */ jsx2(
+                              Section,
+                              {
+                                title: "Expiration",
+                                description: "Control when issued coupons expire.",
+                                children: /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                                  /* @__PURE__ */ jsx2(Field, { label: "Expiration policy", children: /* @__PURE__ */ jsxs2(
+                                    Select,
+                                    {
+                                      value: coupon.expiration_type,
+                                      onValueChange: (expiration_type) => setCoupon((current) => ({
+                                        ...current,
+                                        expiration_type
+                                      })),
+                                      children: [
+                                        /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, {}) }),
+                                        /* @__PURE__ */ jsxs2(Select.Content, { children: [
+                                          /* @__PURE__ */ jsx2(Select.Item, { value: "none", children: "None" }),
+                                          /* @__PURE__ */ jsx2(Select.Item, { value: "duration", children: "Duration after issue" }),
+                                          /* @__PURE__ */ jsx2(Select.Item, { value: "fixed", children: "Fixed date" })
+                                        ] })
+                                      ]
+                                    }
+                                  ) }),
+                                  coupon.expiration_type === "duration" ? /* @__PURE__ */ jsx2(Field, { label: "Expiration days", children: /* @__PURE__ */ jsx2(
+                                    Input,
+                                    {
+                                      type: "number",
+                                      min: 1,
+                                      value: coupon.expiration_days,
+                                      onChange: (event) => setCoupon((current) => ({
+                                        ...current,
+                                        expiration_days: event.target.value
+                                      }))
+                                    }
+                                  ) }) : coupon.expiration_type === "fixed" ? /* @__PURE__ */ jsx2(Field, { label: "Expires at", children: /* @__PURE__ */ jsx2(
+                                    Input,
+                                    {
+                                      type: "datetime-local",
+                                      value: coupon.expiration_date,
+                                      onChange: (event) => setCoupon((current) => ({
+                                        ...current,
+                                        expiration_date: event.target.value
+                                      }))
+                                    }
+                                  ) }) : null,
+                                  coupon.expiration_type !== "none" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+                                    /* @__PURE__ */ jsx2(Field, { label: "Cap expiration", children: /* @__PURE__ */ jsxs2(
+                                      "div",
+                                      {
+                                        className: "flex items-center justify-between gap-x-4",
+                                        style: { ...panelStyle, padding: "8px 12px" },
+                                        children: [
+                                          /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: "Campaign end or cap date" }),
+                                          /* @__PURE__ */ jsx2(
+                                            Switch,
+                                            {
+                                              checked: coupon.expiration_cap_by_campaign,
+                                              onCheckedChange: (expiration_cap_by_campaign) => setCoupon((current) => ({
+                                                ...current,
+                                                expiration_cap_by_campaign: Boolean(
+                                                  expiration_cap_by_campaign
+                                                )
+                                              }))
+                                            }
+                                          )
+                                        ]
+                                      }
+                                    ) }),
+                                    /* @__PURE__ */ jsx2(Field, { label: "Expiration cap date", optional: true, children: /* @__PURE__ */ jsx2(
+                                      Input,
+                                      {
+                                        type: "datetime-local",
+                                        disabled: !coupon.expiration_cap_by_campaign,
+                                        value: coupon.expiration_cap_at,
+                                        onChange: (event) => setCoupon((current) => ({
+                                          ...current,
+                                          expiration_cap_at: event.target.value
+                                        }))
+                                      }
+                                    ) })
+                                  ] })
+                                ] })
+                              }
+                            ),
+                            /* @__PURE__ */ jsx2(
+                              Section,
+                              {
+                                title: "Code",
+                                description: "Choose whether every issued coupon is unique or shares one code.",
+                                children: /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                                  /* @__PURE__ */ jsx2(Field, { label: "Code strategy", children: /* @__PURE__ */ jsxs2(
+                                    Select,
+                                    {
+                                      value: coupon.code_strategy,
+                                      onValueChange: (code_strategy) => setCoupon((current) => ({
+                                        ...current,
+                                        code_strategy
+                                      })),
+                                      children: [
+                                        /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, {}) }),
+                                        /* @__PURE__ */ jsxs2(Select.Content, { children: [
+                                          /* @__PURE__ */ jsx2(Select.Item, { value: "unique_code", children: "Unique code" }),
+                                          /* @__PURE__ */ jsx2(Select.Item, { value: "shared_code", children: "Shared code" })
+                                        ] })
+                                      ]
+                                    }
+                                  ) }),
+                                  coupon.code_strategy === "unique_code" ? /* @__PURE__ */ jsx2(Field, { label: "Code prefix", optional: true, children: /* @__PURE__ */ jsx2(
+                                    Input,
+                                    {
+                                      value: coupon.code_prefix,
+                                      placeholder: "COUPON",
+                                      onChange: (event) => setCoupon((current) => ({
+                                        ...current,
+                                        code_prefix: event.target.value
+                                      }))
+                                    }
+                                  ) }) : /* @__PURE__ */ jsx2(Field, { label: "Shared code", children: /* @__PURE__ */ jsx2(
+                                    Input,
+                                    {
+                                      value: coupon.shared_code,
+                                      placeholder: "SUMMER15",
+                                      onChange: (event) => setCoupon((current) => ({
+                                        ...current,
+                                        shared_code: event.target.value
+                                      }))
+                                    }
+                                  ) })
+                                ] })
+                              }
+                            ),
+                            /* @__PURE__ */ jsx2(Section, { title: "Issuance", children: /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                              /* @__PURE__ */ jsx2(Field, { label: "Max issuance per item", children: /* @__PURE__ */ jsx2(
+                                Input,
+                                {
+                                  type: "number",
+                                  min: 1,
+                                  value: coupon.max_issuance_per_order_item,
+                                  onChange: (event) => setCoupon((current) => ({
+                                    ...current,
+                                    max_issuance_per_order_item: event.target.value
+                                  }))
+                                }
+                              ) }),
+                              allowPromotionMirror && !(isAmountType && coupon.amounts.length > 1) && /* @__PURE__ */ jsx2(Field, { label: "Promotion mirror", children: /* @__PURE__ */ jsxs2(
+                                Select,
+                                {
+                                  value: coupon.promotion_mirror_mode,
+                                  disabled: coupon.type === "buy_x_get_y",
+                                  onValueChange: (promotion_mirror_mode) => setCoupon((current) => ({
+                                    ...current,
+                                    promotion_mirror_mode
+                                  })),
+                                  children: [
+                                    /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, {}) }),
+                                    /* @__PURE__ */ jsxs2(Select.Content, { children: [
+                                      /* @__PURE__ */ jsx2(Select.Item, { value: "none", children: "None" }),
+                                      /* @__PURE__ */ jsx2(Select.Item, { value: "manual", children: "Manual" }),
+                                      /* @__PURE__ */ jsx2(Select.Item, { value: "auto", children: "Auto" })
+                                    ] })
+                                  ]
+                                }
+                              ) })
+                            ] }) })
+                          ]
+                        }
+                      )
+                    ] }),
+                    allowPromotionMirror && activeStep === "campaign" && /* @__PURE__ */ jsx2(ProgressTabs.Content, { value: "campaign", style: stackStyle, children: /* @__PURE__ */ jsx2(Section, { title: "Campaign", children: /* @__PURE__ */ jsxs2("div", { style: twoColumnGridStyle, children: [
+                      /* @__PURE__ */ jsx2(Field, { label: "Campaign mode", children: /* @__PURE__ */ jsxs2(
+                        Select,
+                        {
+                          value: campaign.mode,
+                          onValueChange: (mode) => setCampaign((current) => ({
+                            ...current,
+                            mode
+                          })),
+                          children: [
+                            /* @__PURE__ */ jsx2(Select.Trigger, { children: /* @__PURE__ */ jsx2(Select.Value, {}) }),
+                            /* @__PURE__ */ jsxs2(Select.Content, { children: [
+                              /* @__PURE__ */ jsx2(Select.Item, { value: "none", children: "No campaign" }),
+                              /* @__PURE__ */ jsx2(Select.Item, { value: "existing", children: "Existing campaign" }),
+                              /* @__PURE__ */ jsx2(Select.Item, { value: "new", children: "New campaign" })
+                            ] })
+                          ]
+                        }
+                      ) }),
+                      campaign.mode === "existing" && /* @__PURE__ */ jsx2(Field, { label: "Existing campaign", children: /* @__PURE__ */ jsx2(
+                        OptionSelect,
+                        {
+                          value: campaign.campaign_id,
+                          options: options.campaigns || [],
+                          onChange: (campaign_id) => setCampaign((current) => ({
+                            ...current,
+                            campaign_id
+                          }))
+                        }
+                      ) }),
+                      campaign.mode === "new" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+                        /* @__PURE__ */ jsx2(Field, { label: "Name", children: /* @__PURE__ */ jsx2(
+                          Input,
+                          {
+                            value: campaign.name,
+                            onChange: (event) => setCampaign((current) => ({
+                              ...current,
+                              name: event.target.value
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Identifier", children: /* @__PURE__ */ jsx2(
+                          Input,
+                          {
+                            value: campaign.campaign_identifier,
+                            onChange: (event) => setCampaign((current) => ({
+                              ...current,
+                              campaign_identifier: event.target.value
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Starts at", optional: true, children: /* @__PURE__ */ jsx2(
+                          Input,
+                          {
+                            type: "datetime-local",
+                            value: campaign.starts_at,
+                            onChange: (event) => setCampaign((current) => ({
+                              ...current,
+                              starts_at: event.target.value
+                            }))
+                          }
+                        ) }),
+                        /* @__PURE__ */ jsx2(Field, { label: "Ends at", optional: true, children: /* @__PURE__ */ jsx2(
+                          Input,
+                          {
+                            type: "datetime-local",
+                            value: campaign.ends_at,
+                            onChange: (event) => setCampaign((current) => ({
+                              ...current,
+                              ends_at: event.target.value
+                            }))
+                          }
+                        ) })
+                      ] })
+                    ] }) }) }),
+                    activeStep === "prices" && /* @__PURE__ */ jsx2(ProgressTabs.Content, { value: "prices", style: { height: "100%" }, children: /* @__PURE__ */ jsx2(
+                      ProductPricesTable,
+                      {
+                        currencies,
+                        couponValue: formatCouponValue(coupon, currencies),
+                        prices: product.price_amounts,
+                        onChange: (currencyCode, value) => setProduct((current) => ({
+                          ...current,
+                          price_amounts: {
+                            ...current.price_amounts,
+                            [currencyCode]: value
+                          }
+                        }))
+                      }
+                    ) })
+                  ]
+                }
+              )
+            }
+          ) }),
+          /* @__PURE__ */ jsxs2(FocusModal.Footer, { style: { flexShrink: 0 }, children: [
+            /* @__PURE__ */ jsx2(Button, { variant: "secondary", onClick: () => onOpenChange(false), children: "Cancel" }),
+            currentStepIndex > 0 && /* @__PURE__ */ jsx2(
+              Button,
+              {
+                variant: "secondary",
+                onClick: () => setActiveStep(visibleSteps[currentStepIndex - 1]),
+                children: "Back"
+              }
+            ),
+            currentStepIndex < visibleSteps.length - 1 ? /* @__PURE__ */ jsx2(
+              Button,
+              {
+                disabled: !activeStepComplete,
+                onClick: () => {
+                  const nextIndex = currentStepIndex + 1;
+                  setFurthestStepIndex(
+                    (current) => Math.max(current, nextIndex)
+                  );
+                  setActiveStep(visibleSteps[nextIndex]);
+                },
+                children: "Continue"
+              }
+            ) : /* @__PURE__ */ jsx2(
+              Button,
+              {
+                disabled: !activeStepComplete,
+                isLoading: saving,
+                onClick: () => void save(),
+                children: "Save"
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] }) });
+}
+function CouponProductsPage({
+  allowPromotionMirror = false,
+  apiBase,
+  title
+}) {
+  const [products, setProducts] = useState([]);
+  const [options, setOptions] = useState({});
+  const [loading, setLoading] = useState(true);
+  const [loadError, setLoadError] = useState(null);
+  const [modalOpen, setModalOpen] = useState(false);
+  const [editingRow, setEditingRow] = useState(null);
+  const prompt = usePrompt();
+  const couponBase = `${apiBase}/coupon-products`;
+  const load = useCallback(async () => {
+    setLoading(true);
+    setLoadError(null);
+    try {
+      const [productsPayload, optionsPayload] = await Promise.all([
+        apiFetch(couponBase),
+        apiFetch(`${couponBase}/options`)
+      ]);
+      setProducts(productsPayload.coupon_products || []);
+      setOptions(optionsPayload || {});
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to load coupon products";
+      setLoadError(message);
+      toast.error(message);
+    } finally {
+      setLoading(false);
+    }
+  }, [couponBase]);
+  useEffect(() => {
+    void load();
+  }, [load]);
+  const remove = async (row) => {
+    const confirmed = await prompt({
+      title: "Remove coupon product?",
+      description: `This removes coupon issuance from ${row.product.title || row.product.id}. The underlying Medusa product will remain available.`,
+      confirmText: "Remove product",
+      cancelText: "Cancel",
+      variant: "danger"
+    });
+    if (!confirmed) return;
+    try {
+      await apiFetch(`${couponBase}/${row.product.id}`, { method: "DELETE" });
+      toast.success("Coupon configuration removed");
+      await load();
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Delete failed");
+    }
+  };
+  const mirror = async (row) => {
+    try {
+      await apiFetch(
+        `/admin/coupon-products/${row.product.id}/mirror-promotion`,
+        {
+          method: "POST",
+          body: JSON.stringify({})
+        }
+      );
+      toast.success("Promotion mirror created");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Mirror failed");
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Container, { className: "divide-y p-0", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between px-6 py-4", children: [
+      /* @__PURE__ */ jsx2(Heading, { level: "h1", children: title }),
+      /* @__PURE__ */ jsxs2("div", { className: "flex items-center gap-x-2", children: [
+        /* @__PURE__ */ jsxs2(Button, { size: "small", variant: "secondary", onClick: () => void load(), children: [
+          /* @__PURE__ */ jsx2(ArrowPath, {}),
+          " Refresh"
+        ] }),
+        /* @__PURE__ */ jsxs2(
+          Button,
+          {
+            size: "small",
+            onClick: () => {
+              setEditingRow(null);
+              setModalOpen(true);
+            },
+            children: [
+              /* @__PURE__ */ jsx2(Plus, {}),
+              " Create"
+            ]
+          }
+        )
+      ] })
+    ] }),
+    loading ? /* @__PURE__ */ jsx2(CouponEmptyState, { title: "Loading coupon products" }) : loadError ? /* @__PURE__ */ jsx2(CouponEmptyState, { title: loadError }) : products.length ? /* @__PURE__ */ jsxs2(Table, { children: [
+      /* @__PURE__ */ jsx2(Table.Header, { children: /* @__PURE__ */ jsxs2(Table.Row, { children: [
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Product" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Status" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Type" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Code" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Campaign" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, { children: "Issued" }),
+        /* @__PURE__ */ jsx2(Table.HeaderCell, {})
+      ] }) }),
+      /* @__PURE__ */ jsx2(
+        Table.Body,
+        {
+          style: { borderBottom: "none" },
+          children: products.map((row) => {
+            const config3 = row.coupon_product_config;
+            return /* @__PURE__ */ jsxs2(
+              Table.Row,
+              {
+                style: { borderBottom: "none", background: "none" },
+                children: [
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col", children: [
+                    /* @__PURE__ */ jsx2(Text2, { weight: "plus", children: row.product.title || row.product.id }),
+                    /* @__PURE__ */ jsx2(Text2, { size: "small", className: "text-ui-fg-muted", children: row.product.handle || row.product.id })
+                  ] }) }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: /* @__PURE__ */ jsx2(
+                    StatusBadge,
+                    {
+                      color: couponStatusColor(config3.promotion_status),
+                      children: config3.promotion_status || "draft"
+                    }
+                  ) }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: couponTypeLabel(config3) }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: config3.code_strategy === "shared_code" ? config3.shared_code || "Shared" : `${config3.code_prefix || "COUPON"}-*` }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: campaignLabel(config3) }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: row.entitlements_count || 0 }),
+                  /* @__PURE__ */ jsx2(Table.Cell, { children: /* @__PURE__ */ jsxs2("div", { className: "flex justify-end gap-x-2", children: [
+                    allowPromotionMirror && !(config3.benefit_type === "fixed_amount" && (config3.amounts?.length || 0) > 1) && /* @__PURE__ */ jsx2(
+                      Button,
+                      {
+                        size: "small",
+                        variant: "secondary",
+                        onClick: () => void mirror(row),
+                        children: "Mirror"
+                      }
+                    ),
+                    /* @__PURE__ */ jsx2(
+                      Button,
+                      {
+                        size: "small",
+                        variant: "secondary",
+                        onClick: () => {
+                          setEditingRow(row);
+                          setModalOpen(true);
+                        },
+                        children: /* @__PURE__ */ jsx2(PencilSquare, {})
+                      }
+                    ),
+                    /* @__PURE__ */ jsx2(
+                      Button,
+                      {
+                        size: "small",
+                        variant: "danger",
+                        onClick: () => void remove(row),
+                        children: /* @__PURE__ */ jsx2(Trash, {})
+                      }
+                    )
+                  ] }) })
+                ]
+              },
+              row.id
+            );
+          })
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx2(
+      CouponEmptyState,
+      {
+        title: "No coupon products found",
+        description: "Create a new coupon product to get started."
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      CouponProductModal,
+      {
+        open: modalOpen,
+        row: editingRow,
+        apiBase,
+        options,
+        allowPromotionMirror,
+        onOpenChange: setModalOpen,
+        onSaved: load
+      }
+    )
+  ] });
+}
+
+// src/dashboard/coupons/coupon-manager.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function backendUrl2() {
+  return typeof __BACKEND_URL__ === "string" ? __BACKEND_URL__.replace(/\/$/, "") : "";
+}
+function apiErrorMessage2(payload, fallback) {
+  const candidates = [
+    payload?.message,
+    payload?.error?.message,
+    payload?.error,
+    payload?.errors?.[0]?.message
+  ];
+  const message = candidates.find(
+    (candidate) => typeof candidate === "string" && candidate.trim()
+  );
+  return message || fallback || "Request failed";
+}
+async function apiFetch2(path, options = {}) {
+  const response = await fetch(`${backendUrl2()}${path}`, {
+    ...options,
+    credentials: "include",
+    headers: {
+      ...options.body ? { "Content-Type": "application/json" } : {},
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const payload = await response.json().catch(() => null);
+    throw new Error(apiErrorMessage2(payload, response.statusText));
+  }
+  return response.json();
+}
+function formatDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  return date.toLocaleDateString();
+}
+function formatDateTime(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  return date.toLocaleString();
+}
+function formatFullDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  return date.toLocaleString(void 0, {
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    month: "short",
+    year: "numeric"
+  });
+}
+function formatRelativeDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  const diffSeconds = Math.round((date.getTime() - Date.now()) / 1e3);
+  const absSeconds = Math.abs(diffSeconds);
+  const units = [
+    ["year", 60 * 60 * 24 * 365],
+    ["month", 60 * 60 * 24 * 30],
+    ["week", 60 * 60 * 24 * 7],
+    ["day", 60 * 60 * 24],
+    ["hour", 60 * 60],
+    ["minute", 60]
+  ];
+  const [unit, seconds] = units.find(([, secondsPerUnit]) => absSeconds >= secondsPerUnit) || [];
+  if (!unit || !seconds) {
+    return "just now";
+  }
+  return new Intl.RelativeTimeFormat(void 0, { numeric: "auto" }).format(
+    Math.round(diffSeconds / seconds),
+    unit
+  );
+}
+function formatSnapshotAmount(amount, currency) {
+  if (amount == null) return "-";
+  const code = currency ? currency.toUpperCase() : "";
+  return [code, amount.toLocaleString(void 0, { maximumFractionDigits: 2 })].filter(Boolean).join(" ");
+}
+function entitlementStatusColor(status) {
+  if (status === "issued") return "green";
+  if (status === "redeemed") return "blue";
+  if (status === "expired" || status === "canceled") return "grey";
+  return "orange";
+}
+function snapshotString(snapshot, key) {
+  const value = snapshot?.[key];
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number") return String(value);
+  return "";
+}
+function snapshotNumber(snapshot, key) {
+  const value = snapshot?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function jsonBlock(value) {
+  if (value == null) return "{}";
+  return JSON.stringify(value, null, 2);
+}
+function couponCode(entitlement) {
+  return entitlement.code || entitlement.shared_code || "-";
+}
+function entitlementSource(entitlement) {
+  if (entitlement.origin === "external") return "External";
+  return "Purchase";
+}
+function entitlementSellerScope(entitlement) {
+  const count = entitlement.seller_targets?.length || 0;
+  if (entitlement.origin !== "external") {
+    if (!count) return "Product seller";
+    return `Product seller + ${count} linked`;
+  }
+  if (!count) return "Admin only";
+  return count === 1 ? "1 linked seller" : `${count} linked sellers`;
+}
+function orderDisplayId(order) {
+  if (!order) return "-";
+  return order.display_id == null ? order.id : `#${order.display_id}`;
+}
+function dashboardBasePath(apiBase) {
+  return apiBase === "/vendor" ? "/seller" : "/dashboard";
+}
+function couponDetailPath(apiBase, entitlementId) {
+  return `${dashboardBasePath(apiBase)}/coupons/${encodeURIComponent(
+    entitlementId
+  )}`;
+}
+function orderDetailPath(apiBase, orderId) {
+  return `${dashboardBasePath(apiBase)}/orders/${encodeURIComponent(orderId)}`;
+}
+function currentCouponDetailId(apiBase) {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  const prefix = `${dashboardBasePath(apiBase)}/coupons/`;
+  const path = window.location.pathname;
+  const index = path.indexOf(prefix);
+  if (index === -1) {
+    return "";
+  }
+  const id = path.slice(index + prefix.length).split("/")[0];
+  if (!id || id === "products") {
+    return "";
+  }
+  try {
+    return decodeURIComponent(id);
+  } catch {
+    return id;
+  }
+}
+function benefitSnapshotLabel(snapshot) {
+  const type = snapshotString(snapshot, "benefit_type");
+  if (type === "fixed_amount") {
+    const amounts = Array.isArray(snapshot?.amounts) ? snapshot.amounts : [];
+    if (amounts.length) {
+      return amounts.map((row) => {
+        const amount2 = snapshotNumber(row, "amount");
+        const currency2 = snapshotString(row, "currency_code").toUpperCase();
+        return `${amount2 ?? 0} ${currency2}`.trim();
+      }).join(", ");
+    }
+    const amount = snapshotNumber(snapshot, "amount");
+    const currency = snapshotString(snapshot, "currency_code").toUpperCase();
+    return `${amount ?? 0} ${currency}`.trim();
+  }
+  if (type === "percentage") {
+    const template = snapshot?.promotion_template;
+    const method = template?.application_method;
+    const scope = snapshotString(method, "target_type") === "order" ? "order" : "products";
+    return `${snapshotNumber(snapshot, "percentage") ?? 0}% off ${scope}`;
+  }
+  if (type === "free_shipping") {
+    return "Free shipping";
+  }
+  if (type === "buy_get") {
+    return "Buy X Get Y";
+  }
+  return "Unknown";
+}
+function expirationPolicyLabel(snapshot) {
+  const policy = snapshot?.expiration_policy;
+  const type = snapshotString(policy, "type");
+  if (type === "none") return "No expiration";
+  if (type === "duration") {
+    const days = snapshotNumber(policy, "duration_days") ?? 0;
+    return `${days} days after issuance`;
+  }
+  if (type === "fixed") {
+    return `Fixed date ${formatDateTime(snapshotString(policy, "expires_at"))}`;
+  }
+  return "-";
+}
+function campaignSnapshotLabel(snapshot) {
+  const campaignSnapshot = snapshot?.campaign_snapshot;
+  return snapshotString(campaignSnapshot, "name") || snapshotString(campaignSnapshot, "campaign_identifier") || snapshotString(snapshot, "campaign_id") || "None";
+}
+function promotionSnapshotLabel(snapshot) {
+  const template = snapshot?.promotion_template;
+  const method = template?.application_method;
+  const target = snapshotString(method, "target_type");
+  const allocation = snapshotString(method, "allocation");
+  return [target, allocation].filter(Boolean).join(" / ") || "None";
+}
+var entitlementFilters = [
+  { label: "All", value: "all" },
+  { label: "Issued", value: "issued" },
+  { label: "Redeemed", value: "redeemed" },
+  { label: "Expired", value: "expired" },
+  { label: "Canceled", value: "canceled" }
+];
+function SnapshotBlock({ title, value }) {
+  return /* @__PURE__ */ jsxs3("details", { className: "rounded-lg border p-3", children: [
+    /* @__PURE__ */ jsx3("summary", { className: "cursor-pointer text-ui-fg-base txt-small-plus", children: title }),
+    /* @__PURE__ */ jsx3(
+      "pre",
+      {
+        className: "mt-3 rounded-md bg-ui-bg-subtle p-3 text-ui-fg-subtle txt-compact-xsmall",
+        style: {
+          maxHeight: 220,
+          overflow: "auto",
+          whiteSpace: "pre-wrap",
+          wordBreak: "break-word"
+        },
+        children: jsonBlock(value)
+      }
+    )
+  ] });
+}
+function TwoColumnLayout({
+  firstCol,
+  secondCol
+}) {
+  return /* @__PURE__ */ jsxs3("div", { className: "flex flex-col gap-x-4 gap-y-3 xl:flex-row xl:items-start", children: [
+    /* @__PURE__ */ jsx3("div", { className: "flex w-full flex-col gap-y-3", children: firstCol }),
+    /* @__PURE__ */ jsx3("div", { className: "flex w-full max-w-[100%] flex-col gap-y-3 xl:mt-0 xl:max-w-[440px]", children: secondCol })
+  ] });
+}
+function SectionRow({
+  title,
+  value
+}) {
+  return /* @__PURE__ */ jsxs3("div", { className: "text-ui-fg-subtle grid grid-cols-2 items-center gap-x-4 px-6 py-4", children: [
+    /* @__PURE__ */ jsx3(Text3, { size: "small", weight: "plus", leading: "compact", children: title }),
+    typeof value === "string" || value == null ? /* @__PURE__ */ jsx3(
+      Text3,
+      {
+        size: "small",
+        leading: "compact",
+        className: "text-pretty whitespace-pre-line",
+        children: value || "-"
+      }
+    ) : /* @__PURE__ */ jsx3("div", { className: "min-w-0", children: value })
+  ] });
+}
+function WidgetHeader({ title }) {
+  return /* @__PURE__ */ jsx3("div", { className: "flex items-center justify-between px-6 py-4", children: /* @__PURE__ */ jsx3(Heading2, { level: "h2", children: title }) });
+}
+function SidebarLink({
+  href,
+  label,
+  description,
+  icon
+}) {
+  return /* @__PURE__ */ jsx3("a", { href, className: "group outline-none", children: /* @__PURE__ */ jsx3("div", { className: "flex flex-col gap-2 px-2 pb-2", children: /* @__PURE__ */ jsx3("div", { className: "shadow-elevation-card-rest bg-ui-bg-component transition-fg hover:bg-ui-bg-component-hover active:bg-ui-bg-component-pressed group-focus-visible:shadow-borders-interactive-with-active rounded-md px-4 py-2", children: /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-4", children: [
+    icon && /* @__PURE__ */ jsx3("div", { children: icon }),
+    /* @__PURE__ */ jsxs3("div", { className: "flex flex-1 flex-col", children: [
+      /* @__PURE__ */ jsx3(Text3, { size: "small", leading: "compact", weight: "plus", children: label }),
+      /* @__PURE__ */ jsx3(
+        Text3,
+        {
+          size: "small",
+          leading: "compact",
+          className: "text-ui-fg-subtle",
+          children: description
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3("div", { className: "flex items-center justify-center", children: /* @__PURE__ */ jsx3(TriangleRightMini, { className: "text-ui-fg-muted" }) })
+  ] }) }) }) });
+}
+function SummaryWidget({
+  label,
+  value,
+  tone = "green"
+}) {
+  return /* @__PURE__ */ jsx3(Container2, { className: "px-6 py-4", children: /* @__PURE__ */ jsxs3("div", { className: "text-ui-fg-subtle flex items-center gap-x-3", children: [
+    /* @__PURE__ */ jsx3(
+      "div",
+      {
+        className: `h-8 w-1 rounded-full ${tone === "green" ? "bg-ui-tag-green-icon" : "bg-ui-tag-neutral-icon"}`
+      }
+    ),
+    /* @__PURE__ */ jsxs3("div", { className: "min-w-0", children: [
+      /* @__PURE__ */ jsx3(Text3, { weight: "plus", size: "small", className: "text-ui-fg-subtle", children: label }),
+      /* @__PURE__ */ jsx3(
+        Text3,
+        {
+          weight: "plus",
+          size: "xlarge",
+          className: "tabular-nums text-ui-fg-base break-words",
+          children: value
+        }
+      )
+    ] })
+  ] }) });
+}
+function CouponGeneralSection({ detail }) {
+  const entitlement = detail.customer_coupon_entitlement;
+  const issuance = detail.coupon_issuance || null;
+  const benefitSnapshot = entitlement.benefit_snapshot || null;
+  const sourceSnapshot = entitlement.source_snapshot || null;
+  const code = couponCode(entitlement);
+  const external = entitlement.origin === "external";
+  const productLabel = snapshotString(sourceSnapshot, "title") || snapshotString(sourceSnapshot, "source") || entitlement.product_id || "External";
+  const variantLabel = snapshotString(sourceSnapshot, "variant_id") || entitlement.variant_id || "-";
+  const issuedDate = entitlement.created_at || issuance?.created_at || null;
+  return /* @__PURE__ */ jsxs3(Container2, { className: "divide-y p-0", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between px-6 py-4", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "min-w-0", children: [
+        /* @__PURE__ */ jsxs3("div", { className: "flex items-center gap-x-1", children: [
+          /* @__PURE__ */ jsxs3(Heading2, { className: "break-all", children: [
+            "#",
+            code
+          ] }),
+          code !== "-" && /* @__PURE__ */ jsx3(Copy, { content: code, className: "text-ui-fg-muted" })
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { size: "small", className: "text-ui-fg-subtle", children: formatFullDate(issuedDate) })
+      ] }),
+      /* @__PURE__ */ jsx3(StatusBadge2, { color: entitlementStatusColor(entitlement.status), children: entitlement.status })
+    ] }),
+    /* @__PURE__ */ jsx3(SectionRow, { title: "Date issued", value: formatRelativeDate(issuedDate) }),
+    /* @__PURE__ */ jsx3(
+      SectionRow,
+      {
+        title: "Customer",
+        value: entitlement.email || entitlement.customer_id || "-"
+      }
+    ),
+    /* @__PURE__ */ jsx3(SectionRow, { title: "Origin", value: entitlementSource(entitlement) }),
+    /* @__PURE__ */ jsx3(
+      SectionRow,
+      {
+        title: external ? "Source" : "Coupon product",
+        value: productLabel
+      }
+    ),
+    /* @__PURE__ */ jsx3(SectionRow, { title: "Seller scope", value: entitlementSellerScope(entitlement) }),
+    !external && /* @__PURE__ */ jsx3(SectionRow, { title: "Variant", value: variantLabel }),
+    !external && /* @__PURE__ */ jsx3(
+      SectionRow,
+      {
+        title: "Quantity",
+        value: String(
+          snapshotNumber(sourceSnapshot, "quantity") ?? issuance?.quantity ?? 1
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      SectionRow,
+      {
+        title: "Benefit",
+        value: benefitSnapshotLabel(benefitSnapshot)
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      SectionRow,
+      {
+        title: "Expiration policy",
+        value: expirationPolicyLabel(benefitSnapshot)
+      }
+    ),
+    /* @__PURE__ */ jsx3(SectionRow, { title: "Expiration Date", value: formatDate(entitlement.expires_at) }),
+    /* @__PURE__ */ jsx3(SectionRow, { title: "Redeemed Date", value: formatDate(entitlement.redeemed_at) })
+  ] });
+}
+function RelatedOrderSection({
+  apiBase,
+  detail
+}) {
+  const entitlement = detail.customer_coupon_entitlement;
+  const order = detail.order || null;
+  const orderId = order?.id || entitlement.order_id;
+  if (!orderId) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs3(Container2, { className: "p-0", children: [
+    /* @__PURE__ */ jsx3(WidgetHeader, { title: "Related Order" }),
+    /* @__PURE__ */ jsx3(
+      SidebarLink,
+      {
+        href: orderDetailPath(apiBase, orderId),
+        label: order ? orderDisplayId(order) : orderId,
+        description: order?.created_at ? `Order placed ${formatRelativeDate(order.created_at)}` : "Purchased coupon order",
+        icon: /* @__PURE__ */ jsx3(ShoppingCart, {})
+      }
+    )
+  ] });
+}
+function CouponSnapshotsSection({
+  detail
+}) {
+  const entitlement = detail.customer_coupon_entitlement;
+  const issuance = detail.coupon_issuance || null;
+  return /* @__PURE__ */ jsxs3(Container2, { className: "p-0", children: [
+    /* @__PURE__ */ jsx3(WidgetHeader, { title: "JSON" }),
+    /* @__PURE__ */ jsxs3("div", { className: "flex flex-col gap-y-3 px-6 pb-6", children: [
+      /* @__PURE__ */ jsx3(
+        SnapshotBlock,
+        {
+          title: "Benefit snapshot",
+          value: entitlement.benefit_snapshot
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        SnapshotBlock,
+        {
+          title: "Source snapshot",
+          value: entitlement.source_snapshot
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        SnapshotBlock,
+        {
+          title: "Issuance config snapshot",
+          value: issuance?.config_snapshot
+        }
+      ),
+      /* @__PURE__ */ jsx3(SnapshotBlock, { title: "Seller targets", value: entitlement.seller_targets }),
+      /* @__PURE__ */ jsx3(SnapshotBlock, { title: "Metadata", value: entitlement.metadata })
+    ] })
+  ] });
+}
+function CouponSummarySections({
+  detail
+}) {
+  const entitlement = detail.customer_coupon_entitlement;
+  const issuance = detail.coupon_issuance || null;
+  const benefitSnapshot = entitlement.benefit_snapshot || null;
+  const sourceSnapshot = entitlement.source_snapshot || null;
+  const order = detail.order || null;
+  const lineTotal = snapshotNumber(sourceSnapshot, "total");
+  const external = entitlement.origin === "external";
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx3(
+      SummaryWidget,
+      {
+        label: "Benefit",
+        value: benefitSnapshotLabel(benefitSnapshot)
+      }
+    ),
+    !external && /* @__PURE__ */ jsx3(
+      SummaryWidget,
+      {
+        label: "Line Total",
+        value: formatSnapshotAmount(lineTotal, order?.currency_code),
+        tone: "neutral"
+      }
+    ),
+    !external && /* @__PURE__ */ jsxs3(Container2, { className: "divide-y p-0", children: [
+      /* @__PURE__ */ jsx3(WidgetHeader, { title: "Campaign" }),
+      /* @__PURE__ */ jsx3(SectionRow, { title: "Campaign", value: campaignSnapshotLabel(benefitSnapshot) }),
+      /* @__PURE__ */ jsx3(SectionRow, { title: "Promotion", value: promotionSnapshotLabel(benefitSnapshot) }),
+      /* @__PURE__ */ jsx3(
+        SectionRow,
+        {
+          title: "Promotion status",
+          value: snapshotString(benefitSnapshot, "promotion_status") || "-"
+        }
+      )
+    ] }),
+    !external && /* @__PURE__ */ jsxs3(Container2, { className: "divide-y p-0", children: [
+      /* @__PURE__ */ jsx3(WidgetHeader, { title: "Issuance" }),
+      /* @__PURE__ */ jsx3(SectionRow, { title: "Status", value: issuance?.status || "-" }),
+      /* @__PURE__ */ jsx3(
+        SectionRow,
+        {
+          title: "Issued / failed",
+          value: issuance ? `${issuance.issued_count ?? 0} / ${issuance.failed_count ?? 0}` : "-"
+        }
+      ),
+      /* @__PURE__ */ jsx3(SectionRow, { title: "Config", value: entitlement.config_id || "-" }),
+      /* @__PURE__ */ jsx3(
+        SectionRow,
+        {
+          title: "Variant config",
+          value: entitlement.variant_config_id || "-"
+        }
+      )
+    ] })
+  ] });
+}
+function CouponDetailPageView({ apiBase }) {
+  const id = currentCouponDetailId(apiBase);
+  const [detail, setDetail] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [loadError, setLoadError] = useState2(null);
+  useEffect2(() => {
+    let active = true;
+    async function load() {
+      if (!id) {
+        setLoadError("Missing coupon id");
+        setLoading(false);
+        return;
+      }
+      setLoading(true);
+      setLoadError(null);
+      try {
+        const payload = await apiFetch2(
+          `${apiBase}/coupon-products/entitlements/${encodeURIComponent(id)}`
+        );
+        if (active) {
+          setDetail(payload);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to load coupon details";
+        if (active) {
+          setLoadError(message);
+          toast2.error(message);
+        }
+      } finally {
+        if (active) {
+          setLoading(false);
+        }
+      }
+    }
+    void load();
+    return () => {
+      active = false;
+    };
+  }, [apiBase, id]);
+  if (loading) {
+    return /* @__PURE__ */ jsx3(CouponEmptyState, { title: "Loading coupon" });
+  }
+  if (loadError) {
+    return /* @__PURE__ */ jsx3(CouponEmptyState, { title: loadError });
+  }
+  if (!detail) {
+    return /* @__PURE__ */ jsx3(CouponEmptyState, { title: "Coupon not found" });
+  }
+  return /* @__PURE__ */ jsx3(
+    TwoColumnLayout,
+    {
+      firstCol: /* @__PURE__ */ jsxs3(Fragment2, { children: [
+        /* @__PURE__ */ jsx3(CouponGeneralSection, { detail }),
+        /* @__PURE__ */ jsx3(RelatedOrderSection, { apiBase, detail }),
+        /* @__PURE__ */ jsx3(CouponSnapshotsSection, { detail })
+      ] }),
+      secondCol: /* @__PURE__ */ jsx3(CouponSummarySections, { detail })
+    }
+  );
+}
+function EntitlementsTable({
+  entitlements,
+  loading,
+  error,
+  onOpen
+}) {
+  if (loading) {
+    return /* @__PURE__ */ jsx3(CouponEmptyState, { title: "Loading coupons" });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3(CouponEmptyState, { title: error });
+  }
+  if (!entitlements.length) {
+    return /* @__PURE__ */ jsx3(
+      CouponEmptyState,
+      {
+        title: "No coupons found",
+        description: "Purchased coupons will appear here after they are issued."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs3(Table2, { children: [
+    /* @__PURE__ */ jsx3(Table2.Header, { children: /* @__PURE__ */ jsxs3(Table2.Row, { children: [
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Status" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Code" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Date issued" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Order" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Customer" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Origin" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Seller scope" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Source" }),
+      /* @__PURE__ */ jsx3(Table2.HeaderCell, { children: "Expires" })
+    ] }) }),
+    /* @__PURE__ */ jsx3(Table2.Body, { children: entitlements.map((item) => /* @__PURE__ */ jsxs3(
+      Table2.Row,
+      {
+        className: "cursor-pointer hover:bg-ui-bg-subtle",
+        onClick: () => onOpen(item),
+        children: [
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: /* @__PURE__ */ jsx3(StatusBadge2, { color: entitlementStatusColor(item.status), children: item.status }) }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: item.code || item.shared_code || "-" }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { title: formatFullDate(item.created_at), children: formatRelativeDate(item.created_at) }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: item.order_id || "-" }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: item.email || item.customer_id || "-" }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: entitlementSource(item) }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: entitlementSellerScope(item) }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: snapshotString(item.source_snapshot, "title") || snapshotString(item.source_snapshot, "source") || item.product_id || "External" }),
+          /* @__PURE__ */ jsx3(Table2.Cell, { children: formatDate(item.expires_at) })
+        ]
+      },
+      item.id
+    )) })
+  ] });
+}
+function CouponsPageView({
+  apiBase,
+  title
+}) {
+  const [entitlements, setEntitlements] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [loadError, setLoadError] = useState2(null);
+  const [filter, setFilter] = useState2("all");
+  const load = useCallback2(async () => {
+    setLoading(true);
+    setLoadError(null);
+    try {
+      const payload = await apiFetch2(`${apiBase}/coupon-products/entitlements`);
+      setEntitlements(payload.customer_coupon_entitlements || []);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to load coupons";
+      setLoadError(message);
+      toast2.error(message);
+    } finally {
+      setLoading(false);
+    }
+  }, [apiBase]);
+  useEffect2(() => {
+    void load();
+  }, [load]);
+  const openDetail = useCallback2(
+    (entitlement) => {
+      window.location.assign(couponDetailPath(apiBase, entitlement.id));
+    },
+    [apiBase]
+  );
+  return /* @__PURE__ */ jsxs3(Container2, { className: "divide-y p-0", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between px-6 py-4", children: [
+      /* @__PURE__ */ jsx3(Heading2, { level: "h1", children: title }),
+      /* @__PURE__ */ jsxs3(Button2, { size: "small", variant: "secondary", onClick: () => void load(), children: [
+        /* @__PURE__ */ jsx3(ArrowPath2, {}),
+        "Refresh"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(
+      Tabs,
+      {
+        value: filter,
+        onValueChange: (value) => setFilter(value),
+        children: [
+          /* @__PURE__ */ jsx3("div", { className: "px-6 py-2 border-b", children: /* @__PURE__ */ jsx3(Tabs.List, { children: entitlementFilters.map((item) => /* @__PURE__ */ jsx3(Tabs.Trigger, { value: item.value, children: item.label }, item.value)) }) }),
+          entitlementFilters.map((item) => /* @__PURE__ */ jsx3(Tabs.Content, { value: item.value, children: /* @__PURE__ */ jsx3(
+            EntitlementsTable,
+            {
+              loading,
+              error: loadError,
+              onOpen: openDetail,
+              entitlements: item.value === "all" ? entitlements : entitlements.filter(
+                (entitlement) => entitlement.status === item.value
+              )
+            }
+          ) }, item.value))
+        ]
+      }
+    )
+  ] });
+}
+function CouponProductsPageView({
+  apiBase,
+  title,
+  allowPromotionMirror = false
+}) {
+  return /* @__PURE__ */ jsx3(
+    CouponProductsPage,
+    {
+      apiBase,
+      title,
+      allowPromotionMirror
+    }
+  );
+}
+
+// src/admin/routes/coupons/page.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var config = {
+  label: "Coupons",
+  icon: ReceiptPercent
+};
+function CouponsPage() {
+  return /* @__PURE__ */ jsx4(CouponsPageView, { apiBase: "/admin", title: "Coupons" });
+}
+
+// src/admin/routes/coupons/[id]/page.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function CouponDetailPage() {
+  return /* @__PURE__ */ jsx5(CouponDetailPageView, { apiBase: "/admin" });
+}
+
+// src/admin/routes/coupons/products/page.tsx
+import { ReceiptPercent as ReceiptPercent2 } from "@medusajs/icons";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var config2 = {
+  label: "Coupon Products",
+  icon: ReceiptPercent2
+};
+function CouponProductsPage2() {
+  return /* @__PURE__ */ jsx6(
+    CouponProductsPageView,
+    {
+      apiBase: "/admin",
+      title: "Coupon Products",
+      allowPromotionMirror: true
+    }
+  );
+}
+
+// src/admin/index.ts
+var routeModule = {
+  routes: [
+    {
+      Component: CouponsPage,
+      path: "/coupons"
+    },
+    {
+      Component: CouponProductsPage2,
+      path: "/coupons/products"
+    },
+    {
+      Component: CouponDetailPage,
+      path: "/coupons/:id"
+    }
+  ]
+};
+var menuItemModule = {
+  menuItems: [
+    {
+      label: config.label,
+      icon: config.icon,
+      path: "/coupons",
+      rank: config.rank,
+      nested: config.nested,
+      translationNs: config.translationNs
+    },
+    {
+      label: config2.label,
+      icon: config2.icon,
+      path: "/coupons/products",
+      rank: 11,
+      nested: "/coupons",
+      translationNs: config2.translationNs
+    }
+  ]
+};
+var admin_default = {
+  widgetModule: {
+    widgets: []
+  },
+  routeModule,
+  menuItemModule,
+  formModule: {
+    customFields: {}
+  },
+  displayModule: {
+    displays: {}
+  },
+  i18nModule: i18n_default
+};
+export {
+  admin_default as default
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/admin/i18n/en.json", "../../../../src/admin/i18n/index.ts", "../../../../src/admin/routes/coupons/page.tsx", "../../../../src/dashboard/coupons/coupon-manager.tsx", "../../../../src/dashboard/coupons/coupon-products-page.tsx", "../../../../src/dashboard/coupons/empty-state.tsx", "../../../../src/admin/routes/coupons/[id]/page.tsx", "../../../../src/admin/routes/coupons/products/page.tsx", "../../../../src/admin/index.ts"],
  "sourcesContent": ["{\n  \"coupons\": {\n    \"menu\": \"Coupons\",\n    \"productsMenu\": \"Coupon Products\"\n  }\n}\n", "import en from \"./en.json\"\n\nexport default {\n  en: {\n    translation: en,\n  },\n}\n", "import type { RouteConfig } from \"@mercurjs/dashboard-sdk\"\nimport { ReceiptPercent } from \"@medusajs/icons\"\nimport { CouponsPageView } from \"../../../dashboard/coupons/coupon-manager\"\n\nexport const config: RouteConfig = {\n  label: \"Coupons\",\n  icon: ReceiptPercent,\n}\n\nexport default function CouponsPage() {\n  return <CouponsPageView apiBase=\"/admin\" title=\"Coupons\" />\n}\n", "import {\n  useCallback,\n  useEffect,\n  useMemo,\n  useState,\n  type ChangeEvent,\n  type CSSProperties,\n  type ReactNode,\n} from \"react\"\nimport {\n  ArrowPath,\n  PencilSquare,\n  Plus,\n  ShoppingCart,\n  Trash,\n  TriangleRightMini,\n} from \"@medusajs/icons\"\nimport {\n  Button,\n  Container,\n  Copy,\n  CurrencyInput,\n  FocusModal,\n  Heading,\n  Input,\n  Label,\n  ProgressTabs,\n  Select,\n  StatusBadge,\n  Switch,\n  Table,\n  Tabs,\n  Text,\n  Textarea,\n  toast,\n  usePrompt,\n} from \"@medusajs/ui\"\nimport { CouponProductsPage } from \"./coupon-products-page\"\nimport { CouponEmptyState } from \"./empty-state\"\n\ndeclare const __BACKEND_URL__: string\n\ntype ApiBase = \"/admin\" | \"/vendor\"\ntype BenefitType = \"fixed_amount\" | \"percentage\" | \"free_shipping\" | \"buy_get\"\ntype CodeStrategy = \"unique_code\" | \"shared_code\"\ntype MirrorMode = \"none\" | \"manual\" | \"auto\"\ntype PromotionStatus = \"draft\" | \"active\" | \"inactive\"\ntype CampaignMode = \"none\" | \"existing\" | \"new\"\ntype ExpirationPolicyType = \"duration\" | \"fixed\"\ntype WizardStep = \"details\" | \"organize\" | \"variants\" | \"coupon\" | \"campaign\"\n\ntype CouponProductConfig = {\n  id: string\n  enabled: boolean\n  product_id: string\n  benefit_type: BenefitType\n  amount: number | null\n  percentage: number | null\n  currency_code: string | null\n  code_strategy: CodeStrategy\n  code_prefix: string | null\n  shared_code: string | null\n  expiration_policy:\n    | {\n        type: \"duration\"\n        duration_days: number\n        cap_by_campaign?: boolean\n        cap_at?: string | null\n      }\n    | {\n        type: \"fixed\"\n        expires_at: string\n        cap_by_campaign?: boolean\n        cap_at?: string | null\n      }\n  max_issuance_per_order_item: number\n  promotion_mirror_mode: MirrorMode\n  promotion_status?: PromotionStatus | null\n  campaign_mode?: CampaignMode | null\n  campaign_id?: string | null\n  campaign_snapshot?: Record<string, unknown> | null\n  config_version: number\n}\n\ntype CouponVariantConfig = Partial<CouponProductConfig> & {\n  id: string\n  product_config_id: string\n  variant_id: string\n}\n\ntype ProductVariant = {\n  id: string\n  title: string | null\n  sku?: string | null\n  prices?: { currency_code?: string; amount?: number }[]\n}\n\ntype ProductRecord = {\n  id: string\n  title: string | null\n  subtitle?: string | null\n  handle: string | null\n  description?: string | null\n  status: string | null\n  thumbnail: string | null\n  discountable?: boolean\n  type_id?: string | null\n  collection_id?: string | null\n  shipping_profile_id?: string | null\n  variants?: ProductVariant[]\n  categories?: { id: string; name?: string | null }[]\n  tags?: { id: string; value?: string | null }[]\n  sales_channels?: { id: string; name?: string | null }[]\n}\n\ntype CouponProductRow = {\n  id: string\n  product: ProductRecord\n  coupon_product_config: CouponProductConfig\n  coupon_product_variant_configs: CouponVariantConfig[]\n  entitlements_count: number\n}\n\ntype CouponEntitlement = {\n  id: string\n  origin?: \"purchase\" | \"external\"\n  customer_id: string | null\n  email: string | null\n  code: string | null\n  shared_code: string | null\n  status: string\n  product_id: string | null\n  variant_id: string | null\n  order_id: string | null\n  line_item_id: string | null\n  issuance_id?: string | null\n  config_id?: string | null\n  variant_config_id?: string | null\n  expires_at: string | null\n  redeemed_at: string | null\n  created_at?: string\n  benefit_snapshot?: Record<string, unknown> | null\n  source_snapshot?: Record<string, unknown> | null\n  external_reference?: string | null\n  metadata?: Record<string, unknown> | null\n  seller_targets?: Array<{\n    seller_id: string\n    seller_member_id?: string | null\n  }>\n}\n\ntype CouponIssuanceRecord = {\n  id: string\n  status?: string | null\n  quantity?: number | null\n  config_snapshot?: Record<string, unknown> | null\n  issued_count?: number | null\n  failed_count?: number | null\n  created_at?: string\n  updated_at?: string\n}\n\ntype CouponOrderSummary = {\n  id: string\n  display_id: string | number | null\n  email: string | null\n  customer_id: string | null\n  currency_code: string | null\n  total: number | null\n  created_at: string | null\n}\n\ntype CouponEntitlementDetail = {\n  customer_coupon_entitlement: CouponEntitlement\n  coupon_issuance?: CouponIssuanceRecord | null\n  order?: CouponOrderSummary | null\n}\n\ntype OptionRecord = {\n  id: string\n  name?: string | null\n  title?: string | null\n  value?: string | null\n  handle?: string | null\n  campaign_identifier?: string | null\n}\n\ntype CurrencyOption = {\n  code: string\n  name: string\n  symbol: string\n  symbol_native: string\n  is_default: boolean\n}\n\ntype OptionsPayload = {\n  currencies?: CurrencyOption[]\n  product_types?: OptionRecord[]\n  product_collections?: OptionRecord[]\n  product_categories?: OptionRecord[]\n  product_tags?: OptionRecord[]\n  sales_channels?: OptionRecord[]\n  shipping_profiles?: OptionRecord[]\n  campaigns?: OptionRecord[]\n  sellers?: OptionRecord[]\n}\n\ntype ProductFormState = {\n  id: string\n  title: string\n  subtitle: string\n  handle: string\n  description: string\n  thumbnail: string\n  status: string\n  discountable: boolean\n  seller_id: string\n  type_id: string\n  collection_id: string\n  category_id: string\n  tag_id: string\n  sales_channel_id: string\n  variants: VariantFormState[]\n}\n\ntype VariantFormState = {\n  id?: string\n  override_config_id?: string\n  title: string\n  sku: string\n  currency_code: string\n  amount: string\n  override_enabled: boolean\n  override_benefit_type: BenefitType\n  override_currency_code: string\n  override_amount: string\n  override_percentage: string\n}\n\ntype CouponFormState = {\n  enabled: boolean\n  benefit_type: BenefitType\n  amount: string\n  percentage: string\n  currency_code: string\n  code_strategy: CodeStrategy\n  code_prefix: string\n  shared_code: string\n  expiration_type: ExpirationPolicyType\n  expiration_days: string\n  expiration_date: string\n  expiration_cap_by_campaign: boolean\n  expiration_cap_at: string\n  max_issuance_per_order_item: string\n  promotion_mirror_mode: MirrorMode\n  promotion_status: PromotionStatus\n}\n\ntype CampaignFormState = {\n  mode: CampaignMode\n  campaign_id: string\n  name: string\n  campaign_identifier: string\n  starts_at: string\n  ends_at: string\n}\n\nconst NONE = \"__none__\"\nconst steps: WizardStep[] = [\n  \"details\",\n  \"organize\",\n  \"variants\",\n  \"coupon\",\n  \"campaign\",\n]\n\nconst emptyVariant: VariantFormState = {\n  title: \"Default variant\",\n  sku: \"\",\n  currency_code: \"\",\n  amount: \"\",\n  override_enabled: false,\n  override_benefit_type: \"fixed_amount\",\n  override_currency_code: \"\",\n  override_amount: \"\",\n  override_percentage: \"\",\n}\n\nconst emptyProduct: ProductFormState = {\n  id: \"\",\n  title: \"\",\n  subtitle: \"\",\n  handle: \"\",\n  description: \"\",\n  thumbnail: \"\",\n  status: \"draft\",\n  discountable: false,\n  seller_id: \"\",\n  type_id: \"\",\n  collection_id: \"\",\n  category_id: \"\",\n  tag_id: \"\",\n  sales_channel_id: \"\",\n  variants: [emptyVariant],\n}\n\nconst emptyCoupon: CouponFormState = {\n  enabled: true,\n  benefit_type: \"fixed_amount\",\n  amount: \"\",\n  percentage: \"\",\n  currency_code: \"\",\n  code_strategy: \"unique_code\",\n  code_prefix: \"COUPON\",\n  shared_code: \"\",\n  expiration_type: \"duration\",\n  expiration_days: \"30\",\n  expiration_date: \"\",\n  expiration_cap_by_campaign: true,\n  expiration_cap_at: \"\",\n  max_issuance_per_order_item: \"1\",\n  promotion_mirror_mode: \"none\",\n  promotion_status: \"draft\",\n}\n\nconst emptyCampaign: CampaignFormState = {\n  mode: \"none\",\n  campaign_id: \"\",\n  name: \"\",\n  campaign_identifier: \"\",\n  starts_at: \"\",\n  ends_at: \"\",\n}\n\nconst modalContentStyle: CSSProperties = {\n  display: \"flex\",\n  flexDirection: \"column\",\n  height: \"100%\",\n  overflow: \"hidden\",\n}\n\nconst modalStaticRowStyle: CSSProperties = {\n  flexShrink: 0,\n}\n\nconst modalWizardStyle: CSSProperties = {\n  display: \"flex\",\n  flex: \"1 1 auto\",\n  flexDirection: \"column\",\n  minHeight: 0,\n}\n\nconst modalBodyStyle: CSSProperties = {\n  flex: \"1 1 auto\",\n  minHeight: 0,\n  overflowY: \"auto\",\n  padding: \"32px 24px\",\n}\n\nconst modalFormStyle: CSSProperties = {\n  margin: \"0 auto\",\n  maxWidth: 920,\n  width: \"min(920px, 100%)\",\n}\n\nconst stackStyle: CSSProperties = {\n  display: \"flex\",\n  flexDirection: \"column\",\n  gap: 16,\n}\n\nconst twoColumnGridStyle: CSSProperties = {\n  display: \"grid\",\n  gap: 16,\n  gridTemplateColumns: \"repeat(auto-fit, minmax(260px, 1fr))\",\n}\n\nconst threeColumnGridStyle: CSSProperties = {\n  display: \"grid\",\n  gap: 16,\n  gridTemplateColumns: \"repeat(auto-fit, minmax(220px, 1fr))\",\n}\n\nconst fourColumnGridStyle: CSSProperties = {\n  display: \"grid\",\n  gap: 16,\n  gridTemplateColumns: \"repeat(auto-fit, minmax(160px, 1fr))\",\n}\n\nconst panelStyle: CSSProperties = {\n  border: \"1px solid var(--border-base)\",\n  borderRadius: 8,\n  padding: 16,\n}\n\nconst rowBetweenStyle: CSSProperties = {\n  alignItems: \"center\",\n  display: \"flex\",\n  gap: 16,\n  justifyContent: \"space-between\",\n}\n\nfunction backendUrl() {\n  return typeof __BACKEND_URL__ === \"string\"\n    ? __BACKEND_URL__.replace(/\\/$/, \"\")\n    : \"\"\n}\n\nfunction apiErrorMessage(payload: any, fallback: string) {\n  const candidates = [\n    payload?.message,\n    payload?.error?.message,\n    payload?.error,\n    payload?.errors?.[0]?.message,\n  ]\n  const message = candidates.find(\n    (candidate) => typeof candidate === \"string\" && candidate.trim(),\n  )\n\n  return message || fallback || \"Request failed\"\n}\n\nasync function apiFetch<T>(\n  path: string,\n  options: RequestInit = {},\n): Promise<T> {\n  const response = await fetch(`${backendUrl()}${path}`, {\n    ...options,\n    credentials: \"include\",\n    headers: {\n      ...(options.body ? { \"Content-Type\": \"application/json\" } : {}),\n      ...options.headers,\n    },\n  })\n\n  if (!response.ok) {\n    const payload = await response.json().catch(() => null)\n    throw new Error(apiErrorMessage(payload, response.statusText))\n  }\n\n  return response.json()\n}\n\nfunction numberOrNull(value: string) {\n  const parsed = Number(value)\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : null\n}\n\nfunction optionLabel(option: OptionRecord) {\n  return (\n    option.name || option.title || option.value || option.handle || option.id\n  )\n}\n\nfunction benefitLabel(\n  config: Pick<\n    CouponProductConfig,\n    \"benefit_type\" | \"amount\" | \"percentage\" | \"currency_code\"\n  >,\n) {\n  if (config.benefit_type === \"fixed_amount\") {\n    return `${config.amount || 0} ${(config.currency_code || \"\").toUpperCase()}`\n  }\n  if (config.benefit_type === \"percentage\") {\n    return `${config.percentage || 0}%`\n  }\n  if (config.benefit_type === \"free_shipping\") {\n    return \"Free shipping\"\n  }\n  return \"Buy get\"\n}\n\nfunction formatDate(value?: string | null) {\n  if (!value) return \"-\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"-\"\n  return date.toLocaleDateString()\n}\n\nfunction formatDateTime(value?: string | null) {\n  if (!value) return \"-\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"-\"\n  return date.toLocaleString()\n}\n\nfunction formatFullDate(value?: string | null) {\n  if (!value) return \"-\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"-\"\n  return date.toLocaleString(undefined, {\n    day: \"numeric\",\n    hour: \"numeric\",\n    minute: \"2-digit\",\n    month: \"short\",\n    year: \"numeric\",\n  })\n}\n\nfunction formatRelativeDate(value?: string | null) {\n  if (!value) return \"-\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"-\"\n\n  const diffSeconds = Math.round((date.getTime() - Date.now()) / 1000)\n  const absSeconds = Math.abs(diffSeconds)\n  const units: Array<[Intl.RelativeTimeFormatUnit, number]> = [\n    [\"year\", 60 * 60 * 24 * 365],\n    [\"month\", 60 * 60 * 24 * 30],\n    [\"week\", 60 * 60 * 24 * 7],\n    [\"day\", 60 * 60 * 24],\n    [\"hour\", 60 * 60],\n    [\"minute\", 60],\n  ]\n  const [unit, seconds] =\n    units.find(([, secondsPerUnit]) => absSeconds >= secondsPerUnit) || []\n\n  if (!unit || !seconds) {\n    return \"just now\"\n  }\n\n  return new Intl.RelativeTimeFormat(undefined, { numeric: \"auto\" }).format(\n    Math.round(diffSeconds / seconds),\n    unit,\n  )\n}\n\nfunction formatSnapshotAmount(amount: number | null, currency?: string | null) {\n  if (amount == null) return \"-\"\n  const code = currency ? currency.toUpperCase() : \"\"\n  return [code, amount.toLocaleString(undefined, { maximumFractionDigits: 2 })]\n    .filter(Boolean)\n    .join(\" \")\n}\n\nfunction toDateTimeLocal(value?: string | null) {\n  if (!value) return \"\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"\"\n  const localDate = new Date(date.getTime() - date.getTimezoneOffset() * 60_000)\n  return localDate.toISOString().slice(0, 16)\n}\n\nfunction entitlementStatusColor(status: string) {\n  if (status === \"issued\") return \"green\" as const\n  if (status === \"redeemed\") return \"blue\" as const\n  if (status === \"expired\" || status === \"canceled\") return \"grey\" as const\n  return \"orange\" as const\n}\n\nfunction productStatusColor(status?: string | null) {\n  if (status === \"published\") return \"green\" as const\n  if (status === \"rejected\") return \"red\" as const\n  if (status === \"proposed\") return \"orange\" as const\n  return \"grey\" as const\n}\n\nfunction snapshotString(\n  snapshot: Record<string, unknown> | null | undefined,\n  key: string,\n) {\n  const value = snapshot?.[key]\n  if (typeof value === \"string\" && value.trim()) return value\n  if (typeof value === \"number\") return String(value)\n  return \"\"\n}\n\nfunction snapshotNumber(\n  snapshot: Record<string, unknown> | null | undefined,\n  key: string,\n) {\n  const value = snapshot?.[key]\n  return typeof value === \"number\" && Number.isFinite(value) ? value : null\n}\n\nfunction jsonBlock(value: unknown) {\n  if (value == null) return \"{}\"\n  return JSON.stringify(value, null, 2)\n}\n\nfunction couponCode(entitlement: CouponEntitlement) {\n  return entitlement.code || entitlement.shared_code || \"-\"\n}\n\nfunction entitlementSource(entitlement: CouponEntitlement) {\n  if (entitlement.origin === \"external\") return \"External\"\n  return \"Purchase\"\n}\n\nfunction entitlementSellerScope(entitlement: CouponEntitlement) {\n  const count = entitlement.seller_targets?.length || 0\n  if (entitlement.origin !== \"external\") {\n    if (!count) return \"Product seller\"\n    return `Product seller + ${count} linked`\n  }\n  if (!count) return \"Admin only\"\n  return count === 1 ? \"1 linked seller\" : `${count} linked sellers`\n}\n\nfunction orderDisplayId(order: CouponOrderSummary | null | undefined) {\n  if (!order) return \"-\"\n  return order.display_id == null ? order.id : `#${order.display_id}`\n}\n\nfunction dashboardBasePath(apiBase: ApiBase) {\n  return apiBase === \"/vendor\" ? \"/seller\" : \"/dashboard\"\n}\n\nfunction couponDetailPath(apiBase: ApiBase, entitlementId: string) {\n  return `${dashboardBasePath(apiBase)}/coupons/${encodeURIComponent(\n    entitlementId,\n  )}`\n}\n\nfunction orderDetailPath(apiBase: ApiBase, orderId: string) {\n  return `${dashboardBasePath(apiBase)}/orders/${encodeURIComponent(orderId)}`\n}\n\nfunction currentCouponDetailId(apiBase: ApiBase) {\n  if (typeof window === \"undefined\") {\n    return \"\"\n  }\n\n  const prefix = `${dashboardBasePath(apiBase)}/coupons/`\n  const path = window.location.pathname\n  const index = path.indexOf(prefix)\n  if (index === -1) {\n    return \"\"\n  }\n\n  const id = path.slice(index + prefix.length).split(\"/\")[0]\n  if (!id || id === \"products\") {\n    return \"\"\n  }\n\n  try {\n    return decodeURIComponent(id)\n  } catch {\n    return id\n  }\n}\n\nfunction benefitSnapshotLabel(\n  snapshot: Record<string, unknown> | null | undefined,\n) {\n  const type = snapshotString(snapshot, \"benefit_type\")\n  if (type === \"fixed_amount\") {\n    const amounts = Array.isArray(snapshot?.amounts)\n      ? (snapshot.amounts as Array<Record<string, unknown>>)\n      : []\n    if (amounts.length) {\n      return amounts\n        .map((row) => {\n          const amount = snapshotNumber(row, \"amount\")\n          const currency = snapshotString(row, \"currency_code\").toUpperCase()\n          return `${amount ?? 0} ${currency}`.trim()\n        })\n        .join(\", \")\n    }\n\n    const amount = snapshotNumber(snapshot, \"amount\")\n    const currency = snapshotString(snapshot, \"currency_code\").toUpperCase()\n    return `${amount ?? 0} ${currency}`.trim()\n  }\n\n  if (type === \"percentage\") {\n    const template = snapshot?.promotion_template as\n      | Record<string, unknown>\n      | null\n      | undefined\n    const method = template?.application_method as\n      | Record<string, unknown>\n      | null\n      | undefined\n    const scope = snapshotString(method, \"target_type\") === \"order\"\n      ? \"order\"\n      : \"products\"\n    return `${snapshotNumber(snapshot, \"percentage\") ?? 0}% off ${scope}`\n  }\n\n  if (type === \"free_shipping\") {\n    return \"Free shipping\"\n  }\n\n  if (type === \"buy_get\") {\n    return \"Buy X Get Y\"\n  }\n\n  return \"Unknown\"\n}\n\nfunction expirationPolicyLabel(\n  snapshot: Record<string, unknown> | null | undefined,\n) {\n  const policy = snapshot?.expiration_policy as\n    | Record<string, unknown>\n    | null\n    | undefined\n  const type = snapshotString(policy, \"type\")\n\n  if (type === \"none\") return \"No expiration\"\n  if (type === \"duration\") {\n    const days = snapshotNumber(policy, \"duration_days\") ?? 0\n    return `${days} days after issuance`\n  }\n  if (type === \"fixed\") {\n    return `Fixed date ${formatDateTime(snapshotString(policy, \"expires_at\"))}`\n  }\n\n  return \"-\"\n}\n\nfunction campaignSnapshotLabel(\n  snapshot: Record<string, unknown> | null | undefined,\n) {\n  const campaignSnapshot = snapshot?.campaign_snapshot as\n    | Record<string, unknown>\n    | null\n    | undefined\n  return (\n    snapshotString(campaignSnapshot, \"name\") ||\n    snapshotString(campaignSnapshot, \"campaign_identifier\") ||\n    snapshotString(snapshot, \"campaign_id\") ||\n    \"None\"\n  )\n}\n\nfunction promotionSnapshotLabel(\n  snapshot: Record<string, unknown> | null | undefined,\n) {\n  const template = snapshot?.promotion_template as\n    | Record<string, unknown>\n    | null\n    | undefined\n  const method = template?.application_method as\n    | Record<string, unknown>\n    | null\n    | undefined\n  const target = snapshotString(method, \"target_type\")\n  const allocation = snapshotString(method, \"allocation\")\n\n  return [target, allocation].filter(Boolean).join(\" / \") || \"None\"\n}\n\nfunction campaignLabel(config: CouponProductConfig) {\n  const name = config.campaign_snapshot?.name\n  if (typeof name === \"string\" && name) {\n    return name\n  }\n\n  return config.campaign_id || \"None\"\n}\n\nfunction formFromRow(row: CouponProductRow, defaultCurrencyCode: string) {\n  const product = row.product || ({} as ProductRecord)\n  const config = row.coupon_product_config\n  const variantConfigByVariantId = new Map(\n    (row.coupon_product_variant_configs || []).map((variantConfig) => [\n      variantConfig.variant_id,\n      variantConfig,\n    ]),\n  )\n  const durationDays =\n    config.expiration_policy?.type === \"duration\"\n      ? config.expiration_policy.duration_days\n      : 30\n\n  return {\n    product: {\n      ...emptyProduct,\n      id: product.id || \"\",\n      title: product.title || \"\",\n      subtitle: product.subtitle || \"\",\n      handle: product.handle || \"\",\n      description: product.description || \"\",\n      thumbnail: product.thumbnail || \"\",\n      status: product.status || \"draft\",\n      discountable: Boolean(product.discountable),\n      type_id: product.type_id || \"\",\n      collection_id: product.collection_id || \"\",\n      category_id: product.categories?.[0]?.id || \"\",\n      tag_id: product.tags?.[0]?.id || \"\",\n      sales_channel_id: product.sales_channels?.[0]?.id || \"\",\n      variants: (product.variants?.length ? product.variants : []).map(\n        (variant) => {\n          const override = variantConfigByVariantId.get(variant.id)\n          return {\n            ...emptyVariant,\n            id: variant.id,\n            override_config_id: override?.id,\n            title: variant.title || \"\",\n            sku: variant.sku || \"\",\n            currency_code:\n              variant.prices?.[0]?.currency_code ||\n              override?.currency_code ||\n              config.currency_code ||\n              defaultCurrencyCode,\n            amount:\n              variant.prices?.[0]?.amount == null\n                ? \"\"\n                : String(variant.prices?.[0]?.amount),\n            override_enabled: override ? override.enabled !== false : false,\n            override_benefit_type:\n              override?.benefit_type || config.benefit_type || \"fixed_amount\",\n            override_currency_code:\n              override?.currency_code ||\n              config.currency_code ||\n              defaultCurrencyCode,\n            override_amount:\n              override?.amount == null ? \"\" : String(override.amount),\n            override_percentage:\n              override?.percentage == null ? \"\" : String(override.percentage),\n          }\n        },\n      ),\n    },\n    coupon: {\n      ...emptyCoupon,\n      enabled: config.enabled,\n      benefit_type: config.benefit_type,\n      amount: config.amount == null ? \"\" : String(config.amount),\n      percentage: config.percentage == null ? \"\" : String(config.percentage),\n      currency_code: config.currency_code || defaultCurrencyCode,\n      code_strategy: config.code_strategy,\n      code_prefix: config.code_prefix || \"\",\n      shared_code: config.shared_code || \"\",\n      expiration_type: config.expiration_policy?.type || \"duration\",\n      expiration_days: String(durationDays),\n      expiration_date:\n        config.expiration_policy?.type === \"fixed\"\n          ? toDateTimeLocal(config.expiration_policy.expires_at)\n          : \"\",\n      expiration_cap_by_campaign:\n        config.expiration_policy?.cap_by_campaign !== false,\n      expiration_cap_at: config.expiration_policy?.cap_at\n        ? toDateTimeLocal(config.expiration_policy.cap_at)\n        : \"\",\n      max_issuance_per_order_item: String(\n        config.max_issuance_per_order_item || 1,\n      ),\n      promotion_mirror_mode: config.promotion_mirror_mode || \"none\",\n      promotion_status: config.promotion_status || \"draft\",\n    },\n    campaign: {\n      ...emptyCampaign,\n      mode: config.campaign_id ? \"existing\" : \"none\",\n      campaign_id: config.campaign_id || \"\",\n    },\n  }\n}\n\nfunction buildCouponPayload(\n  coupon: CouponFormState,\n  allowPromotionMirror: boolean,\n) {\n  return {\n    enabled: coupon.enabled,\n    benefit_type: coupon.benefit_type,\n    amount:\n      coupon.benefit_type === \"fixed_amount\"\n        ? numberOrNull(coupon.amount)\n        : null,\n    percentage:\n      coupon.benefit_type === \"percentage\"\n        ? numberOrNull(coupon.percentage)\n        : null,\n    currency_code:\n      coupon.benefit_type === \"fixed_amount\"\n        ? coupon.currency_code.trim().toLowerCase()\n        : null,\n    code_strategy: coupon.code_strategy,\n    code_prefix:\n      coupon.code_strategy === \"unique_code\"\n        ? coupon.code_prefix.trim() || \"COUPON\"\n        : null,\n    shared_code:\n      coupon.code_strategy === \"shared_code\" ? coupon.shared_code.trim() : null,\n    expiration_policy:\n      coupon.expiration_type === \"fixed\"\n        ? {\n            type: \"fixed\" as const,\n            expires_at: new Date(coupon.expiration_date).toISOString(),\n            cap_by_campaign: coupon.expiration_cap_by_campaign,\n            cap_at: coupon.expiration_cap_at\n              ? new Date(coupon.expiration_cap_at).toISOString()\n              : null,\n          }\n        : {\n            type: \"duration\" as const,\n            duration_days: Number(coupon.expiration_days) || 30,\n            cap_by_campaign: coupon.expiration_cap_by_campaign,\n            cap_at: coupon.expiration_cap_at\n              ? new Date(coupon.expiration_cap_at).toISOString()\n              : null,\n          },\n    max_issuance_per_order_item:\n      Number(coupon.max_issuance_per_order_item) || 1,\n    ...(allowPromotionMirror\n      ? {\n          promotion_mirror_mode: coupon.promotion_mirror_mode,\n          promotion_status: coupon.promotion_status,\n        }\n      : {}),\n  }\n}\n\nfunction buildCampaignPayload(\n  campaign: CampaignFormState,\n  allowCampaign: boolean,\n) {\n  if (!allowCampaign) {\n    return undefined\n  }\n  if (campaign.mode === \"existing\") {\n    return {\n      mode: \"existing\",\n      campaign_id: campaign.campaign_id || null,\n    }\n  }\n  if (campaign.mode === \"new\") {\n    return {\n      mode: \"new\",\n      campaign: {\n        name: campaign.name,\n        campaign_identifier: campaign.campaign_identifier,\n        starts_at: campaign.starts_at\n          ? new Date(campaign.starts_at).toISOString()\n          : null,\n        ends_at: campaign.ends_at\n          ? new Date(campaign.ends_at).toISOString()\n          : null,\n      },\n    }\n  }\n  return { mode: \"none\" }\n}\n\nfunction stepStatus(step: WizardStep, active: WizardStep) {\n  const stepIndex = steps.indexOf(step)\n  const activeIndex = steps.indexOf(active)\n  if (stepIndex < activeIndex) return \"completed\"\n  if (stepIndex === activeIndex) return \"in-progress\"\n  return \"not-started\"\n}\n\nfunction Field({ label, children }: { label: string; children: ReactNode }) {\n  return (\n    <div className=\"flex flex-col gap-y-1\" style={{ minWidth: 0 }}>\n      <Label>{label}</Label>\n      {children}\n    </div>\n  )\n}\n\nfunction currencyDecimalDigits(code: string) {\n  try {\n    return new Intl.NumberFormat(\"en\", {\n      style: \"currency\",\n      currency: code.toUpperCase(),\n    }).resolvedOptions().maximumFractionDigits\n  } catch {\n    return 2\n  }\n}\n\nfunction currencySymbol(code: string) {\n  if (!code) return \"\"\n\n  try {\n    return (\n      new Intl.NumberFormat(\"en\", {\n        style: \"currency\",\n        currency: code.toUpperCase(),\n        currencyDisplay: \"narrowSymbol\",\n      })\n        .formatToParts(0)\n        .find((part) => part.type === \"currency\")?.value || code.toUpperCase()\n    )\n  } catch {\n    return code.toUpperCase()\n  }\n}\n\nfunction CurrencySelect({\n  currencies,\n  disabled,\n  onChange,\n  value,\n}: {\n  currencies: CurrencyOption[]\n  disabled?: boolean\n  onChange: (value: string) => void\n  value: string\n}) {\n  return (\n    <Select\n      value={value || undefined}\n      disabled={disabled || !currencies.length}\n      onValueChange={onChange}\n    >\n      <Select.Trigger>\n        <Select.Value\n          placeholder={\n            currencies.length ? \"Select currency\" : \"No currencies available\"\n          }\n        />\n      </Select.Trigger>\n      <Select.Content>\n        {currencies.map((currency) => (\n          <Select.Item key={currency.code} value={currency.code}>\n            {currency.name} ({currency.code.toUpperCase()})\n          </Select.Item>\n        ))}\n      </Select.Content>\n    </Select>\n  )\n}\n\nfunction CurrencyAmountInput({\n  currencies,\n  currencyCode,\n  disabled,\n  onChange,\n  value,\n}: {\n  currencies: CurrencyOption[]\n  currencyCode: string\n  disabled?: boolean\n  onChange: (value: string) => void\n  value: string\n}) {\n  const currency = currencies.find((item) => item.code === currencyCode)\n  const code = currencyCode.toUpperCase()\n  const decimals = currencyDecimalDigits(code || \"USD\")\n\n  return (\n    <CurrencyInput\n      code={code || \"USD\"}\n      symbol={\n        currency?.symbol_native ||\n        currency?.symbol ||\n        currencySymbol(code || \"USD\")\n      }\n      min={0}\n      decimalScale={decimals}\n      decimalsLimit={decimals}\n      value={value}\n      disabled={disabled || !currencyCode}\n      onValueChange={(nextValue) => onChange(nextValue || \"\")}\n    />\n  )\n}\n\nconst entitlementFilters = [\n  { label: \"All\", value: \"all\" },\n  { label: \"Issued\", value: \"issued\" },\n  { label: \"Redeemed\", value: \"redeemed\" },\n  { label: \"Expired\", value: \"expired\" },\n  { label: \"Canceled\", value: \"canceled\" },\n] as const\n\ntype EntitlementFilter = (typeof entitlementFilters)[number][\"value\"]\n\nfunction SnapshotBlock({ title, value }: { title: string; value: unknown }) {\n  return (\n    <details className=\"rounded-lg border p-3\">\n      <summary className=\"cursor-pointer text-ui-fg-base txt-small-plus\">\n        {title}\n      </summary>\n      <pre\n        className=\"mt-3 rounded-md bg-ui-bg-subtle p-3 text-ui-fg-subtle txt-compact-xsmall\"\n        style={{\n          maxHeight: 220,\n          overflow: \"auto\",\n          whiteSpace: \"pre-wrap\",\n          wordBreak: \"break-word\",\n        }}\n      >\n        {jsonBlock(value)}\n      </pre>\n    </details>\n  )\n}\n\nfunction TwoColumnLayout({\n  firstCol,\n  secondCol,\n}: {\n  firstCol: ReactNode\n  secondCol: ReactNode\n}) {\n  return (\n    <div className=\"flex flex-col gap-x-4 gap-y-3 xl:flex-row xl:items-start\">\n      <div className=\"flex w-full flex-col gap-y-3\">{firstCol}</div>\n      <div className=\"flex w-full max-w-[100%] flex-col gap-y-3 xl:mt-0 xl:max-w-[440px]\">\n        {secondCol}\n      </div>\n    </div>\n  )\n}\n\nfunction SectionRow({\n  title,\n  value,\n}: {\n  title: string\n  value: ReactNode\n}) {\n  return (\n    <div className=\"text-ui-fg-subtle grid grid-cols-2 items-center gap-x-4 px-6 py-4\">\n      <Text size=\"small\" weight=\"plus\" leading=\"compact\">\n        {title}\n      </Text>\n      {typeof value === \"string\" || value == null ? (\n        <Text\n          size=\"small\"\n          leading=\"compact\"\n          className=\"text-pretty whitespace-pre-line\"\n        >\n          {value || \"-\"}\n        </Text>\n      ) : (\n        <div className=\"min-w-0\">{value}</div>\n      )}\n    </div>\n  )\n}\n\nfunction WidgetHeader({ title }: { title: string }) {\n  return (\n    <div className=\"flex items-center justify-between px-6 py-4\">\n      <Heading level=\"h2\">{title}</Heading>\n    </div>\n  )\n}\n\nfunction SidebarLink({\n  href,\n  label,\n  description,\n  icon,\n}: {\n  href: string\n  label: string\n  description: string\n  icon?: ReactNode\n}) {\n  return (\n    <a href={href} className=\"group outline-none\">\n      <div className=\"flex flex-col gap-2 px-2 pb-2\">\n        <div className=\"shadow-elevation-card-rest bg-ui-bg-component transition-fg hover:bg-ui-bg-component-hover active:bg-ui-bg-component-pressed group-focus-visible:shadow-borders-interactive-with-active rounded-md px-4 py-2\">\n          <div className=\"flex items-center gap-4\">\n            {icon && <div>{icon}</div>}\n            <div className=\"flex flex-1 flex-col\">\n              <Text size=\"small\" leading=\"compact\" weight=\"plus\">\n                {label}\n              </Text>\n              <Text\n                size=\"small\"\n                leading=\"compact\"\n                className=\"text-ui-fg-subtle\"\n              >\n                {description}\n              </Text>\n            </div>\n            <div className=\"flex items-center justify-center\">\n              <TriangleRightMini className=\"text-ui-fg-muted\" />\n            </div>\n          </div>\n        </div>\n      </div>\n    </a>\n  )\n}\n\nfunction SummaryWidget({\n  label,\n  value,\n  tone = \"green\",\n}: {\n  label: string\n  value: string\n  tone?: \"green\" | \"neutral\"\n}) {\n  return (\n    <Container className=\"px-6 py-4\">\n      <div className=\"text-ui-fg-subtle flex items-center gap-x-3\">\n        <div\n          className={`h-8 w-1 rounded-full ${\n            tone === \"green\"\n              ? \"bg-ui-tag-green-icon\"\n              : \"bg-ui-tag-neutral-icon\"\n          }`}\n        />\n        <div className=\"min-w-0\">\n          <Text weight=\"plus\" size=\"small\" className=\"text-ui-fg-subtle\">\n            {label}\n          </Text>\n          <Text\n            weight=\"plus\"\n            size=\"xlarge\"\n            className=\"tabular-nums text-ui-fg-base break-words\"\n          >\n            {value}\n          </Text>\n        </div>\n      </div>\n    </Container>\n  )\n}\n\nfunction CouponGeneralSection({ detail }: { detail: CouponEntitlementDetail }) {\n  const entitlement = detail.customer_coupon_entitlement\n  const issuance = detail.coupon_issuance || null\n  const benefitSnapshot = entitlement.benefit_snapshot || null\n  const sourceSnapshot = entitlement.source_snapshot || null\n  const code = couponCode(entitlement)\n  const external = entitlement.origin === \"external\"\n  const productLabel =\n    snapshotString(sourceSnapshot, \"title\") ||\n    snapshotString(sourceSnapshot, \"source\") ||\n    entitlement.product_id ||\n    \"External\"\n  const variantLabel =\n    snapshotString(sourceSnapshot, \"variant_id\") || entitlement.variant_id || \"-\"\n  const issuedDate = entitlement.created_at || issuance?.created_at || null\n\n  return (\n    <Container className=\"divide-y p-0\">\n      <div className=\"flex items-center justify-between px-6 py-4\">\n        <div className=\"min-w-0\">\n          <div className=\"flex items-center gap-x-1\">\n            <Heading className=\"break-all\">#{code}</Heading>\n            {code !== \"-\" && (\n              <Copy content={code} className=\"text-ui-fg-muted\" />\n            )}\n          </div>\n          <Text size=\"small\" className=\"text-ui-fg-subtle\">\n            {formatFullDate(issuedDate)}\n          </Text>\n        </div>\n        <StatusBadge color={entitlementStatusColor(entitlement.status)}>\n          {entitlement.status}\n        </StatusBadge>\n      </div>\n      <SectionRow title=\"Date issued\" value={formatRelativeDate(issuedDate)} />\n      <SectionRow\n        title=\"Customer\"\n        value={entitlement.email || entitlement.customer_id || \"-\"}\n      />\n      <SectionRow title=\"Origin\" value={entitlementSource(entitlement)} />\n      <SectionRow\n        title={external ? \"Source\" : \"Coupon product\"}\n        value={productLabel}\n      />\n      <SectionRow title=\"Seller scope\" value={entitlementSellerScope(entitlement)} />\n      {!external && <SectionRow title=\"Variant\" value={variantLabel} />}\n      {!external && (\n        <SectionRow\n          title=\"Quantity\"\n          value={String(\n            snapshotNumber(sourceSnapshot, \"quantity\") ?? issuance?.quantity ?? 1,\n          )}\n        />\n      )}\n      <SectionRow\n        title=\"Benefit\"\n        value={benefitSnapshotLabel(benefitSnapshot)}\n      />\n      <SectionRow\n        title=\"Expiration policy\"\n        value={expirationPolicyLabel(benefitSnapshot)}\n      />\n      <SectionRow title=\"Expiration Date\" value={formatDate(entitlement.expires_at)} />\n      <SectionRow title=\"Redeemed Date\" value={formatDate(entitlement.redeemed_at)} />\n    </Container>\n  )\n}\n\nfunction RelatedOrderSection({\n  apiBase,\n  detail,\n}: {\n  apiBase: ApiBase\n  detail: CouponEntitlementDetail\n}) {\n  const entitlement = detail.customer_coupon_entitlement\n  const order = detail.order || null\n  const orderId = order?.id || entitlement.order_id\n  if (!orderId) {\n    return null\n  }\n\n  return (\n    <Container className=\"p-0\">\n      <WidgetHeader title=\"Related Order\" />\n      <SidebarLink\n        href={orderDetailPath(apiBase, orderId)}\n        label={order ? orderDisplayId(order) : orderId}\n        description={\n          order?.created_at\n            ? `Order placed ${formatRelativeDate(order.created_at)}`\n            : \"Purchased coupon order\"\n        }\n        icon={<ShoppingCart />}\n      />\n    </Container>\n  )\n}\n\nfunction CouponSnapshotsSection({\n  detail,\n}: {\n  detail: CouponEntitlementDetail\n}) {\n  const entitlement = detail.customer_coupon_entitlement\n  const issuance = detail.coupon_issuance || null\n\n  return (\n    <Container className=\"p-0\">\n      <WidgetHeader title=\"JSON\" />\n      <div className=\"flex flex-col gap-y-3 px-6 pb-6\">\n        <SnapshotBlock\n          title=\"Benefit snapshot\"\n          value={entitlement.benefit_snapshot}\n        />\n        <SnapshotBlock\n          title=\"Source snapshot\"\n          value={entitlement.source_snapshot}\n        />\n        <SnapshotBlock\n          title=\"Issuance config snapshot\"\n          value={issuance?.config_snapshot}\n        />\n        <SnapshotBlock title=\"Seller targets\" value={entitlement.seller_targets} />\n        <SnapshotBlock title=\"Metadata\" value={entitlement.metadata} />\n      </div>\n    </Container>\n  )\n}\n\nfunction CouponSummarySections({\n  detail,\n}: {\n  detail: CouponEntitlementDetail\n}) {\n  const entitlement = detail.customer_coupon_entitlement\n  const issuance = detail.coupon_issuance || null\n  const benefitSnapshot = entitlement.benefit_snapshot || null\n  const sourceSnapshot = entitlement.source_snapshot || null\n  const order = detail.order || null\n  const lineTotal = snapshotNumber(sourceSnapshot, \"total\")\n  const external = entitlement.origin === \"external\"\n\n  return (\n    <>\n      <SummaryWidget\n        label=\"Benefit\"\n        value={benefitSnapshotLabel(benefitSnapshot)}\n      />\n      {!external && (\n        <SummaryWidget\n          label=\"Line Total\"\n          value={formatSnapshotAmount(lineTotal, order?.currency_code)}\n          tone=\"neutral\"\n        />\n      )}\n      {!external && (\n        <Container className=\"divide-y p-0\">\n          <WidgetHeader title=\"Campaign\" />\n          <SectionRow title=\"Campaign\" value={campaignSnapshotLabel(benefitSnapshot)} />\n          <SectionRow title=\"Promotion\" value={promotionSnapshotLabel(benefitSnapshot)} />\n          <SectionRow\n            title=\"Promotion status\"\n            value={snapshotString(benefitSnapshot, \"promotion_status\") || \"-\"}\n          />\n        </Container>\n      )}\n      {!external && (\n        <Container className=\"divide-y p-0\">\n          <WidgetHeader title=\"Issuance\" />\n          <SectionRow title=\"Status\" value={issuance?.status || \"-\"} />\n          <SectionRow\n            title=\"Issued / failed\"\n            value={\n              issuance\n                ? `${issuance.issued_count ?? 0} / ${issuance.failed_count ?? 0}`\n                : \"-\"\n            }\n          />\n          <SectionRow title=\"Config\" value={entitlement.config_id || \"-\"} />\n          <SectionRow\n            title=\"Variant config\"\n            value={entitlement.variant_config_id || \"-\"}\n          />\n        </Container>\n      )}\n    </>\n  )\n}\n\nexport function CouponDetailPageView({ apiBase }: { apiBase: ApiBase }) {\n  const id = currentCouponDetailId(apiBase)\n  const [detail, setDetail] = useState<CouponEntitlementDetail | null>(null)\n  const [loading, setLoading] = useState(true)\n  const [loadError, setLoadError] = useState<string | null>(null)\n\n  useEffect(() => {\n    let active = true\n    async function load() {\n      if (!id) {\n        setLoadError(\"Missing coupon id\")\n        setLoading(false)\n        return\n      }\n\n      setLoading(true)\n      setLoadError(null)\n\n      try {\n        const payload = await apiFetch<CouponEntitlementDetail>(\n          `${apiBase}/coupon-products/entitlements/${encodeURIComponent(id)}`,\n        )\n        if (active) {\n          setDetail(payload)\n        }\n      } catch (error) {\n        const message =\n          error instanceof Error\n            ? error.message\n            : \"Failed to load coupon details\"\n        if (active) {\n          setLoadError(message)\n          toast.error(message)\n        }\n      } finally {\n        if (active) {\n          setLoading(false)\n        }\n      }\n    }\n\n    void load()\n\n    return () => {\n      active = false\n    }\n  }, [apiBase, id])\n\n  if (loading) {\n    return <CouponEmptyState title=\"Loading coupon\" />\n  }\n\n  if (loadError) {\n    return <CouponEmptyState title={loadError} />\n  }\n\n  if (!detail) {\n    return <CouponEmptyState title=\"Coupon not found\" />\n  }\n\n  return (\n    <TwoColumnLayout\n      firstCol={\n        <>\n          <CouponGeneralSection detail={detail} />\n          <RelatedOrderSection apiBase={apiBase} detail={detail} />\n          <CouponSnapshotsSection detail={detail} />\n        </>\n      }\n      secondCol={<CouponSummarySections detail={detail} />}\n    />\n  )\n}\n\nfunction EntitlementsTable({\n  entitlements,\n  loading,\n  error,\n  onOpen,\n}: {\n  entitlements: CouponEntitlement[]\n  loading: boolean\n  error: string | null\n  onOpen: (entitlement: CouponEntitlement) => void\n}) {\n  if (loading) {\n    return <CouponEmptyState title=\"Loading coupons\" />\n  }\n  if (error) {\n    return <CouponEmptyState title={error} />\n  }\n  if (!entitlements.length) {\n    return (\n      <CouponEmptyState\n        title=\"No coupons found\"\n        description=\"Purchased coupons will appear here after they are issued.\"\n      />\n    )\n  }\n\n  return (\n    <Table>\n      <Table.Header>\n        <Table.Row>\n          <Table.HeaderCell>Status</Table.HeaderCell>\n          <Table.HeaderCell>Code</Table.HeaderCell>\n          <Table.HeaderCell>Date issued</Table.HeaderCell>\n          <Table.HeaderCell>Order</Table.HeaderCell>\n          <Table.HeaderCell>Customer</Table.HeaderCell>\n          <Table.HeaderCell>Origin</Table.HeaderCell>\n          <Table.HeaderCell>Seller scope</Table.HeaderCell>\n          <Table.HeaderCell>Source</Table.HeaderCell>\n          <Table.HeaderCell>Expires</Table.HeaderCell>\n        </Table.Row>\n      </Table.Header>\n      <Table.Body>\n        {entitlements.map((item) => (\n          <Table.Row\n            key={item.id}\n            className=\"cursor-pointer hover:bg-ui-bg-subtle\"\n            onClick={() => onOpen(item)}\n          >\n            <Table.Cell>\n              <StatusBadge color={entitlementStatusColor(item.status)}>\n                {item.status}\n              </StatusBadge>\n            </Table.Cell>\n            <Table.Cell>{item.code || item.shared_code || \"-\"}</Table.Cell>\n            <Table.Cell title={formatFullDate(item.created_at)}>\n              {formatRelativeDate(item.created_at)}\n            </Table.Cell>\n            <Table.Cell>{item.order_id || \"-\"}</Table.Cell>\n            <Table.Cell>{item.email || item.customer_id || \"-\"}</Table.Cell>\n            <Table.Cell>{entitlementSource(item)}</Table.Cell>\n            <Table.Cell>{entitlementSellerScope(item)}</Table.Cell>\n            <Table.Cell>\n              {snapshotString(item.source_snapshot, \"title\") ||\n                snapshotString(item.source_snapshot, \"source\") ||\n                item.product_id ||\n                \"External\"}\n            </Table.Cell>\n            <Table.Cell>{formatDate(item.expires_at)}</Table.Cell>\n          </Table.Row>\n        ))}\n      </Table.Body>\n    </Table>\n  )\n}\n\nexport function CouponsPageView({\n  apiBase,\n  title,\n}: {\n  apiBase: ApiBase\n  title: string\n}) {\n  const [entitlements, setEntitlements] = useState<CouponEntitlement[]>([])\n  const [loading, setLoading] = useState(true)\n  const [loadError, setLoadError] = useState<string | null>(null)\n  const [filter, setFilter] = useState<EntitlementFilter>(\"all\")\n\n  const load = useCallback(async () => {\n    setLoading(true)\n    setLoadError(null)\n    try {\n      const payload = await apiFetch<{\n        customer_coupon_entitlements: CouponEntitlement[]\n      }>(`${apiBase}/coupon-products/entitlements`)\n      setEntitlements(payload.customer_coupon_entitlements || [])\n    } catch (error) {\n      const message =\n        error instanceof Error ? error.message : \"Failed to load coupons\"\n      setLoadError(message)\n      toast.error(message)\n    } finally {\n      setLoading(false)\n    }\n  }, [apiBase])\n\n  useEffect(() => {\n    void load()\n  }, [load])\n\n  const openDetail = useCallback(\n    (entitlement: CouponEntitlement) => {\n      window.location.assign(couponDetailPath(apiBase, entitlement.id))\n    },\n    [apiBase],\n  )\n\n  return (\n    <Container className=\"divide-y p-0\">\n      <div className=\"flex items-center justify-between px-6 py-4\">\n        <Heading level=\"h1\">{title}</Heading>\n        <Button size=\"small\" variant=\"secondary\" onClick={() => void load()}>\n          <ArrowPath />\n          Refresh\n        </Button>\n      </div>\n      <Tabs\n        value={filter}\n        onValueChange={(value) => setFilter(value as EntitlementFilter)}\n      >\n        <div className=\"px-6 py-2 border-b\">\n          <Tabs.List>\n            {entitlementFilters.map((item) => (\n              <Tabs.Trigger key={item.value} value={item.value}>\n                {item.label}\n              </Tabs.Trigger>\n            ))}\n          </Tabs.List>\n        </div>\n        {entitlementFilters.map((item) => (\n          <Tabs.Content key={item.value} value={item.value}>\n            <EntitlementsTable\n              loading={loading}\n              error={loadError}\n              onOpen={openDetail}\n              entitlements={\n                item.value === \"all\"\n                  ? entitlements\n                  : entitlements.filter(\n                      (entitlement) => entitlement.status === item.value,\n                    )\n              }\n            />\n          </Tabs.Content>\n        ))}\n      </Tabs>\n    </Container>\n  )\n}\n\nexport function CouponProductsPageView({\n  apiBase,\n  title,\n  allowPromotionMirror = false,\n}: {\n  apiBase: ApiBase\n  title: string\n  allowPromotionMirror?: boolean\n}) {\n  return (\n    <CouponProductsPage\n      apiBase={apiBase}\n      title={title}\n      allowPromotionMirror={allowPromotionMirror}\n    />\n  )\n}\n\nfunction LegacyCouponProductsPageView({\n  apiBase,\n  title,\n  allowPromotionMirror = false,\n}: {\n  apiBase: ApiBase\n  title: string\n  allowPromotionMirror?: boolean\n}) {\n  const [products, setProducts] = useState<CouponProductRow[]>([])\n  const [options, setOptions] = useState<OptionsPayload>({})\n  const [loading, setLoading] = useState(true)\n  const [loadError, setLoadError] = useState<string | null>(null)\n  const [modalOpen, setModalOpen] = useState(false)\n  const [saving, setSaving] = useState(false)\n  const [activeStep, setActiveStep] = useState<WizardStep>(\"details\")\n  const [productForm, setProductForm] = useState<ProductFormState>(emptyProduct)\n  const [couponForm, setCouponForm] = useState<CouponFormState>(emptyCoupon)\n  const [campaignForm, setCampaignForm] =\n    useState<CampaignFormState>(emptyCampaign)\n  const prompt = usePrompt()\n\n  const couponBase = `${apiBase}/coupon-products`\n\n  const load = useCallback(async () => {\n    setLoading(true)\n    setLoadError(null)\n    try {\n      const [productsPayload, optionsPayload] = await Promise.all([\n        apiFetch<{ coupon_products: CouponProductRow[] }>(couponBase),\n        apiFetch<OptionsPayload>(`${couponBase}/options`),\n      ])\n      setProducts(productsPayload.coupon_products || [])\n      setOptions(optionsPayload || {})\n    } catch (error) {\n      const message =\n        error instanceof Error\n          ? error.message\n          : \"Failed to load coupon products\"\n      setLoadError(message)\n      toast.error(message)\n    } finally {\n      setLoading(false)\n    }\n  }, [couponBase])\n\n  useEffect(() => {\n    void load()\n  }, [load])\n\n  const optionDefaults = useMemo(\n    () => ({\n      sales_channel_id: options.sales_channels?.[0]?.id || \"\",\n      currency_code:\n        options.currencies?.find((currency) => currency.is_default)?.code ||\n        options.currencies?.[0]?.code ||\n        \"\",\n    }),\n    [options],\n  )\n\n  const currencies = options.currencies || []\n  const supportedCurrencyCodes = useMemo(\n    () => new Set(currencies.map((currency) => currency.code)),\n    [currencies],\n  )\n\n  const updateProduct =\n    (field: keyof ProductFormState) =>\n    (event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {\n      setProductForm((current) => ({\n        ...current,\n        [field]: event.target.value,\n      }))\n    }\n\n  const updateCoupon =\n    (field: keyof CouponFormState) =>\n    (event: ChangeEvent<HTMLInputElement>) => {\n      setCouponForm((current) => ({ ...current, [field]: event.target.value }))\n    }\n\n  const updateCampaign =\n    (field: keyof CampaignFormState) =>\n    (event: ChangeEvent<HTMLInputElement>) => {\n      setCampaignForm((current) => ({\n        ...current,\n        [field]: event.target.value,\n      }))\n    }\n\n  function openCreate() {\n    const currencyCode = optionDefaults.currency_code\n    setProductForm({\n      ...emptyProduct,\n      ...optionDefaults,\n      variants: [\n        {\n          ...emptyVariant,\n          currency_code: currencyCode,\n          override_currency_code: currencyCode,\n        },\n      ],\n    })\n    setCouponForm({ ...emptyCoupon, currency_code: currencyCode })\n    setCampaignForm(emptyCampaign)\n    setActiveStep(\"details\")\n    setModalOpen(true)\n  }\n\n  function openEdit(row: CouponProductRow) {\n    const forms = formFromRow(row, optionDefaults.currency_code)\n    setProductForm({\n      ...forms.product,\n      variants: forms.product.variants.length\n        ? forms.product.variants\n        : [{ ...emptyVariant }],\n    })\n    setCouponForm(forms.coupon)\n    setCampaignForm(forms.campaign)\n    setActiveStep(\"details\")\n    setModalOpen(true)\n  }\n\n  function setVariant(index: number, patch: Partial<VariantFormState>) {\n    setProductForm((current) => ({\n      ...current,\n      variants: current.variants.map((variant, variantIndex) =>\n        variantIndex === index ? { ...variant, ...patch } : variant,\n      ),\n    }))\n  }\n\n  function addVariant() {\n    const currencyCode =\n      couponForm.currency_code || optionDefaults.currency_code\n    setProductForm((current) => ({\n      ...current,\n      variants: [\n        ...current.variants,\n        {\n          ...emptyVariant,\n          currency_code: currencyCode,\n          override_currency_code: currencyCode,\n        },\n      ],\n    }))\n  }\n\n  function removeVariant(index: number) {\n    setProductForm((current) => ({\n      ...current,\n      variants: current.variants.filter(\n        (_, variantIndex) => variantIndex !== index,\n      ),\n    }))\n  }\n\n  function productPayload(includeVariants: boolean) {\n    const product: Record<string, unknown> = {\n      title: productForm.title,\n      subtitle: productForm.subtitle || null,\n      handle: productForm.handle || null,\n      description: productForm.description || null,\n      status: productForm.status,\n      thumbnail: productForm.thumbnail || null,\n      discountable: productForm.discountable,\n      type_id: productForm.type_id || null,\n      collection_id: productForm.collection_id || null,\n      categories: productForm.category_id\n        ? [{ id: productForm.category_id }]\n        : [],\n      tags: productForm.tag_id ? [{ id: productForm.tag_id }] : [],\n      sales_channels: productForm.sales_channel_id\n        ? [{ id: productForm.sales_channel_id }]\n        : [],\n    }\n\n    if (includeVariants) {\n      product.variants = productForm.variants.map((variant) => ({\n        title: variant.title,\n        sku: variant.sku || null,\n        manage_inventory: false,\n        allow_backorder: true,\n        prices: [\n          {\n            currency_code: variant.currency_code.trim().toLowerCase(),\n            amount: Number(variant.amount) || 0,\n          },\n        ],\n      }))\n    }\n\n    return product\n  }\n\n  function variantOverrides() {\n    return productForm.variants\n      .map((variant, index) => {\n        if (!variant.override_enabled) return null\n        return {\n          variant_index: index,\n          enabled: true,\n          benefit_type: variant.override_benefit_type,\n          amount:\n            variant.override_benefit_type === \"fixed_amount\"\n              ? numberOrNull(variant.override_amount)\n              : null,\n          percentage:\n            variant.override_benefit_type === \"percentage\"\n              ? numberOrNull(variant.override_percentage)\n              : null,\n          currency_code:\n            variant.override_benefit_type === \"fixed_amount\"\n              ? variant.override_currency_code.trim().toLowerCase() ||\n                couponForm.currency_code\n              : null,\n        }\n      })\n      .filter(Boolean)\n  }\n\n  function validateForm() {\n    if (!productForm.title.trim()) {\n      throw new Error(\"Product title is required\")\n    }\n    if (!productForm.id && !productForm.variants.length) {\n      throw new Error(\"At least one product variant is required\")\n    }\n    if (!currencies.length) {\n      throw new Error(\"Add a supported currency to the store before continuing\")\n    }\n    if (!productForm.id) {\n      for (const variant of productForm.variants) {\n        if (!supportedCurrencyCodes.has(variant.currency_code)) {\n          throw new Error(`Select an available currency for ${variant.title}`)\n        }\n      }\n    }\n    if (\n      couponForm.benefit_type === \"fixed_amount\" &&\n      numberOrNull(couponForm.amount) == null\n    ) {\n      throw new Error(\"A positive coupon amount is required\")\n    }\n    if (\n      couponForm.benefit_type === \"fixed_amount\" &&\n      !supportedCurrencyCodes.has(couponForm.currency_code)\n    ) {\n      throw new Error(\"Select an available coupon currency\")\n    }\n    if (couponForm.benefit_type === \"percentage\") {\n      const percentage = numberOrNull(couponForm.percentage)\n      if (percentage == null || percentage > 100) {\n        throw new Error(\"Coupon percentage must be between 1 and 100\")\n      }\n    }\n    if (\n      couponForm.code_strategy === \"shared_code\" &&\n      !couponForm.shared_code.trim()\n    ) {\n      throw new Error(\"A shared coupon code is required\")\n    }\n    if (couponForm.expiration_type === \"fixed\") {\n      const expiration = new Date(couponForm.expiration_date)\n      if (!couponForm.expiration_date || Number.isNaN(expiration.getTime())) {\n        throw new Error(\"A valid fixed expiration date is required\")\n      }\n    }\n    if (couponForm.expiration_cap_at) {\n      const expirationCap = new Date(couponForm.expiration_cap_at)\n      if (Number.isNaN(expirationCap.getTime())) {\n        throw new Error(\"A valid expiration cap date is required\")\n      }\n    }\n    for (const variant of productForm.variants) {\n      if (!variant.override_enabled) continue\n      if (\n        variant.override_benefit_type === \"fixed_amount\" &&\n        numberOrNull(variant.override_amount) == null\n      ) {\n        throw new Error(\n          `A positive coupon amount is required for ${variant.title}`,\n        )\n      }\n      if (\n        variant.override_benefit_type === \"fixed_amount\" &&\n        !supportedCurrencyCodes.has(variant.override_currency_code)\n      ) {\n        throw new Error(\n          `Select an available coupon currency for ${variant.title}`,\n        )\n      }\n      if (variant.override_benefit_type === \"percentage\") {\n        const percentage = numberOrNull(variant.override_percentage)\n        if (percentage == null || percentage > 100) {\n          throw new Error(\n            `Coupon percentage for ${variant.title} must be between 1 and 100`,\n          )\n        }\n      }\n    }\n    if (\n      allowPromotionMirror &&\n      campaignForm.mode === \"existing\" &&\n      !campaignForm.campaign_id\n    ) {\n      throw new Error(\"Select an existing campaign\")\n    }\n    if (\n      allowPromotionMirror &&\n      campaignForm.mode === \"new\" &&\n      (!campaignForm.name.trim() || !campaignForm.campaign_identifier.trim())\n    ) {\n      throw new Error(\"Campaign name and identifier are required\")\n    }\n  }\n\n  async function syncVariantOverrides(productId: string) {\n    await Promise.all(\n      productForm.variants.map(async (variant) => {\n        if (!variant.id) return\n\n        if (!variant.override_enabled) {\n          if (variant.override_config_id) {\n            await apiFetch(`${couponBase}/${productId}/variants`, {\n              method: \"POST\",\n              body: JSON.stringify({\n                variant_id: variant.id,\n                enabled: false,\n              }),\n            })\n          }\n          return\n        }\n\n        await apiFetch(`${couponBase}/${productId}/variants`, {\n          method: \"POST\",\n          body: JSON.stringify({\n            variant_id: variant.id,\n            enabled: true,\n            benefit_type: variant.override_benefit_type,\n            amount:\n              variant.override_benefit_type === \"fixed_amount\"\n                ? numberOrNull(variant.override_amount)\n                : null,\n            percentage:\n              variant.override_benefit_type === \"percentage\"\n                ? numberOrNull(variant.override_percentage)\n                : null,\n            currency_code:\n              variant.override_benefit_type === \"fixed_amount\"\n                ? variant.override_currency_code.trim().toLowerCase() ||\n                  couponForm.currency_code.trim().toLowerCase()\n                : null,\n          }),\n        })\n      }),\n    )\n  }\n\n  async function saveProduct() {\n    setSaving(true)\n    try {\n      validateForm()\n      const isEdit = Boolean(productForm.id)\n      const path = isEdit ? `${couponBase}/${productForm.id}` : couponBase\n      const method = isEdit ? \"PATCH\" : \"POST\"\n      const payload = {\n        product: productPayload(!isEdit),\n        coupon: buildCouponPayload(couponForm, allowPromotionMirror),\n        campaign: buildCampaignPayload(campaignForm, allowPromotionMirror),\n        seller_id: productForm.seller_id || null,\n        variant_overrides: isEdit ? [] : variantOverrides(),\n      }\n\n      await apiFetch(path, {\n        method,\n        body: JSON.stringify(payload),\n      })\n      if (isEdit) {\n        await syncVariantOverrides(productForm.id)\n      }\n      toast.success(\n        isEdit ? \"Coupon product updated\" : \"Coupon product created\",\n      )\n      setModalOpen(false)\n      await load()\n    } catch (error) {\n      toast.error(\n        error instanceof Error\n          ? error.message\n          : \"Failed to save coupon product\",\n      )\n    } finally {\n      setSaving(false)\n    }\n  }\n\n  async function deleteProduct(row: CouponProductRow) {\n    const confirmed = await prompt({\n      title: \"Remove coupon product?\",\n      description: `This removes coupon issuance from ${\n        row.product.title || row.product.id\n      }. The underlying Medusa product will remain available.`,\n      confirmText: \"Remove product\",\n      cancelText: \"Cancel\",\n      variant: \"danger\",\n    })\n    if (!confirmed) return\n\n    try {\n      await apiFetch(`${couponBase}/${row.product.id}`, { method: \"DELETE\" })\n      toast.success(\"Coupon configuration removed\")\n      await load()\n    } catch (error) {\n      toast.error(\n        error instanceof Error\n          ? error.message\n          : \"Failed to remove coupon product\",\n      )\n    }\n  }\n\n  async function mirrorPromotion(row: CouponProductRow) {\n    try {\n      await apiFetch(\n        `/admin/coupon-products/${row.product.id}/mirror-promotion`,\n        {\n          method: \"POST\",\n          body: JSON.stringify({}),\n        },\n      )\n      toast.success(\"Promotion mirror created\")\n    } catch (error) {\n      toast.error(error instanceof Error ? error.message : \"Mirror failed\")\n    }\n  }\n\n  const currentStepIndex = steps.indexOf(activeStep)\n  const canGoBack = currentStepIndex > 0\n  const canGoNext = currentStepIndex < steps.length - 1\n  const showCampaignStep = allowPromotionMirror\n  const visibleSteps = showCampaignStep\n    ? steps\n    : steps.filter((step) => step !== \"campaign\")\n\n  return (\n    <Container className=\"divide-y p-0\">\n      <div className=\"flex items-center justify-between px-6 py-4\">\n        <Heading level=\"h1\">{title}</Heading>\n        <div className=\"flex items-center gap-x-2\">\n          <Button size=\"small\" variant=\"secondary\" onClick={() => void load()}>\n            <ArrowPath />\n            Refresh\n          </Button>\n          <Button size=\"small\" onClick={openCreate}>\n            <Plus />\n            Create\n          </Button>\n        </div>\n      </div>\n      {loading ? (\n        <CouponEmptyState title=\"Loading coupon products\" />\n      ) : loadError ? (\n        <CouponEmptyState title={loadError} />\n      ) : products.length ? (\n        <Table>\n          <Table.Header>\n            <Table.Row>\n              <Table.HeaderCell>Product</Table.HeaderCell>\n              <Table.HeaderCell>Status</Table.HeaderCell>\n              <Table.HeaderCell>Benefit</Table.HeaderCell>\n              <Table.HeaderCell>Code</Table.HeaderCell>\n              <Table.HeaderCell>Campaign</Table.HeaderCell>\n              <Table.HeaderCell>Issued</Table.HeaderCell>\n              <Table.HeaderCell />\n            </Table.Row>\n          </Table.Header>\n          <Table.Body>\n            {products.map((row) => {\n              const config = row.coupon_product_config\n              return (\n                <Table.Row key={row.id}>\n                  <Table.Cell>\n                    <div className=\"flex flex-col\">\n                      <Text weight=\"plus\">\n                        {row.product.title || row.product.id}\n                      </Text>\n                      <Text size=\"small\" className=\"text-ui-fg-muted\">\n                        {row.product.handle || row.product.id}\n                      </Text>\n                    </div>\n                  </Table.Cell>\n                  <Table.Cell>\n                    <StatusBadge color={productStatusColor(row.product.status)}>\n                      {row.product.status || \"draft\"}\n                    </StatusBadge>\n                  </Table.Cell>\n                  <Table.Cell>{benefitLabel(config)}</Table.Cell>\n                  <Table.Cell>\n                    {config.code_strategy === \"shared_code\"\n                      ? config.shared_code || \"-\"\n                      : config.code_prefix || \"COUPON\"}\n                  </Table.Cell>\n                  <Table.Cell>{campaignLabel(config)}</Table.Cell>\n                  <Table.Cell>{row.entitlements_count || 0}</Table.Cell>\n                  <Table.Cell>\n                    <div className=\"flex justify-end gap-x-2\">\n                      {allowPromotionMirror && (\n                        <Button\n                          size=\"small\"\n                          variant=\"secondary\"\n                          onClick={() => void mirrorPromotion(row)}\n                        >\n                          Mirror\n                        </Button>\n                      )}\n                      <Button\n                        size=\"small\"\n                        variant=\"secondary\"\n                        onClick={() => openEdit(row)}\n                      >\n                        <PencilSquare />\n                        Edit\n                      </Button>\n                      <Button\n                        size=\"small\"\n                        variant=\"danger\"\n                        onClick={() => void deleteProduct(row)}\n                      >\n                        <Trash />\n                        Remove config\n                      </Button>\n                    </div>\n                  </Table.Cell>\n                </Table.Row>\n              )\n            })}\n          </Table.Body>\n        </Table>\n      ) : (\n        <CouponEmptyState\n          title=\"No coupon products found\"\n          description=\"Create a new coupon product to get started.\"\n        />\n      )}\n\n      <FocusModal open={modalOpen} onOpenChange={setModalOpen}>\n        <FocusModal.Content style={modalContentStyle}>\n          <FocusModal.Header style={modalStaticRowStyle}>\n            <FocusModal.Title>\n              {productForm.id ? \"Edit Coupon Product\" : \"Create Coupon Product\"}\n            </FocusModal.Title>\n          </FocusModal.Header>\n          <ProgressTabs\n            value={activeStep}\n            onValueChange={(value) => setActiveStep(value as WizardStep)}\n            style={modalWizardStyle}\n          >\n            <ProgressTabs.List className=\"border-b\" style={modalStaticRowStyle}>\n              {visibleSteps.map((step) => (\n                <ProgressTabs.Trigger\n                  key={step}\n                  value={step}\n                  status={stepStatus(step, activeStep)}\n                >\n                  {step === \"details\"\n                    ? \"Details\"\n                    : step === \"organize\"\n                      ? \"Organize\"\n                      : step === \"variants\"\n                        ? \"Variants\"\n                        : step === \"coupon\"\n                          ? \"Coupon\"\n                          : \"Campaign\"}\n                </ProgressTabs.Trigger>\n              ))}\n            </ProgressTabs.List>\n            <FocusModal.Body style={modalBodyStyle}>\n              <div style={modalFormStyle}>\n                <ProgressTabs.Content value=\"details\" style={stackStyle}>\n                  <div style={threeColumnGridStyle}>\n                    <Field label=\"Title\">\n                      <Input\n                        value={productForm.title}\n                        onChange={updateProduct(\"title\")}\n                      />\n                    </Field>\n                    <Field label=\"Subtitle\">\n                      <Input\n                        value={productForm.subtitle}\n                        onChange={updateProduct(\"subtitle\")}\n                      />\n                    </Field>\n                    <Field label=\"Handle\">\n                      <Input\n                        value={productForm.handle}\n                        onChange={updateProduct(\"handle\")}\n                      />\n                    </Field>\n                  </div>\n                  <div style={stackStyle}>\n                    <Field label=\"Description\">\n                      <Textarea\n                        value={productForm.description}\n                        onChange={updateProduct(\"description\")}\n                      />\n                    </Field>\n                    <Field label=\"Media URL\">\n                      <Input\n                        value={productForm.thumbnail}\n                        onChange={updateProduct(\"thumbnail\")}\n                      />\n                    </Field>\n                  </div>\n                </ProgressTabs.Content>\n\n                <ProgressTabs.Content value=\"organize\" style={stackStyle}>\n                  <div style={twoColumnGridStyle}>\n                    <Field label=\"Status\">\n                      <Select\n                        value={productForm.status}\n                        onValueChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            status: value,\n                          }))\n                        }\n                      >\n                        <Select.Trigger>\n                          <Select.Value />\n                        </Select.Trigger>\n                        <Select.Content>\n                          <Select.Item value=\"draft\">Draft</Select.Item>\n                          <Select.Item value=\"published\">Published</Select.Item>\n                          <Select.Item value=\"proposed\">Proposed</Select.Item>\n                          <Select.Item value=\"rejected\">Rejected</Select.Item>\n                        </Select.Content>\n                      </Select>\n                    </Field>\n                    {apiBase === \"/admin\" && !productForm.id && (\n                      <Field label=\"Seller\">\n                        <OptionSelect\n                          value={productForm.seller_id}\n                          options={options.sellers || []}\n                          onChange={(value) =>\n                            setProductForm((current) => ({\n                              ...current,\n                              seller_id: value,\n                            }))\n                          }\n                        />\n                      </Field>\n                    )}\n                    <Field label=\"Type\">\n                      <OptionSelect\n                        value={productForm.type_id}\n                        options={options.product_types || []}\n                        onChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            type_id: value,\n                          }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Collection\">\n                      <OptionSelect\n                        value={productForm.collection_id}\n                        options={options.product_collections || []}\n                        onChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            collection_id: value,\n                          }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Category\">\n                      <OptionSelect\n                        value={productForm.category_id}\n                        options={options.product_categories || []}\n                        onChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            category_id: value,\n                          }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Tag\">\n                      <OptionSelect\n                        value={productForm.tag_id}\n                        options={options.product_tags || []}\n                        onChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            tag_id: value,\n                          }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Sales channel\">\n                      <OptionSelect\n                        value={productForm.sales_channel_id}\n                        options={options.sales_channels || []}\n                        onChange={(value) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            sales_channel_id: value,\n                          }))\n                        }\n                      />\n                    </Field>\n                  </div>\n                  <div style={panelStyle}>\n                    <div style={rowBetweenStyle}>\n                      <div>\n                        <Text weight=\"plus\">Discountable</Text>\n                        <Text size=\"small\" className=\"text-ui-fg-muted\">\n                          Discounts can apply to this product\n                        </Text>\n                      </div>\n                      <Switch\n                        checked={productForm.discountable}\n                        onCheckedChange={(checked) =>\n                          setProductForm((current) => ({\n                            ...current,\n                            discountable: Boolean(checked),\n                          }))\n                        }\n                      />\n                    </div>\n                  </div>\n                </ProgressTabs.Content>\n\n                <ProgressTabs.Content value=\"variants\" style={stackStyle}>\n                  <div style={rowBetweenStyle}>\n                    <Heading level=\"h2\">Variants</Heading>\n                    {!productForm.id && (\n                      <Button\n                        size=\"small\"\n                        variant=\"secondary\"\n                        onClick={addVariant}\n                      >\n                        <Plus />\n                        Add variant\n                      </Button>\n                    )}\n                  </div>\n                  <div className=\"flex flex-col gap-y-4\">\n                    {productForm.variants.map((variant, index) => (\n                      <div key={`${variant.id || index}`} style={panelStyle}>\n                        <div style={fourColumnGridStyle}>\n                          <Field label=\"Title\">\n                            <Input\n                              value={variant.title}\n                              disabled={Boolean(productForm.id)}\n                              onChange={(event) =>\n                                setVariant(index, { title: event.target.value })\n                              }\n                            />\n                          </Field>\n                          <Field label=\"SKU\">\n                            <Input\n                              value={variant.sku}\n                              disabled={Boolean(productForm.id)}\n                              onChange={(event) =>\n                                setVariant(index, { sku: event.target.value })\n                              }\n                            />\n                          </Field>\n                          <Field label=\"Currency\">\n                            <CurrencySelect\n                              currencies={currencies}\n                              value={variant.currency_code}\n                              disabled={Boolean(productForm.id)}\n                              onChange={(currency_code) =>\n                                setVariant(index, {\n                                  currency_code,\n                                })\n                              }\n                            />\n                          </Field>\n                          <Field label=\"Price\">\n                            <CurrencyAmountInput\n                              currencies={currencies}\n                              currencyCode={variant.currency_code}\n                              value={variant.amount}\n                              disabled={Boolean(productForm.id)}\n                              onChange={(amount) =>\n                                setVariant(index, {\n                                  amount,\n                                })\n                              }\n                            />\n                          </Field>\n                        </div>\n                        <div\n                          style={{\n                            borderTop: \"1px solid var(--border-base)\",\n                            marginTop: 16,\n                            paddingTop: 16,\n                          }}\n                        >\n                          <div style={rowBetweenStyle}>\n                            <Text weight=\"plus\">Coupon benefit override</Text>\n                            <Switch\n                              checked={variant.override_enabled}\n                              onCheckedChange={(checked) =>\n                                setVariant(index, {\n                                  override_enabled: Boolean(checked),\n                                })\n                              }\n                            />\n                          </div>\n                          {variant.override_enabled && (\n                            <div\n                              style={{ ...fourColumnGridStyle, marginTop: 12 }}\n                            >\n                              <Field label=\"Benefit\">\n                                <Select\n                                  value={variant.override_benefit_type}\n                                  onValueChange={(value) =>\n                                    setVariant(index, {\n                                      override_benefit_type:\n                                        value as BenefitType,\n                                    })\n                                  }\n                                >\n                                  <Select.Trigger>\n                                    <Select.Value />\n                                  </Select.Trigger>\n                                  <Select.Content>\n                                    <Select.Item value=\"fixed_amount\">\n                                      Fixed amount\n                                    </Select.Item>\n                                    <Select.Item value=\"percentage\">\n                                      Percentage\n                                    </Select.Item>\n                                    <Select.Item value=\"free_shipping\">\n                                      Free shipping\n                                    </Select.Item>\n                                  </Select.Content>\n                                </Select>\n                              </Field>\n                              <Field label=\"Currency\">\n                                <CurrencySelect\n                                  currencies={currencies}\n                                  value={variant.override_currency_code}\n                                  disabled={\n                                    variant.override_benefit_type !==\n                                    \"fixed_amount\"\n                                  }\n                                  onChange={(override_currency_code) =>\n                                    setVariant(index, {\n                                      override_currency_code,\n                                    })\n                                  }\n                                />\n                              </Field>\n                              <Field label=\"Amount\">\n                                <CurrencyAmountInput\n                                  currencies={currencies}\n                                  currencyCode={variant.override_currency_code}\n                                  value={variant.override_amount}\n                                  disabled={\n                                    variant.override_benefit_type !==\n                                    \"fixed_amount\"\n                                  }\n                                  onChange={(override_amount) =>\n                                    setVariant(index, {\n                                      override_amount,\n                                    })\n                                  }\n                                />\n                              </Field>\n                              <Field label=\"Percentage\">\n                                <Input\n                                  type=\"number\"\n                                  value={variant.override_percentage}\n                                  disabled={\n                                    variant.override_benefit_type !==\n                                    \"percentage\"\n                                  }\n                                  onChange={(event) =>\n                                    setVariant(index, {\n                                      override_percentage: event.target.value,\n                                    })\n                                  }\n                                />\n                              </Field>\n                            </div>\n                          )}\n                          {!productForm.id &&\n                            productForm.variants.length > 1 && (\n                              <Button\n                                className=\"mt-4\"\n                                style={{ marginTop: 16 }}\n                                size=\"small\"\n                                variant=\"danger\"\n                                onClick={() => removeVariant(index)}\n                              >\n                                Remove variant\n                              </Button>\n                            )}\n                        </div>\n                      </div>\n                    ))}\n                  </div>\n                </ProgressTabs.Content>\n\n                <ProgressTabs.Content value=\"coupon\" style={stackStyle}>\n                  <div style={panelStyle}>\n                    <div style={rowBetweenStyle}>\n                      <div>\n                        <Text weight=\"plus\">Coupon issuance</Text>\n                        <Text size=\"small\" className=\"text-ui-fg-muted\">\n                          Issue coupons when customers purchase this product\n                        </Text>\n                      </div>\n                      <Switch\n                        checked={couponForm.enabled}\n                        onCheckedChange={(checked) =>\n                          setCouponForm((current) => ({\n                            ...current,\n                            enabled: Boolean(checked),\n                          }))\n                        }\n                      />\n                    </div>\n                  </div>\n                  <div style={twoColumnGridStyle}>\n                    <Field label=\"Benefit\">\n                      <Select\n                        value={couponForm.benefit_type}\n                        onValueChange={(value) =>\n                          setCouponForm((current) => ({\n                            ...current,\n                            benefit_type: value as BenefitType,\n                          }))\n                        }\n                      >\n                        <Select.Trigger>\n                          <Select.Value />\n                        </Select.Trigger>\n                        <Select.Content>\n                          <Select.Item value=\"fixed_amount\">\n                            Fixed amount\n                          </Select.Item>\n                          <Select.Item value=\"percentage\">\n                            Percentage\n                          </Select.Item>\n                          <Select.Item value=\"free_shipping\">\n                            Free shipping\n                          </Select.Item>\n                        </Select.Content>\n                      </Select>\n                    </Field>\n                    {allowPromotionMirror && (\n                      <Field label=\"Promotion status\">\n                        <Select\n                          value={couponForm.promotion_status}\n                          onValueChange={(value) =>\n                            setCouponForm((current) => ({\n                              ...current,\n                              promotion_status: value as PromotionStatus,\n                            }))\n                          }\n                        >\n                          <Select.Trigger>\n                            <Select.Value />\n                          </Select.Trigger>\n                          <Select.Content>\n                            <Select.Item value=\"draft\">Draft</Select.Item>\n                            <Select.Item value=\"active\">Active</Select.Item>\n                            <Select.Item value=\"inactive\">Inactive</Select.Item>\n                          </Select.Content>\n                        </Select>\n                      </Field>\n                    )}\n                    <Field label=\"Amount\">\n                      <CurrencyAmountInput\n                        currencies={currencies}\n                        currencyCode={couponForm.currency_code}\n                        disabled={couponForm.benefit_type !== \"fixed_amount\"}\n                        value={couponForm.amount}\n                        onChange={(amount) =>\n                          setCouponForm((current) => ({ ...current, amount }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Percentage\">\n                      <Input\n                        type=\"number\"\n                        disabled={couponForm.benefit_type !== \"percentage\"}\n                        value={couponForm.percentage}\n                        onChange={updateCoupon(\"percentage\")}\n                      />\n                    </Field>\n                    <Field label=\"Currency\">\n                      <CurrencySelect\n                        currencies={currencies}\n                        value={couponForm.currency_code}\n                        disabled={couponForm.benefit_type !== \"fixed_amount\"}\n                        onChange={(currency_code) =>\n                          setCouponForm((current) => ({\n                            ...current,\n                            currency_code,\n                          }))\n                        }\n                      />\n                    </Field>\n                    <Field label=\"Expiration policy\">\n                      <Select\n                        value={couponForm.expiration_type}\n                        onValueChange={(value) =>\n                          setCouponForm((current) => ({\n                            ...current,\n                            expiration_type: value as ExpirationPolicyType,\n                          }))\n                        }\n                      >\n                        <Select.Trigger>\n                          <Select.Value />\n                        </Select.Trigger>\n                        <Select.Content>\n                          <Select.Item value=\"duration\">\n                            Duration after issue\n                          </Select.Item>\n                          <Select.Item value=\"fixed\">Fixed date</Select.Item>\n                        </Select.Content>\n                      </Select>\n                    </Field>\n                    {couponForm.expiration_type === \"duration\" ? (\n                      <Field label=\"Expiration days\">\n                        <Input\n                          type=\"number\"\n                          min={1}\n                          value={couponForm.expiration_days}\n                          onChange={updateCoupon(\"expiration_days\")}\n                        />\n                      </Field>\n                    ) : (\n                      <Field label=\"Expires at\">\n                        <Input\n                          type=\"datetime-local\"\n                          value={couponForm.expiration_date}\n                          onChange={updateCoupon(\"expiration_date\")}\n                        />\n                      </Field>\n                    )}\n                    <Field label=\"Cap expiration\">\n                      <div style={rowBetweenStyle}>\n                        <Text size=\"small\" className=\"text-ui-fg-muted\">\n                          Campaign end or cap date\n                        </Text>\n                        <Switch\n                          checked={couponForm.expiration_cap_by_campaign}\n                          onCheckedChange={(checked) =>\n                            setCouponForm((current) => ({\n                              ...current,\n                              expiration_cap_by_campaign: Boolean(checked),\n                            }))\n                          }\n                        />\n                      </div>\n                    </Field>\n                    <Field label=\"Expiration cap date (optional)\">\n                      <Input\n                        type=\"datetime-local\"\n                        disabled={!couponForm.expiration_cap_by_campaign}\n                        value={couponForm.expiration_cap_at}\n                        onChange={updateCoupon(\"expiration_cap_at\")}\n                      />\n                    </Field>\n                    <Field label=\"Code strategy\">\n                      <Select\n                        value={couponForm.code_strategy}\n                        onValueChange={(value) =>\n                          setCouponForm((current) => ({\n                            ...current,\n                            code_strategy: value as CodeStrategy,\n                          }))\n                        }\n                      >\n                        <Select.Trigger>\n                          <Select.Value />\n                        </Select.Trigger>\n                        <Select.Content>\n                          <Select.Item value=\"unique_code\">\n                            Unique code\n                          </Select.Item>\n                          <Select.Item value=\"shared_code\">\n                            Shared code\n                          </Select.Item>\n                        </Select.Content>\n                      </Select>\n                    </Field>\n                    <Field label=\"Code prefix\">\n                      <Input\n                        disabled={couponForm.code_strategy !== \"unique_code\"}\n                        value={couponForm.code_prefix}\n                        onChange={updateCoupon(\"code_prefix\")}\n                      />\n                    </Field>\n                    <Field label=\"Shared code\">\n                      <Input\n                        disabled={couponForm.code_strategy !== \"shared_code\"}\n                        value={couponForm.shared_code}\n                        onChange={updateCoupon(\"shared_code\")}\n                      />\n                    </Field>\n                    <Field label=\"Max issuance per item\">\n                      <Input\n                        type=\"number\"\n                        value={couponForm.max_issuance_per_order_item}\n                        onChange={updateCoupon(\"max_issuance_per_order_item\")}\n                      />\n                    </Field>\n                    {allowPromotionMirror && (\n                      <Field label=\"Promotion mirror\">\n                        <Select\n                          value={couponForm.promotion_mirror_mode}\n                          onValueChange={(value) =>\n                            setCouponForm((current) => ({\n                              ...current,\n                              promotion_mirror_mode: value as MirrorMode,\n                            }))\n                          }\n                        >\n                          <Select.Trigger>\n                            <Select.Value />\n                          </Select.Trigger>\n                          <Select.Content>\n                            <Select.Item value=\"none\">None</Select.Item>\n                            <Select.Item value=\"manual\">Manual</Select.Item>\n                            <Select.Item value=\"auto\">Auto</Select.Item>\n                          </Select.Content>\n                        </Select>\n                      </Field>\n                    )}\n                  </div>\n                </ProgressTabs.Content>\n\n                {allowPromotionMirror && (\n                  <ProgressTabs.Content value=\"campaign\" style={stackStyle}>\n                    <div style={twoColumnGridStyle}>\n                      <Field label=\"Campaign\">\n                        <Select\n                          value={campaignForm.mode}\n                          onValueChange={(value) =>\n                            setCampaignForm((current) => ({\n                              ...current,\n                              mode: value as CampaignMode,\n                            }))\n                          }\n                        >\n                          <Select.Trigger>\n                            <Select.Value />\n                          </Select.Trigger>\n                          <Select.Content>\n                            <Select.Item value=\"none\">No campaign</Select.Item>\n                            <Select.Item value=\"existing\">\n                              Existing campaign\n                            </Select.Item>\n                            <Select.Item value=\"new\">New campaign</Select.Item>\n                          </Select.Content>\n                        </Select>\n                      </Field>\n                      {campaignForm.mode === \"existing\" && (\n                        <Field label=\"Existing campaign\">\n                          <OptionSelect\n                            value={campaignForm.campaign_id}\n                            options={options.campaigns || []}\n                            onChange={(value) =>\n                              setCampaignForm((current) => ({\n                                ...current,\n                                campaign_id: value,\n                              }))\n                            }\n                          />\n                        </Field>\n                      )}\n                      {campaignForm.mode === \"new\" && (\n                        <>\n                          <Field label=\"Name\">\n                            <Input\n                              value={campaignForm.name}\n                              onChange={updateCampaign(\"name\")}\n                            />\n                          </Field>\n                          <Field label=\"Identifier\">\n                            <Input\n                              value={campaignForm.campaign_identifier}\n                              onChange={updateCampaign(\"campaign_identifier\")}\n                            />\n                          </Field>\n                          <Field label=\"Starts at\">\n                            <Input\n                              type=\"datetime-local\"\n                              value={campaignForm.starts_at}\n                              onChange={updateCampaign(\"starts_at\")}\n                            />\n                          </Field>\n                          <Field label=\"Ends at\">\n                            <Input\n                              type=\"datetime-local\"\n                              value={campaignForm.ends_at}\n                              onChange={updateCampaign(\"ends_at\")}\n                            />\n                          </Field>\n                        </>\n                      )}\n                    </div>\n                  </ProgressTabs.Content>\n                )}\n              </div>\n            </FocusModal.Body>\n          </ProgressTabs>\n          <FocusModal.Footer style={modalStaticRowStyle}>\n            <Button variant=\"secondary\" onClick={() => setModalOpen(false)}>\n              Cancel\n            </Button>\n            {canGoBack && (\n              <Button\n                variant=\"secondary\"\n                onClick={() =>\n                  setActiveStep(visibleSteps[currentStepIndex - 1])\n                }\n              >\n                Back\n              </Button>\n            )}\n            {canGoNext &&\n            activeStep !== visibleSteps[visibleSteps.length - 1] ? (\n              <Button\n                onClick={() =>\n                  setActiveStep(visibleSteps[currentStepIndex + 1])\n                }\n              >\n                Continue\n              </Button>\n            ) : (\n              <Button isLoading={saving} onClick={() => void saveProduct()}>\n                Save\n              </Button>\n            )}\n          </FocusModal.Footer>\n        </FocusModal.Content>\n      </FocusModal>\n    </Container>\n  )\n}\n\nfunction OptionSelect({\n  value,\n  options,\n  onChange,\n}: {\n  value: string\n  options: OptionRecord[]\n  onChange: (value: string) => void\n}) {\n  return (\n    <Select\n      value={value || NONE}\n      onValueChange={(next) => onChange(next === NONE ? \"\" : next)}\n    >\n      <Select.Trigger>\n        <Select.Value />\n      </Select.Trigger>\n      <Select.Content>\n        <Select.Item value={NONE}>None</Select.Item>\n        {options.map((option) => (\n          <Select.Item key={option.id} value={option.id}>\n            {optionLabel(option)}\n          </Select.Item>\n        ))}\n      </Select.Content>\n    </Select>\n  )\n}\n", "import {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ChangeEvent,\n  type CSSProperties,\n  type DragEvent,\n  type ReactNode,\n} from \"react\"\nimport {\n  Adjustments,\n  ArrowPath,\n  ArrowUpTray,\n  InformationCircle,\n  PencilSquare,\n  Plus,\n  TaxExclusive,\n  TaxInclusive,\n  Trash,\n  XMarkMini,\n} from \"@medusajs/icons\"\nimport {\n  Button,\n  Checkbox,\n  Container,\n  CurrencyInput,\n  Divider,\n  DropdownMenu,\n  Drawer,\n  FocusModal,\n  Heading,\n  Input,\n  Label,\n  ProgressTabs,\n  RadioGroup,\n  Select,\n  StatusBadge,\n  Switch,\n  Table,\n  Text,\n  Textarea,\n  Tooltip,\n  toast,\n  usePrompt,\n} from \"@medusajs/ui\"\nimport { CouponEmptyState } from \"./empty-state\"\n\ndeclare const __BACKEND_URL__: string\n\ntype ApiBase = \"/admin\" | \"/vendor\"\ntype BenefitType = \"fixed_amount\" | \"percentage\" | \"free_shipping\" | \"buy_get\"\ntype CouponType =\n  | \"amount_off_products\"\n  | \"amount_off_order\"\n  | \"percentage_off_product\"\n  | \"percentage_off_order\"\n  | \"buy_x_get_y\"\n  | \"free_shipping\"\ntype CodeStrategy = \"unique_code\" | \"shared_code\"\ntype MirrorMode = \"none\" | \"manual\" | \"auto\"\ntype PromotionStatus = \"draft\" | \"active\" | \"inactive\"\ntype CampaignMode = \"none\" | \"existing\" | \"new\"\ntype ExpirationPolicyType = \"none\" | \"duration\" | \"fixed\"\ntype CouponAllocation = \"each\" | \"once\"\ntype WizardStep = \"details\" | \"organize\" | \"campaign\" | \"prices\"\ntype PurchaseConditionAttribute =\n  | \"customer.groups.id\"\n  | \"region.id\"\n  | \"shipping_address.country_code\"\n  | \"sales_channel_id\"\n  | \"currency_code\"\ntype PurchaseConditionOperator = \"in\" | \"eq\" | \"ne\"\n\ntype PurchaseConditionForm = {\n  key: string\n  attribute: PurchaseConditionAttribute | \"\"\n  operator: PurchaseConditionOperator | \"\"\n  values: string[]\n}\n\ntype OptionRecord = {\n  id: string\n  name?: string | null\n  title?: string | null\n  value?: string | null\n  handle?: string | null\n  campaign_identifier?: string | null\n  display_name?: string | null\n  iso_2?: string | null\n}\n\ntype CurrencyOption = {\n  code: string\n  name: string\n  symbol: string\n  symbol_native: string\n  is_default: boolean\n  is_tax_inclusive?: boolean\n}\n\ntype OptionsPayload = {\n  currencies?: CurrencyOption[]\n  product_types?: OptionRecord[]\n  product_collections?: OptionRecord[]\n  product_categories?: OptionRecord[]\n  product_tags?: OptionRecord[]\n  sales_channels?: OptionRecord[]\n  shipping_profiles?: OptionRecord[]\n  campaigns?: OptionRecord[]\n  sellers?: OptionRecord[]\n  customer_groups?: OptionRecord[]\n  regions?: OptionRecord[]\n  countries?: OptionRecord[]\n}\n\ntype CouponProductConfig = {\n  id: string\n  enabled: boolean\n  product_id: string\n  benefit_type: BenefitType\n  purchase_conditions?: Array<{\n    attribute: PurchaseConditionAttribute\n    operator: PurchaseConditionOperator\n    values: string[]\n  }> | null\n  amounts?: { currency_code: string; amount: number }[] | null\n  amount: number | null\n  percentage: number | null\n  currency_code: string | null\n  code_strategy: CodeStrategy\n  code_prefix: string | null\n  shared_code: string | null\n  expiration_policy:\n  | { type: \"none\" }\n  | {\n    type: \"duration\"\n    duration_days: number\n    cap_by_campaign?: boolean\n    cap_at?: string | null\n  }\n  | {\n    type: \"fixed\"\n    expires_at: string\n    cap_by_campaign?: boolean\n    cap_at?: string | null\n  }\n  max_issuance_per_order_item: number\n  promotion_mirror_mode: MirrorMode\n  promotion_status?: PromotionStatus | null\n  promotion_template?: Record<string, any> | null\n  campaign_id?: string | null\n  campaign_snapshot?: Record<string, unknown> | null\n}\n\ntype ProductRecord = {\n  id: string\n  title: string | null\n  subtitle?: string | null\n  handle: string | null\n  description?: string | null\n  status: string | null\n  thumbnail: string | null\n  thumbnail_asset_id?: string | null\n  images?: { id?: string; url?: string | null; asset_id?: string | null }[]\n  discountable?: boolean\n  type_id?: string | null\n  collection_id?: string | null\n  shipping_profile_id?: string | null\n  variants?: {\n    id: string\n    sku?: string | null\n    prices?: { currency_code?: string; amount?: number }[]\n  }[]\n  categories?: { id: string }[]\n  tags?: { id: string }[]\n  sales_channels?: { id: string; name?: string | null }[]\n}\n\ntype ProductMedia = {\n  url: string\n  asset_id?: string\n}\n\ntype CouponProductRow = {\n  id: string\n  product: ProductRecord\n  coupon_product_config: CouponProductConfig\n  entitlements_count: number\n}\n\ntype ProductFormState = {\n  title: string\n  subtitle: string\n  handle: string\n  description: string\n  media: ProductMedia[]\n  sku: string\n  price_amounts: Record<string, string>\n  status: string\n  discountable: boolean\n  seller_id: string\n  type_id: string\n  collection_id: string\n  category_id: string\n  tag_id: string\n}\n\ntype CouponFormState = {\n  enabled: boolean\n  type: CouponType\n  purchase_conditions: PurchaseConditionForm[]\n  amounts: CouponAmountFormRow[]\n  percentage: string\n  allocation: CouponAllocation\n  code_strategy: CodeStrategy\n  code_prefix: string\n  shared_code: string\n  expiration_type: ExpirationPolicyType\n  expiration_days: string\n  expiration_date: string\n  expiration_cap_by_campaign: boolean\n  expiration_cap_at: string\n  max_issuance_per_order_item: string\n  promotion_mirror_mode: MirrorMode\n  promotion_status: PromotionStatus\n}\n\ntype CouponAmountFormRow = {\n  key: string\n  currency_code: string\n  amount: string\n}\n\ntype CampaignFormState = {\n  mode: CampaignMode\n  campaign_id: string\n  name: string\n  campaign_identifier: string\n  starts_at: string\n  ends_at: string\n}\n\nconst NONE = \"__none__\"\nconst allSteps: WizardStep[] = [\"details\", \"organize\", \"campaign\", \"prices\"]\n\nconst conditionAttributes: Array<{\n  value: PurchaseConditionAttribute\n  label: string\n}> = [\n  { value: \"customer.groups.id\", label: \"Customer Group\" },\n  { value: \"region.id\", label: \"Region\" },\n  { value: \"shipping_address.country_code\", label: \"Country\" },\n  { value: \"sales_channel_id\", label: \"Sales Channel\" },\n  { value: \"currency_code\", label: \"Currency Code\" },\n]\n\nconst conditionOperators: Array<{\n  value: PurchaseConditionOperator\n  label: string\n}> = [\n  { value: \"in\", label: \"In\" },\n  { value: \"eq\", label: \"Equals\" },\n  { value: \"ne\", label: \"Not In\" },\n]\n\nexport const typeChoices: {\n  value: CouponType\n  label: string\n  description: string\n}[] = [\n    {\n      value: \"amount_off_products\",\n      label: \"Amount off products\",\n      description: \"Discount specific products or a collection of products\",\n    },\n    {\n      value: \"amount_off_order\",\n      label: \"Amount off order\",\n      description: \"Discount the total order amount\",\n    },\n    {\n      value: \"percentage_off_product\",\n      label: \"Percentage off product\",\n      description: \"Discount a percentage off selected products\",\n    },\n    {\n      value: \"percentage_off_order\",\n      label: \"Percentage off order\",\n      description: \"Discount a percentage off the total order amount\",\n    },\n    {\n      value: \"buy_x_get_y\",\n      label: \"Buy X Get Y\",\n      description: \"Issue a Buy X Get Y coupon entitlement\",\n    },\n    {\n      value: \"free_shipping\",\n      label: \"Free shipping\",\n      description: \"Apply a 100% discount to shipping fees\",\n    },\n  ]\n\nconst statusChoices: {\n  value: PromotionStatus\n  label: string\n  description: string\n}[] = [\n    {\n      value: \"draft\",\n      label: \"Draft\",\n      description: \"Customers will not be able to use the code yet\",\n    },\n    {\n      value: \"active\",\n      label: \"Active\",\n      description: \"Customers will be able to use the code\",\n    },\n    {\n      value: \"inactive\",\n      label: \"Inactive\",\n      description: \"Keep the promotion unavailable until reactivated\",\n    },\n  ]\n\nfunction backendUrl() {\n  return typeof __BACKEND_URL__ === \"string\"\n    ? __BACKEND_URL__.replace(/\\/$/, \"\")\n    : \"\"\n}\n\nfunction apiErrorMessage(payload: any, fallback: string) {\n  return (\n    [payload?.message, payload?.error?.message, payload?.error].find(\n      (candidate) => typeof candidate === \"string\" && candidate.trim(),\n    ) ||\n    fallback ||\n    \"Request failed\"\n  )\n}\n\nasync function apiFetch<T>(\n  path: string,\n  options: RequestInit = {},\n): Promise<T> {\n  const response = await fetch(`${backendUrl()}${path}`, {\n    ...options,\n    credentials: \"include\",\n    headers: {\n      ...(options.body ? { \"Content-Type\": \"application/json\" } : {}),\n      ...options.headers,\n    },\n  })\n\n  if (!response.ok) {\n    const payload = await response.json().catch(() => null)\n    throw new Error(apiErrorMessage(payload, response.statusText))\n  }\n\n  return response.json()\n}\n\nfunction optionLabel(option: OptionRecord) {\n  return (\n    option.name || option.title || option.value || option.handle || option.id\n  )\n}\n\nfunction numberOrNull(value: string) {\n  const parsed = Number(value)\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : null\n}\n\nfunction nonNegativeNumberOrNull(value: string) {\n  if (!value.trim()) return null\n  const parsed = Number(value)\n  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null\n}\n\nfunction toDateTimeLocal(value?: string | null) {\n  if (!value) return \"\"\n  const date = new Date(value)\n  if (Number.isNaN(date.getTime())) return \"\"\n  const localDate = new Date(date.getTime() - date.getTimezoneOffset() * 60_000)\n  return localDate.toISOString().slice(0, 16)\n}\n\nfunction currencyDecimalDigits(code: string) {\n  try {\n    return new Intl.NumberFormat(\"en\", {\n      style: \"currency\",\n      currency: code.toUpperCase(),\n    }).resolvedOptions().maximumFractionDigits\n  } catch {\n    return 2\n  }\n}\n\nfunction currencySymbol(code: string) {\n  if (!code) return \"\"\n  try {\n    return (\n      new Intl.NumberFormat(\"en\", {\n        style: \"currency\",\n        currency: code.toUpperCase(),\n        currencyDisplay: \"narrowSymbol\",\n      })\n        .formatToParts(0)\n        .find((part) => part.type === \"currency\")?.value || code.toUpperCase()\n    )\n  } catch {\n    return code.toUpperCase()\n  }\n}\n\nexport function couponTypeFromConfig(config: CouponProductConfig): CouponType {\n  if (config.benefit_type === \"percentage\") {\n    return config.promotion_template?.application_method?.target_type === \"order\"\n      ? \"percentage_off_order\"\n      : \"percentage_off_product\"\n  }\n  if (config.benefit_type === \"buy_get\") return \"buy_x_get_y\"\n  if (config.benefit_type === \"free_shipping\") return \"free_shipping\"\n\n  return config.promotion_template?.application_method?.target_type === \"order\"\n    ? \"amount_off_order\"\n    : \"amount_off_products\"\n}\n\nfunction benefitTypeFromCouponType(type: CouponType): BenefitType {\n  if (\n    type === \"percentage_off_product\" ||\n    type === \"percentage_off_order\"\n  ) return \"percentage\"\n  if (type === \"buy_x_get_y\") return \"buy_get\"\n  if (type === \"free_shipping\") return \"free_shipping\"\n  return \"fixed_amount\"\n}\n\nfunction couponTypeLabel(config: CouponProductConfig) {\n  return typeChoices.find(\n    (choice) => choice.value === couponTypeFromConfig(config),\n  )?.label\n}\n\nfunction couponStatusColor(status?: PromotionStatus | null) {\n  if (status === \"active\") return \"green\" as const\n  if (status === \"inactive\") return \"orange\" as const\n  return \"grey\" as const\n}\n\nfunction productStatusFromCouponStatus(status: PromotionStatus) {\n  return status === \"active\" ? \"published\" : \"draft\"\n}\n\nfunction campaignLabel(config: CouponProductConfig) {\n  const name = config.campaign_snapshot?.name\n  return typeof name === \"string\" && name ? name : config.campaign_id || \"None\"\n}\n\nfunction defaultCurrency(options: OptionsPayload) {\n  return (\n    options.currencies?.find((currency) => currency.is_default)?.code ||\n    options.currencies?.[0]?.code ||\n    \"\"\n  )\n}\n\nfunction conditionKey(prefix = \"condition\") {\n  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`\n}\n\nfunction isAmountCouponType(type: CouponType) {\n  return type === \"amount_off_products\" || type === \"amount_off_order\"\n}\n\nexport function effectiveCouponCurrencies(\n  conditions: PurchaseConditionForm[],\n  currencies: CurrencyOption[],\n) {\n  const condition = conditions.find(\n    (item) => item.attribute === \"currency_code\",\n  )\n  if (!condition || !condition.operator) return []\n  const selected = new Set(condition.values)\n  const supported = currencies.map((currency) => currency.code)\n\n  return condition.operator === \"ne\"\n    ? supported.filter((code) => !selected.has(code))\n    : supported.filter((code) => selected.has(code))\n}\n\nexport function reconcileCouponAmounts(\n  current: CouponAmountFormRow[],\n  currencyCodes: string[],\n) {\n  const byCurrency = Object.fromEntries(\n    current.map((row) => [row.currency_code, row]),\n  )\n  return currencyCodes.map((currencyCode) => ({\n    key: byCurrency[currencyCode]?.key || conditionKey(\"coupon-value\"),\n    currency_code: currencyCode,\n    amount: byCurrency[currencyCode]?.amount || \"\",\n  }))\n}\n\nfunction defaultPurchaseConditions(options: OptionsPayload) {\n  const currencyCode = defaultCurrency(options)\n  return currencyCode\n    ? [\n      {\n        key: conditionKey(\"currency\"),\n        attribute: \"currency_code\" as const,\n        operator: \"eq\" as const,\n        values: [currencyCode],\n      },\n    ]\n    : []\n}\n\nfunction emptyProduct(options: OptionsPayload): ProductFormState {\n  return {\n    title: \"\",\n    subtitle: \"\",\n    handle: \"\",\n    description: \"\",\n    media: [],\n    sku: \"\",\n    price_amounts: Object.fromEntries(\n      (options.currencies || []).map((currency) => [currency.code, \"\"]),\n    ),\n    status: \"draft\",\n    discountable: false,\n    seller_id: \"\",\n    type_id: \"\",\n    collection_id: \"\",\n    category_id: \"\",\n    tag_id: \"\",\n  }\n}\n\nfunction emptyCoupon(options: OptionsPayload): CouponFormState {\n  const currencyCode = defaultCurrency(options)\n  const purchaseConditions = defaultPurchaseConditions(options)\n  return {\n    enabled: true,\n    type: \"amount_off_products\",\n    purchase_conditions: purchaseConditions,\n    amounts: currencyCode\n      ? [\n        {\n          key: \"coupon-value-default\",\n          currency_code: currencyCode,\n          amount: \"\",\n        },\n      ]\n      : [],\n    percentage: \"\",\n    allocation: \"each\",\n    code_strategy: \"unique_code\",\n    code_prefix: \"COUPON\",\n    shared_code: \"\",\n    expiration_type: \"duration\",\n    expiration_days: \"30\",\n    expiration_date: \"\",\n    expiration_cap_by_campaign: true,\n    expiration_cap_at: \"\",\n    max_issuance_per_order_item: \"1\",\n    promotion_mirror_mode: \"none\",\n    promotion_status: \"draft\",\n  }\n}\n\nconst emptyCampaign: CampaignFormState = {\n  mode: \"none\",\n  campaign_id: \"\",\n  name: \"\",\n  campaign_identifier: \"\",\n  starts_at: \"\",\n  ends_at: \"\",\n}\n\nfunction formsFromRow(\n  row: CouponProductRow,\n  options: OptionsPayload,\n): {\n  product: ProductFormState\n  coupon: CouponFormState\n  campaign: CampaignFormState\n} {\n  const product = row.product\n  const config = row.coupon_product_config\n  const variant = product.variants?.[0]\n  const prices = Object.fromEntries(\n    (variant?.prices || [])\n      .filter((price) => price.currency_code)\n      .map((price) => [\n        String(price.currency_code).toLowerCase(),\n        price.amount == null ? \"\" : String(price.amount),\n      ]),\n  )\n  const media = Array.from(\n    new Map(\n      [\n        ...(product.thumbnail\n          ? [\n              {\n                url: product.thumbnail,\n                asset_id: product.thumbnail_asset_id || undefined,\n              },\n            ]\n          : []),\n        ...(product.images || [])\n          .filter((image) => image.url)\n          .map((image) => ({\n            url: String(image.url),\n            asset_id: image.asset_id || undefined,\n          })),\n      ].map((item) => [item.url, item]),\n    ).values(),\n  )\n  const configuredAmounts =\n    Array.isArray(config.amounts) && config.amounts.length\n      ? config.amounts\n      : config.amount != null && config.currency_code\n        ? [{ amount: config.amount, currency_code: config.currency_code }]\n        : []\n  const configuredConditions = (config.purchase_conditions || []).map(\n    (condition, index) => ({\n      key: `condition-${index}`,\n      attribute: condition.attribute,\n      operator: condition.operator,\n      values: condition.values.map((value) =>\n        condition.attribute === \"currency_code\" ||\n          condition.attribute === \"shipping_address.country_code\"\n          ? value.toLowerCase()\n          : value,\n      ),\n    }),\n  )\n  if (\n    !configuredConditions.some(\n      (condition) => condition.attribute === \"currency_code\",\n    ) &&\n    config.benefit_type === \"fixed_amount\" &&\n    configuredAmounts.length\n  ) {\n    configuredConditions.push({\n      key: \"condition-legacy-currency\",\n      attribute: \"currency_code\",\n      operator: configuredAmounts.length === 1 ? \"eq\" : \"in\",\n      values: configuredAmounts.map((amount) =>\n        amount.currency_code.toLowerCase(),\n      ),\n    })\n  }\n  if (\n    !configuredConditions.some(\n      (condition) => condition.attribute === \"sales_channel_id\",\n    ) &&\n    product.sales_channels?.length\n  ) {\n    configuredConditions.push({\n      key: \"condition-legacy-sales-channel\",\n      attribute: \"sales_channel_id\",\n      operator: product.sales_channels.length === 1 ? \"eq\" : \"in\",\n      values: product.sales_channels.map((channel) => channel.id),\n    })\n  }\n  const expirationPolicy = config.expiration_policy\n  const configuredAmountRows = configuredAmounts.map((row, index) => ({\n    key: `coupon-value-${index}`,\n    amount: String(row.amount),\n    currency_code: row.currency_code.toLowerCase(),\n  }))\n  const amountRows =\n    config.benefit_type === \"fixed_amount\"\n      ? reconcileCouponAmounts(\n        configuredAmountRows,\n        effectiveCouponCurrencies(configuredConditions, options.currencies || []),\n      )\n      : configuredAmountRows\n\n  return {\n    product: {\n      ...emptyProduct(options),\n      title: product.title || \"\",\n      subtitle: product.subtitle || \"\",\n      handle: product.handle || \"\",\n      description: product.description || \"\",\n      media,\n      sku: variant?.sku || \"\",\n      price_amounts: {\n        ...emptyProduct(options).price_amounts,\n        ...prices,\n      },\n      status: product.status || \"draft\",\n      discountable: Boolean(product.discountable),\n      type_id: product.type_id || \"\",\n      collection_id: product.collection_id || \"\",\n      category_id: product.categories?.[0]?.id || \"\",\n      tag_id: product.tags?.[0]?.id || \"\",\n    },\n    coupon: {\n      ...emptyCoupon(options),\n      enabled: config.enabled,\n      type: couponTypeFromConfig(config),\n      purchase_conditions: configuredConditions,\n      amounts:\n        config.benefit_type === \"fixed_amount\"\n          ? amountRows\n          : amountRows.length\n            ? amountRows\n            : emptyCoupon(options).amounts,\n      percentage: config.percentage == null ? \"\" : String(config.percentage),\n      allocation:\n        config.promotion_template?.application_method?.allocation === \"once\"\n          ? (\"once\" as const)\n          : (\"each\" as const),\n      code_strategy: config.code_strategy,\n      code_prefix: config.code_prefix || \"\",\n      shared_code: config.shared_code || \"\",\n      expiration_type: config.expiration_policy?.type || \"duration\",\n      expiration_days:\n        config.expiration_policy?.type === \"duration\"\n          ? String(config.expiration_policy.duration_days)\n          : \"30\",\n      expiration_date:\n        config.expiration_policy?.type === \"fixed\"\n          ? toDateTimeLocal(config.expiration_policy.expires_at)\n          : \"\",\n      expiration_cap_by_campaign:\n        expirationPolicy.type === \"none\" ||\n        expirationPolicy.cap_by_campaign !== false,\n      expiration_cap_at:\n        expirationPolicy.type === \"none\"\n          ? \"\"\n          : toDateTimeLocal(expirationPolicy.cap_at),\n      max_issuance_per_order_item: String(\n        config.max_issuance_per_order_item || 1,\n      ),\n      promotion_mirror_mode: config.promotion_mirror_mode || \"none\",\n      promotion_status: config.promotion_status || \"draft\",\n    },\n    campaign: {\n      ...emptyCampaign,\n      mode: config.campaign_id ? (\"existing\" as const) : (\"none\" as const),\n      campaign_id: config.campaign_id || \"\",\n    },\n  }\n}\n\nconst modalContentStyle: CSSProperties = {\n  display: \"flex\",\n  flexDirection: \"column\",\n  overflow: \"hidden\",\n}\n\nconst modalWizardStyle: CSSProperties = {\n  display: \"flex\",\n  flex: \"1 1 auto\",\n  flexDirection: \"column\",\n  minHeight: 0,\n  overflow: \"hidden\",\n}\n\nconst visuallyHiddenStyle: CSSProperties = {\n  clip: \"rect(0 0 0 0)\",\n  clipPath: \"inset(50%)\",\n  height: 1,\n  overflow: \"hidden\",\n  position: \"absolute\",\n  whiteSpace: \"nowrap\",\n  width: 1,\n}\n\nconst modalBodyStyle: CSSProperties = {\n  flex: \"1 1 auto\",\n  minHeight: 0,\n  padding: 0,\n}\n\nconst modalScrollStyle: CSSProperties = {\n  height: \"100%\",\n  overflowY: \"auto\",\n  padding: \"64px 24px 112px\",\n  width: \"100%\",\n}\n\nconst modalFormStyle: CSSProperties = {\n  margin: \"0 auto\",\n  maxWidth: 720,\n  width: \"min(720px, 100%)\",\n}\n\nconst stackStyle: CSSProperties = {\n  display: \"flex\",\n  flexDirection: \"column\",\n  gap: 24,\n}\n\nconst twoColumnGridStyle: CSSProperties = {\n  display: \"grid\",\n  gap: 16,\n  gridTemplateColumns: \"repeat(auto-fit, minmax(260px, 1fr))\",\n}\n\nconst threeColumnGridStyle: CSSProperties = {\n  display: \"grid\",\n  gap: 16,\n  gridTemplateColumns: \"repeat(auto-fit, minmax(180px, 1fr))\",\n}\n\nconst panelStyle: CSSProperties = {\n  border: \"1px solid var(--border-base)\",\n  borderRadius: 8,\n  padding: 16,\n}\n\nfunction Field({\n  children,\n  label,\n  optional,\n  tooltip,\n}: {\n  children: ReactNode\n  label: string\n  optional?: boolean\n  tooltip?: string\n}) {\n  return (\n    <div className=\"flex flex-col gap-y-1\" style={{ minWidth: 0 }}>\n      <div className=\"flex items-center gap-x-1\">\n        <Label>{label}</Label>\n        {tooltip && (\n          <Tooltip content={tooltip}>\n            <button\n              type=\"button\"\n              aria-label={`${label} information`}\n              className=\"text-ui-fg-muted\"\n            >\n              <InformationCircle />\n            </button>\n          </Tooltip>\n        )}\n        {optional && (\n          <Text size=\"small\" className=\"text-ui-fg-muted\">\n            (Optional)\n          </Text>\n        )}\n      </div>\n      {children}\n    </div>\n  )\n}\n\nfunction Section({\n  children,\n  description,\n  title,\n}: {\n  children: ReactNode\n  description?: string\n  title: string\n}) {\n  return (\n    <section className=\"flex flex-col gap-y-4\">\n      <div>\n        <Heading level=\"h2\">{title}</Heading>\n        {description && (\n          <Text size=\"small\" className=\"text-ui-fg-muted\">\n            {description}\n          </Text>\n        )}\n      </div>\n      {children}\n    </section>\n  )\n}\n\nfunction OptionSelect({\n  onChange,\n  options,\n  value,\n}: {\n  onChange: (value: string) => void\n  options: OptionRecord[]\n  value: string\n}) {\n  return (\n    <Select\n      value={value || NONE}\n      onValueChange={(next) => onChange(next === NONE ? \"\" : next)}\n    >\n      <Select.Trigger>\n        <Select.Value />\n      </Select.Trigger>\n      <Select.Content>\n        <Select.Item value={NONE}>None</Select.Item>\n        {options.map((option) => (\n          <Select.Item key={option.id} value={option.id}>\n            {optionLabel(option)}\n          </Select.Item>\n        ))}\n      </Select.Content>\n    </Select>\n  )\n}\n\nfunction CurrencySelect({\n  currencies,\n  onChange,\n  value,\n}: {\n  currencies: CurrencyOption[]\n  onChange: (value: string) => void\n  value: string\n}) {\n  return (\n    <Select\n      value={value || undefined}\n      disabled={!currencies.length}\n      onValueChange={onChange}\n    >\n      <Select.Trigger>\n        <Select.Value\n          placeholder={\n            currencies.length ? \"Select currency\" : \"No currencies available\"\n          }\n        />\n      </Select.Trigger>\n      <Select.Content>\n        {currencies.map((currency) => (\n          <Select.Item key={currency.code} value={currency.code}>\n            {currency.name} ({currency.code.toUpperCase()})\n          </Select.Item>\n        ))}\n      </Select.Content>\n    </Select>\n  )\n}\n\nfunction CurrencyAmountField({\n  currencies,\n  currencyCode,\n  onChange,\n  value,\n}: {\n  currencies: CurrencyOption[]\n  currencyCode: string\n  onChange: (value: string) => void\n  value: string\n}) {\n  const currency = currencies.find((item) => item.code === currencyCode)\n  const code = currencyCode.toUpperCase()\n  const decimals = currencyDecimalDigits(code || \"USD\")\n  return (\n    <CurrencyInput\n      code={code || \"USD\"}\n      symbol={\n        currency?.symbol_native ||\n        currency?.symbol ||\n        currencySymbol(code || \"USD\")\n      }\n      min={0}\n      decimalScale={decimals}\n      decimalsLimit={decimals}\n      value={value}\n      disabled={!currencyCode}\n      onValueChange={(nextValue) => onChange(nextValue || \"\")}\n    />\n  )\n}\n\nfunction PercentageInput({\n  onChange,\n  value,\n}: {\n  onChange: (value: string) => void\n  value: string\n}) {\n  return (\n    <div className=\"flex w-full items-stretch\" style={{ width: \"100%\" }}>\n      <div\n        className=\"bg-ui-bg-field text-ui-fg-muted flex items-center border\"\n        style={{\n          borderColor: \"var(--border-base)\",\n          borderRadius: \"6px 0 0 6px\",\n          borderRight: 0,\n          padding: \"0 12px\",\n        }}\n      >\n        %\n      </div>\n      <div\n        className=\"min-w-0 flex-1\"\n        style={{ flex: \"1 1 0%\", minWidth: 0 }}\n      >\n        <Input\n          className=\"w-full\"\n          type=\"number\"\n          min={1}\n          max={100}\n          value={value}\n          style={{\n            borderRadius: \"0 6px 6px 0\",\n            width: \"100%\",\n          }}\n          onChange={(event) => onChange(event.target.value)}\n        />\n      </div>\n    </div>\n  )\n}\n\nfunction HandleInput({\n  onChange,\n  value,\n}: {\n  onChange: (value: string) => void\n  value: string\n}) {\n  return (\n    <div className=\"relative\">\n      <div className=\"text-ui-fg-muted pointer-events-none absolute inset-y-0 left-0 z-10 flex min-w-8 items-center justify-center border-r px-2.5\">\n        <span className=\"txt-compact-small font-medium\">/</span>\n      </div>\n      <Input\n        value={value}\n        placeholder=\"winter-jacket\"\n        style={{ paddingLeft: 34 }}\n        onChange={(event) => onChange(event.target.value)}\n      />\n    </div>\n  )\n}\n\nfunction MediaUpload({\n  isUploading,\n  media,\n  onRemove,\n  onUpload,\n}: {\n  isUploading: boolean\n  media: ProductMedia[]\n  onRemove: (media: ProductMedia) => void\n  onUpload: (files: File[]) => void\n}) {\n  const inputRef = useRef<HTMLInputElement>(null)\n  const accept =\n    \"image/jpeg,image/png,image/gif,image/webp,image/heic,image/svg+xml\"\n\n  const handleFiles = (files: FileList | null) => {\n    if (!files?.length) return\n    onUpload(Array.from(files))\n  }\n\n  const handleDrop = (event: DragEvent<HTMLButtonElement>) => {\n    event.preventDefault()\n    handleFiles(event.dataTransfer.files)\n  }\n\n  return (\n    <div className=\"flex flex-col gap-y-3\">\n      {media.length > 0 && (\n        <div\n          className=\"grid gap-3\"\n          style={{\n            gridTemplateColumns: \"repeat(auto-fill, minmax(120px, 1fr))\",\n          }}\n        >\n          {media.map((item, index) => (\n            <div\n              key={item.asset_id || item.url}\n              className=\"relative overflow-hidden rounded-md border\"\n            >\n              <img\n                src={item.url}\n                alt=\"\"\n                className=\"h-32 w-full object-cover\"\n                style={{ height: 128 }}\n              />\n              <div className=\"absolute inset-x-0 bottom-0 flex items-center justify-between bg-black/60 px-2 py-1\">\n                <Text size=\"xsmall\" style={{ color: \"white\" }}>\n                  {index === 0 ? \"Thumbnail\" : `Image ${index + 1}`}\n                </Text>\n                <button\n                  type=\"button\"\n                  aria-label=\"Remove image\"\n                  style={{ color: \"white\" }}\n                  onClick={() => onRemove(item)}\n                >\n                  <XMarkMini />\n                </button>\n              </div>\n            </div>\n          ))}\n        </div>\n      )}\n      <input\n        ref={inputRef}\n        type=\"file\"\n        hidden\n        multiple\n        accept={accept}\n        onChange={(event) => {\n          handleFiles(event.target.files)\n          event.target.value = \"\"\n        }}\n      />\n      <button\n        type=\"button\"\n        disabled={isUploading}\n        className=\"text-ui-fg-muted flex w-full flex-col items-center justify-center gap-y-2 rounded-md border border-dashed p-8\"\n        style={{ minHeight: 148 }}\n        onClick={() => inputRef.current?.click()}\n        onDragOver={(event) => event.preventDefault()}\n        onDrop={handleDrop}\n      >\n        <span className=\"text-ui-fg-base flex items-center gap-x-2\">\n          <ArrowUpTray />\n          {isUploading ? \"Uploading images...\" : \"Upload images\"}\n        </span>\n        <Text size=\"small\" className=\"text-ui-fg-muted\">\n          Drag and drop images here or click to upload.\n        </Text>\n      </button>\n    </div>\n  )\n}\n\ntype ConditionValueOption = { value: string; label: string }\n\nfunction conditionValueOptions(\n  attribute: PurchaseConditionAttribute | \"\",\n  options: OptionsPayload,\n): ConditionValueOption[] {\n  if (attribute === \"currency_code\") {\n    return (options.currencies || []).map((currency) => ({\n      value: currency.code,\n      label: `${currency.name} (${currency.code.toUpperCase()})`,\n    }))\n  }\n  if (attribute === \"shipping_address.country_code\") {\n    return (options.countries || []).map((country) => ({\n      value: String(country.iso_2 || country.id).toLowerCase(),\n      label: country.display_name || country.name || country.id,\n    }))\n  }\n\n  const records =\n    attribute === \"customer.groups.id\"\n      ? options.customer_groups\n      : attribute === \"region.id\"\n        ? options.regions\n        : attribute === \"sales_channel_id\"\n          ? options.sales_channels\n          : []\n  return (records || []).map((record) => ({\n    value: record.id,\n    label: optionLabel(record),\n  }))\n}\n\nfunction MultiConditionValues({\n  attribute,\n  onChange,\n  options,\n  value,\n}: {\n  attribute: PurchaseConditionAttribute\n  onChange: (value: string[]) => void\n  options: ConditionValueOption[]\n  value: string[]\n}) {\n  const [open, setOpen] = useState(false)\n  const [draft, setDraft] = useState(value)\n  const [search, setSearch] = useState(\"\")\n  const labels = Object.fromEntries(options.map((option) => [option.value, option.label]))\n  const filtered = options.filter((option) =>\n    option.label.toLowerCase().includes(search.trim().toLowerCase()),\n  )\n\n  return (\n    <>\n      <Button\n        type=\"button\"\n        variant=\"secondary\"\n        className=\"w-full justify-start\"\n        onClick={() => {\n          setDraft(value)\n          setSearch(\"\")\n          setOpen(true)\n        }}\n      >\n        {value.length\n          ? value.length === 1\n            ? labels[value[0]] || value[0]\n            : `${value.length} values selected`\n          : \"Select values\"}\n      </Button>\n      {value.length > 0 && (\n        <div className=\"mt-2 flex flex-wrap gap-1\">\n          {value.map((item) => (\n            <span\n              key={item}\n              className=\"bg-ui-bg-component text-ui-fg-subtle flex items-center gap-x-1 rounded-md border px-2 py-1 text-xs\"\n            >\n              {labels[item] || item}\n              <button\n                type=\"button\"\n                aria-label={`Remove ${labels[item] || item}`}\n                onClick={() => onChange(value.filter((entry) => entry !== item))}\n              >\n                <XMarkMini />\n              </button>\n            </span>\n          ))}\n        </div>\n      )}\n      <Drawer open={open} onOpenChange={setOpen}>\n        <Drawer.Content>\n          <Drawer.Header>\n            <Drawer.Title>\n              Select {conditionAttributes.find((item) => item.value === attribute)?.label}\n            </Drawer.Title>\n          </Drawer.Header>\n          <Drawer.Body className=\"flex flex-col gap-y-3 overflow-y-auto\">\n            <Input\n              value={search}\n              placeholder=\"Search values\"\n              onChange={(event) => setSearch(event.target.value)}\n            />\n            {filtered.length ? (\n              filtered.map((option) => (\n                <label\n                  key={option.value}\n                  className=\"flex cursor-pointer items-center gap-x-3 rounded-md border p-3\"\n                >\n                  <Checkbox\n                    checked={draft.includes(option.value)}\n                    onCheckedChange={(checked) =>\n                      setDraft((current) =>\n                        checked\n                          ? Array.from(new Set([...current, option.value]))\n                          : current.filter((value) => value !== option.value),\n                      )\n                    }\n                  />\n                  <Text>{option.label}</Text>\n                </label>\n              ))\n            ) : (\n              <Text className=\"text-ui-fg-muted\">No matching values.</Text>\n            )}\n          </Drawer.Body>\n          <Drawer.Footer>\n            <Button type=\"button\" variant=\"secondary\" onClick={() => setOpen(false)}>\n              Cancel\n            </Button>\n            <Button\n              type=\"button\"\n              disabled={!draft.length}\n              onClick={() => {\n                onChange(draft)\n                setOpen(false)\n              }}\n            >\n              Apply\n            </Button>\n          </Drawer.Footer>\n        </Drawer.Content>\n      </Drawer>\n    </>\n  )\n}\n\nfunction PurchaseConditionsField({\n  fixedAmount,\n  onChange,\n  options,\n  value,\n}: {\n  fixedAmount: boolean\n  onChange: (conditions: PurchaseConditionForm[]) => void\n  options: OptionsPayload\n  value: PurchaseConditionForm[]\n}) {\n  const selectedAttributes = new Set(\n    value.map((condition) => condition.attribute).filter(Boolean),\n  )\n\n  const replace = (key: string, update: Partial<PurchaseConditionForm>) =>\n    onChange(\n      value.map((condition) =>\n        condition.key === key ? { ...condition, ...update } : condition,\n      ),\n    )\n\n  return (\n    <Section\n      title=\"Who can purchase this coupon?\"\n      description=\"Coupon products can be purchased by all customers when no conditions are configured. Conditions are combined with AND.\"\n    >\n      <div className=\"flex flex-col gap-y-3\">\n        {value.map((condition, index) => {\n          const values = conditionValueOptions(condition.attribute, options)\n          const currencyRequired =\n            fixedAmount && condition.attribute === \"currency_code\"\n          return (\n            <div key={condition.key}>\n              {index > 0 && (\n                <div className=\"text-ui-fg-muted flex h-8 items-center text-xs font-medium\">\n                  AND\n                </div>\n              )}\n              <div style={panelStyle} className=\"relative flex flex-col gap-y-3\">\n                <div className=\"flex items-start gap-x-2\">\n                  <div className=\"flex-1\">\n                    <Select\n                      value={condition.attribute || undefined}\n                      disabled={currencyRequired}\n                      onValueChange={(attribute) =>\n                        replace(condition.key, {\n                          attribute: attribute as PurchaseConditionAttribute,\n                          operator: \"\",\n                          values: [],\n                        })\n                      }\n                    >\n                      <Select.Trigger>\n                        <Select.Value placeholder=\"Select attribute\" />\n                      </Select.Trigger>\n                      <Select.Content>\n                        {conditionAttributes\n                          .filter(\n                            (attribute) =>\n                              attribute.value === condition.attribute ||\n                              !selectedAttributes.has(attribute.value),\n                          )\n                          .map((attribute) => (\n                            <Select.Item key={attribute.value} value={attribute.value}>\n                              {attribute.label}\n                            </Select.Item>\n                          ))}\n                      </Select.Content>\n                    </Select>\n                  </div>\n                  <Button\n                    type=\"button\"\n                    size=\"small\"\n                    variant=\"transparent\"\n                    disabled={currencyRequired}\n                    aria-label=\"Remove condition\"\n                    onClick={() =>\n                      onChange(value.filter((item) => item.key !== condition.key))\n                    }\n                  >\n                    <XMarkMini />\n                  </Button>\n                </div>\n                <div style={twoColumnGridStyle}>\n                  <Select\n                    value={condition.operator || undefined}\n                    disabled={!condition.attribute}\n                    onValueChange={(operator) =>\n                      replace(condition.key, {\n                        operator: operator as PurchaseConditionOperator,\n                        values:\n                          operator === \"eq\"\n                            ? condition.values.slice(0, 1)\n                            : condition.values,\n                      })\n                    }\n                  >\n                    <Select.Trigger>\n                      <Select.Value placeholder=\"Select operator\" />\n                    </Select.Trigger>\n                    <Select.Content>\n                      {conditionOperators.map((operator) => (\n                        <Select.Item key={operator.value} value={operator.value}>\n                          {operator.label}\n                        </Select.Item>\n                      ))}\n                    </Select.Content>\n                  </Select>\n                  {condition.attribute && condition.operator === \"eq\" ? (\n                    <Select\n                      value={condition.values[0] || undefined}\n                      onValueChange={(selected) =>\n                        replace(condition.key, { values: [selected] })\n                      }\n                    >\n                      <Select.Trigger>\n                        <Select.Value placeholder=\"Select value\" />\n                      </Select.Trigger>\n                      <Select.Content>\n                        {values.map((option) => (\n                          <Select.Item key={option.value} value={option.value}>\n                            {option.label}\n                          </Select.Item>\n                        ))}\n                      </Select.Content>\n                    </Select>\n                  ) : condition.attribute && condition.operator ? (\n                    <MultiConditionValues\n                      attribute={condition.attribute}\n                      options={values}\n                      value={condition.values}\n                      onChange={(values) => replace(condition.key, { values })}\n                    />\n                  ) : (\n                    <Button type=\"button\" variant=\"secondary\" disabled className=\"w-full\">\n                      Select values\n                    </Button>\n                  )}\n                </div>\n              </div>\n            </div>\n          )\n        })}\n        <div className=\"flex items-center gap-x-2\">\n          <Button\n            type=\"button\"\n            variant=\"secondary\"\n            disabled={selectedAttributes.size >= conditionAttributes.length}\n            onClick={() =>\n              onChange([\n                ...value,\n                { key: conditionKey(), attribute: \"\", operator: \"\", values: [] },\n              ])\n            }\n          >\n            <Plus /> Add condition\n          </Button>\n          <Button\n            type=\"button\"\n            variant=\"transparent\"\n            onClick={() =>\n              onChange(fixedAmount ? defaultPurchaseConditions(options) : [])\n            }\n          >\n            Clear all\n          </Button>\n        </div>\n      </div>\n    </Section>\n  )\n}\n\nfunction ProductPricesTable({\n  currencies,\n  couponValue,\n  onChange,\n  prices,\n}: {\n  currencies: CurrencyOption[]\n  couponValue: string\n  onChange: (currencyCode: string, value: string) => void\n  prices: Record<string, string>\n}) {\n  const [visibleCurrencies, setVisibleCurrencies] = useState<string[]>(() =>\n    currencies.map((currency) => currency.code),\n  )\n\n  useEffect(() => {\n    setVisibleCurrencies((current) => {\n      const available = new Set(currencies.map((currency) => currency.code))\n      const retained = current.filter((code) => available.has(code))\n      const added = currencies\n        .map((currency) => currency.code)\n        .filter((code) => !current.includes(code))\n      return [...retained, ...added]\n    })\n  }, [currencies])\n\n  const shownCurrencies = currencies.filter((currency) =>\n    visibleCurrencies.includes(currency.code),\n  )\n\n  return (\n    <div className=\"flex size-full flex-col divide-y overflow-hidden\">\n      <div className=\"bg-ui-bg-subtle flex size-full flex-col\">\n        <div className=\"bg-ui-bg-base flex items-center justify-between border-b p-4\">\n          <div className=\"flex items-center gap-x-2\">\n            <DropdownMenu>\n              <DropdownMenu.Trigger asChild>\n                <Button type=\"button\" size=\"small\" variant=\"secondary\">\n                  <Adjustments />\n                  View\n                </Button>\n              </DropdownMenu.Trigger>\n              <DropdownMenu.Content align=\"start\">\n                {currencies.map((currency) => (\n                  <DropdownMenu.CheckboxItem\n                    key={currency.code}\n                    checked={visibleCurrencies.includes(currency.code)}\n                    onCheckedChange={(checked) =>\n                      setVisibleCurrencies((current) =>\n                        checked\n                          ? Array.from(new Set([...current, currency.code]))\n                          : current.filter((code) => code !== currency.code),\n                      )\n                    }\n                  >\n                    Price {currency.code.toUpperCase()}\n                  </DropdownMenu.CheckboxItem>\n                ))}\n              </DropdownMenu.Content>\n            </DropdownMenu>\n          </div>\n          <div className=\"flex items-center gap-x-2\" />\n        </div>\n\n        <div className=\"size-full overflow-auto\">\n          <Table\n            style={{\n              borderCollapse: \"collapse\",\n              tableLayout: \"fixed\",\n              width: \"max-content\"\n            }}\n          >\n            <Table.Header style={{ borderTop: \"none\" }}>\n              <Table.Row style={{ height: 40 }}>\n                <Table.HeaderCell\n                  style={{\n                    background: \"var(--bg-base)\",\n                    borderBottom: \"1px solid var(--border-base)\",\n                    borderRight: \"1px solid var(--border-base)\",\n                    height: 40,\n                    left: 0,\n                    maxWidth: 200,\n                    minWidth: 200,\n                    padding: \"0 16px\",\n                    position: \"sticky\",\n                    width: 200,\n                    zIndex: 1,\n                  }}\n                >\n                  Coupon Value\n                </Table.HeaderCell>\n                {shownCurrencies.map((currency) => (\n                  <Table.HeaderCell\n                    key={currency.code}\n                    style={{\n                      background: \"var(--bg-base)\",\n                      borderBottom: \"1px solid var(--border-base)\",\n                      borderRight: \"1px solid var(--border-base)\",\n                      height: 40,\n                      maxWidth: 200,\n                      minWidth: 200,\n                      padding: \"0 16px\",\n                      width: 200,\n                    }}\n                  >\n                    <div className=\"flex w-full items-center justify-between gap-3\">\n                      <span className=\"truncate\" title={`Price ${currency.code.toUpperCase()}`}>\n                        Price {currency.code.toUpperCase()}\n                      </span>\n                      {currency.is_tax_inclusive ? (\n                        <TaxInclusive className=\"text-ui-fg-muted shrink-0\" />\n                      ) : (\n                        <TaxExclusive className=\"text-ui-fg-muted shrink-0\" />\n                      )}\n                    </div>\n                  </Table.HeaderCell>\n                ))}\n              </Table.Row>\n            </Table.Header>\n            <Table.Body>\n              <Table.Row className=\"bg-ui-bg-subtle\" style={{ height: 40 }}>\n                <Table.Cell\n                  style={{\n                    background: \"var(--bg-subtle)\",\n                    borderBottom: \"1px solid var(--border-base)\",\n                    borderRight: \"1px solid var(--border-base)\",\n                    height: 40,\n                    left: 0,\n                    maxWidth: 200,\n                    minWidth: 200,\n                    padding: \"0 16px\",\n                    position: \"sticky\",\n                    width: 200,\n                    zIndex: 1,\n                  }}\n                >\n                  <span className=\"block truncate\">{couponValue}</span>\n                </Table.Cell>\n                {shownCurrencies.map((currency) => (\n                  <Table.Cell\n                    key={currency.code}\n                    style={{\n                      background: \"var(--bg-base)\",\n                      borderBottom: \"1px solid var(--border-base)\",\n                      borderRight: \"1px solid var(--border-base)\",\n                      height: 40,\n                      maxWidth: 200,\n                      minWidth: 200,\n                      padding: 0,\n                      width: 200,\n                    }}\n                  >\n                    <TablePriceInput\n                      currency={currency}\n                      value={prices[currency.code] || \"\"}\n                      onChange={(value) => onChange(currency.code, value)}\n                    />\n                  </Table.Cell>\n                ))}\n              </Table.Row>\n            </Table.Body>\n          </Table>\n\n          {!currencies.length && (\n            <div className=\"p-4\">\n              <Text className=\"text-ui-fg-muted\">\n                Add a supported currency to the store before setting prices.\n              </Text>\n            </div>\n          )}\n        </div>\n      </div>\n    </div>\n  )\n}\n\nexport function formatCouponValue(\n  coupon: Pick<CouponFormState, \"amounts\" | \"percentage\" | \"type\">,\n  currencies: Pick<CurrencyOption, \"code\" | \"is_default\">[],\n) {\n  if (\n    coupon.type === \"amount_off_products\" ||\n    coupon.type === \"amount_off_order\"\n  ) {\n    const defaultCode =\n      currencies.find((currency) => currency.is_default)?.code ||\n      currencies[0]?.code\n    const primary =\n      coupon.amounts.find((row) => row.currency_code === defaultCode) ||\n      coupon.amounts[0]\n    const amount = numberOrNull(primary?.amount)\n    if (amount == null) return \"\u2014\"\n    const additional = Math.max(0, coupon.amounts.length - 1)\n    const formatted = `${amount}${primary.currency_code.toUpperCase()}`\n    return additional ? `${formatted} +${additional}` : formatted\n  }\n\n  if (\n    coupon.type === \"percentage_off_product\" ||\n    coupon.type === \"percentage_off_order\"\n  ) {\n    const percentage = numberOrNull(coupon.percentage)\n    if (percentage == null) return \"\u2014\"\n    return coupon.type === \"percentage_off_order\"\n      ? `${percentage}% off order`\n      : `${percentage}% off products`\n  }\n\n  return coupon.type === \"free_shipping\" ? \"Free shipping\" : \"Buy X Get Y\"\n}\n\nfunction TablePriceInput({\n  currency,\n  onChange,\n  value,\n}: {\n  currency: CurrencyOption\n  onChange: (value: string) => void\n  value: string\n}) {\n  const symbol =\n    currency.symbol_native ||\n    currency.symbol ||\n    currencySymbol(currency.code || \"USD\")\n\n  return (\n    <label\n      className=\"bg-ui-bg-base hover:bg-ui-bg-subtle focus-within:shadow-borders-interactive-with-active text-ui-fg-base\"\n      style={{\n        alignItems: \"center\",\n        borderRadius: 0,\n        display: \"flex\",\n        height: 40,\n        margin: 0,\n        overflow: \"hidden\",\n        width: 200,\n      }}\n    >\n      <span\n        className=\"text-ui-fg-muted\"\n        aria-hidden=\"true\"\n        style={{ flex: \"0 0 40px\", paddingLeft: 16 }}\n      >\n        {symbol}\n      </span>\n      <input\n        aria-label={`Price ${currency.code.toUpperCase()}`}\n        inputMode=\"decimal\"\n        value={value}\n        onChange={(event) => onChange(event.target.value)}\n        style={{\n          appearance: \"none\",\n          background: \"transparent\",\n          border: 0,\n          borderRadius: 0,\n          flex: \"1 1 auto\",\n          height: \"100%\",\n          margin: 0,\n          minWidth: 0,\n          outline: \"none\",\n          padding: \"0 16px 0 0\",\n          textAlign: \"right\",\n        }}\n        type=\"text\"\n      />\n    </label>\n  )\n}\n\nfunction CouponProductModal({\n  allowPromotionMirror,\n  apiBase,\n  onOpenChange,\n  onSaved,\n  open,\n  options,\n  row,\n}: {\n  allowPromotionMirror: boolean\n  apiBase: ApiBase\n  onOpenChange: (open: boolean) => void\n  onSaved: () => Promise<void>\n  open: boolean\n  options: OptionsPayload\n  row: CouponProductRow | null\n}) {\n  const [activeStep, setActiveStep] = useState<WizardStep>(\"details\")\n  const [product, setProduct] = useState<ProductFormState>(() =>\n    emptyProduct(options),\n  )\n  const [coupon, setCoupon] = useState<CouponFormState>(() =>\n    emptyCoupon(options),\n  )\n  const [campaign, setCampaign] = useState<CampaignFormState>(emptyCampaign)\n  const [saving, setSaving] = useState(false)\n  const [uploading, setUploading] = useState(false)\n  const [furthestStepIndex, setFurthestStepIndex] = useState(0)\n\n  const visibleSteps = useMemo(\n    () =>\n      allowPromotionMirror\n        ? allSteps\n        : allSteps.filter((step) => step !== \"campaign\"),\n    [allowPromotionMirror],\n  )\n  const currentStepIndex = visibleSteps.indexOf(activeStep)\n  const currencies = options.currencies || []\n  const supportedCurrencyCodes = useMemo(\n    () => new Set(currencies.map((currency) => currency.code)),\n    [currencies],\n  )\n  const isAmountType =\n    coupon.type === \"amount_off_products\" || coupon.type === \"amount_off_order\"\n  const isPercentageType =\n    coupon.type === \"percentage_off_product\" ||\n    coupon.type === \"percentage_off_order\"\n  const isItemScopedDiscount =\n    coupon.type === \"amount_off_products\" ||\n    coupon.type === \"percentage_off_product\"\n  const effectiveCurrencies = useMemo(\n    () => effectiveCouponCurrencies(coupon.purchase_conditions, currencies),\n    [coupon.purchase_conditions, currencies],\n  )\n  const productPrices = currencies.flatMap((currency) => {\n    const value = product.price_amounts[currency.code] || \"\"\n    const amount = nonNegativeNumberOrNull(value)\n    return amount == null ? [] : [{ currency_code: currency.code, amount }]\n  })\n\n  useEffect(() => {\n    if (!open) return\n    const forms = row\n      ? formsFromRow(row, options)\n      : {\n        product: emptyProduct(options),\n        coupon: emptyCoupon(options),\n        campaign: emptyCampaign,\n      }\n    setProduct(forms.product)\n    setCoupon(forms.coupon)\n    setCampaign(forms.campaign)\n    setActiveStep(\"details\")\n    setFurthestStepIndex(0)\n  }, [open, row, options])\n\n  const updatePurchaseConditions = (\n    purchaseConditions: PurchaseConditionForm[],\n  ) => {\n    setCoupon((current) => ({\n      ...current,\n      purchase_conditions: purchaseConditions,\n      amounts: isAmountCouponType(current.type)\n        ? reconcileCouponAmounts(\n          current.amounts,\n          effectiveCouponCurrencies(purchaseConditions, currencies),\n        )\n        : current.amounts,\n    }))\n  }\n\n  const updateCouponType = (type: CouponType) => {\n    setCoupon((current) => {\n      let purchaseConditions = current.purchase_conditions\n      if (\n        isAmountCouponType(type) &&\n        !purchaseConditions.some(\n          (condition) => condition.attribute === \"currency_code\",\n        )\n      ) {\n        purchaseConditions = [\n          ...purchaseConditions,\n          ...defaultPurchaseConditions(options),\n        ]\n      }\n      return {\n        ...current,\n        type,\n        purchase_conditions: purchaseConditions,\n        amounts: isAmountCouponType(type)\n          ? reconcileCouponAmounts(\n            current.amounts,\n            effectiveCouponCurrencies(purchaseConditions, currencies),\n          )\n          : current.amounts,\n        promotion_mirror_mode:\n          type === \"buy_x_get_y\" ? \"none\" : current.promotion_mirror_mode,\n      }\n    })\n  }\n\n  const uploadMedia = async (files: File[]) => {\n    if (!files.length) return\n    const formData = new FormData()\n    files.forEach((file) => formData.append(\"files\", file))\n    if (apiBase === \"/admin\" && product.seller_id) {\n      formData.append(\"seller_id\", product.seller_id)\n    }\n    setUploading(true)\n    try {\n      const response = await fetch(\n        `${backendUrl()}${apiBase}/coupon-products/uploads`,\n        {\n          method: \"POST\",\n          body: formData,\n          credentials: \"include\",\n        },\n      )\n      if (!response.ok) {\n        const payload = await response.json().catch(() => null)\n        throw new Error(apiErrorMessage(payload, response.statusText))\n      }\n      const payload = (await response.json()) as {\n        files?: { asset_id?: string; url?: string }[]\n      }\n      const uploaded = (payload.files || [])\n        .filter(\n          (file): file is { asset_id: string; url: string } =>\n            Boolean(file.asset_id && file.url),\n        )\n        .map((file) => ({ asset_id: file.asset_id, url: file.url }))\n      if (!uploaded.length)\n        throw new Error(\"The upload did not return an image URL\")\n      setProduct((current) => ({\n        ...current,\n        media: Array.from(\n          new Map(\n            [...current.media, ...uploaded].map((item) => [item.url, item]),\n          ).values(),\n        ),\n      }))\n    } catch (error) {\n      toast.error(\n        error instanceof Error ? error.message : \"Image upload failed\",\n      )\n    } finally {\n      setUploading(false)\n    }\n  }\n\n  const detailsComplete = useMemo(() => {\n    if (!product.title.trim()) return false\n    if (!currencies.length) return false\n\n    const attributes = new Set<string>()\n    for (const condition of coupon.purchase_conditions) {\n      if (\n        !condition.attribute ||\n        !condition.operator ||\n        !condition.values.length ||\n        (condition.operator === \"eq\" && condition.values.length !== 1) ||\n        attributes.has(condition.attribute)\n      ) {\n        return false\n      }\n      attributes.add(condition.attribute)\n    }\n\n    if (isAmountType) {\n      if (!attributes.has(\"currency_code\")) return false\n      if (!coupon.amounts.length) return false\n      if (coupon.amounts.length !== effectiveCurrencies.length) return false\n      const seen = new Set<string>()\n      for (const row of coupon.amounts) {\n        if (!supportedCurrencyCodes.has(row.currency_code)) return false\n        if (seen.has(row.currency_code)) return false\n        if (numberOrNull(row.amount) == null) return false\n        seen.add(row.currency_code)\n      }\n    }\n\n    if (isPercentageType) {\n      const value = numberOrNull(coupon.percentage)\n      if (value == null || value > 100) return false\n    }\n\n    if (coupon.code_strategy === \"shared_code\" && !coupon.shared_code.trim()) {\n      return false\n    }\n\n    if (coupon.expiration_type === \"duration\") {\n      const days = Number(coupon.expiration_days)\n      if (!Number.isInteger(days) || days < 1) return false\n    } else if (coupon.expiration_type === \"fixed\") {\n      const expiration = new Date(coupon.expiration_date)\n      if (!coupon.expiration_date || Number.isNaN(expiration.getTime())) {\n        return false\n      }\n    }\n\n    if (coupon.expiration_type !== \"none\" && coupon.expiration_cap_at) {\n      const cap = new Date(coupon.expiration_cap_at)\n      if (Number.isNaN(cap.getTime())) return false\n    }\n\n    const maxIssuance = Number(coupon.max_issuance_per_order_item)\n    return Number.isInteger(maxIssuance) && maxIssuance > 0\n  }, [\n    coupon,\n    currencies.length,\n    effectiveCurrencies.length,\n    isAmountType,\n    isPercentageType,\n    product.title,\n    supportedCurrencyCodes,\n  ])\n\n  const campaignComplete = useMemo(() => {\n    if (!allowPromotionMirror || campaign.mode === \"none\") return true\n    if (campaign.mode === \"existing\") return Boolean(campaign.campaign_id)\n    if (!campaign.name.trim() || !campaign.campaign_identifier.trim()) {\n      return false\n    }\n\n    return [campaign.starts_at, campaign.ends_at].every((value) => {\n      if (!value) return true\n      return !Number.isNaN(new Date(value).getTime())\n    })\n  }, [allowPromotionMirror, campaign])\n\n  const pricesComplete = useMemo(() => {\n    if (!currencies.length || !productPrices.length) return false\n    return currencies.every((currency) => {\n      const value = product.price_amounts[currency.code] || \"\"\n      return !value.trim() || nonNegativeNumberOrNull(value) != null\n    })\n  }, [currencies, product.price_amounts, productPrices.length])\n\n  const stepValidity = useMemo<Record<WizardStep, boolean>>(\n    () => ({\n      details: detailsComplete,\n      organize: true,\n      campaign: campaignComplete,\n      prices: pricesComplete,\n    }),\n    [campaignComplete, detailsComplete, pricesComplete],\n  )\n\n  const activeStepComplete = stepValidity[activeStep]\n\n  useEffect(() => {\n    if (!open || !activeStepComplete) return\n    setFurthestStepIndex((current) =>\n      Math.max(\n        current,\n        Math.min(currentStepIndex + 1, visibleSteps.length - 1),\n      ),\n    )\n  }, [activeStepComplete, currentStepIndex, open, visibleSteps.length])\n\n  const isStepDisabled = (index: number) =>\n    index > furthestStepIndex ||\n    visibleSteps.slice(0, index).some((previous) => !stepValidity[previous])\n\n  const validate = () => {\n    if (!product.title.trim()) throw new Error(\"Product title is required\")\n    if (!currencies.length) {\n      throw new Error(\"Add a supported currency to the store before continuing\")\n    }\n    const invalidPrice = currencies.some((currency) => {\n      const value = product.price_amounts[currency.code] || \"\"\n      return value.trim() && nonNegativeNumberOrNull(value) == null\n    })\n    if (invalidPrice) {\n      throw new Error(\"Product prices must be 0 or more\")\n    }\n    if (!productPrices.length) {\n      throw new Error(\"Add at least one product price\")\n    }\n    if (isAmountType) {\n      if (!coupon.amounts.length) {\n        throw new Error(\"Add at least one coupon value\")\n      }\n      const seen = new Set<string>()\n      const currencyCondition = coupon.purchase_conditions.find(\n        (condition) => condition.attribute === \"currency_code\",\n      )\n      if (!currencyCondition) {\n        throw new Error(\"Add a Currency Code purchase condition\")\n      }\n      if (coupon.amounts.length !== effectiveCurrencies.length) {\n        throw new Error(\n          \"Coupon values must match every effective currency condition value\",\n        )\n      }\n      for (const row of coupon.amounts) {\n        if (!supportedCurrencyCodes.has(row.currency_code)) {\n          throw new Error(\"Select an available coupon currency\")\n        }\n        if (seen.has(row.currency_code)) {\n          throw new Error(\"Coupon value currencies cannot be duplicated\")\n        }\n        if (numberOrNull(row.amount) == null) {\n          throw new Error(\"Coupon values must be greater than 0\")\n        }\n        seen.add(row.currency_code)\n      }\n    }\n    const seenAttributes = new Set<string>()\n    for (const condition of coupon.purchase_conditions) {\n      if (!condition.attribute || !condition.operator) {\n        throw new Error(\"Complete every purchase condition\")\n      }\n      if (!condition.values.length) {\n        throw new Error(\"Select at least one value for every purchase condition\")\n      }\n      if (condition.operator === \"eq\" && condition.values.length !== 1) {\n        throw new Error(\"Equals conditions require exactly one value\")\n      }\n      if (seenAttributes.has(condition.attribute)) {\n        throw new Error(\"Purchase condition attributes cannot be duplicated\")\n      }\n      seenAttributes.add(condition.attribute)\n    }\n    if (isPercentageType) {\n      const value = numberOrNull(coupon.percentage)\n      if (value == null || value > 100) {\n        throw new Error(\"Coupon value must be between 1 and 100 percent\")\n      }\n    }\n    if (coupon.code_strategy === \"shared_code\" && !coupon.shared_code.trim()) {\n      throw new Error(\"A shared coupon code is required\")\n    }\n    if (coupon.expiration_type === \"fixed\") {\n      const expiration = new Date(coupon.expiration_date)\n      if (!coupon.expiration_date || Number.isNaN(expiration.getTime())) {\n        throw new Error(\"A valid fixed expiration date is required\")\n      }\n    }\n    if (coupon.expiration_type !== \"none\" && coupon.expiration_cap_at) {\n      const cap = new Date(coupon.expiration_cap_at)\n      if (Number.isNaN(cap.getTime())) {\n        throw new Error(\"A valid expiration cap date is required\")\n      }\n    }\n    if (campaign.mode === \"existing\" && !campaign.campaign_id) {\n      throw new Error(\"Select an existing campaign\")\n    }\n    if (\n      campaign.mode === \"new\" &&\n      (!campaign.name.trim() || !campaign.campaign_identifier.trim())\n    ) {\n      throw new Error(\"Campaign name and identifier are required\")\n    }\n  }\n\n  const save = async () => {\n    setSaving(true)\n    try {\n      validate()\n      const benefitType = benefitTypeFromCouponType(coupon.type)\n      const targetType =\n        coupon.type === \"amount_off_order\" ||\n        coupon.type === \"percentage_off_order\"\n          ? \"order\"\n          : \"items\"\n      const payload = {\n        product: {\n          title: product.title.trim(),\n          subtitle: product.subtitle.trim() || null,\n          handle: product.handle.trim() || null,\n          description: product.description.trim() || null,\n          status: productStatusFromCouponStatus(coupon.promotion_status),\n          thumbnail: product.media[0]?.url || null,\n          thumbnail_asset_id: product.media[0]?.asset_id || null,\n          images: product.media.slice(1).map((media) => ({\n            url: media.url,\n            ...(media.asset_id ? { asset_id: media.asset_id } : {}),\n          })),\n          discountable: product.discountable,\n          type_id: product.type_id || null,\n          collection_id: product.collection_id || null,\n          categories: product.category_id ? [{ id: product.category_id }] : [],\n          tags: product.tag_id ? [{ id: product.tag_id }] : [],\n          variants: [\n            {\n              title: \"Default\",\n              sku: product.sku.trim() || null,\n              manage_inventory: false,\n              allow_backorder: true,\n              prices: productPrices,\n            },\n          ],\n        },\n        coupon: {\n          enabled: coupon.enabled,\n          benefit_type: benefitType,\n          purchase_conditions: coupon.purchase_conditions.map((condition) => ({\n            attribute: condition.attribute,\n            operator: condition.operator,\n            values: condition.values,\n          })),\n          amounts: isAmountType\n            ? coupon.amounts.map((row) => ({\n              amount: numberOrNull(row.amount),\n              currency_code: row.currency_code,\n            }))\n            : null,\n          amount: null,\n          percentage: isPercentageType ? numberOrNull(coupon.percentage) : null,\n          currency_code: null,\n          code_strategy: coupon.code_strategy,\n          code_prefix:\n            coupon.code_strategy === \"unique_code\"\n              ? coupon.code_prefix.trim() || \"COUPON\"\n              : null,\n          shared_code:\n            coupon.code_strategy === \"shared_code\"\n              ? coupon.shared_code.trim()\n              : null,\n          expiration_policy:\n            coupon.expiration_type === \"none\"\n              ? { type: \"none\" }\n              : coupon.expiration_type === \"fixed\"\n                ? {\n                  type: \"fixed\",\n                  expires_at: new Date(coupon.expiration_date).toISOString(),\n                  cap_by_campaign: coupon.expiration_cap_by_campaign,\n                  cap_at: coupon.expiration_cap_at\n                    ? new Date(coupon.expiration_cap_at).toISOString()\n                    : null,\n                }\n                : {\n                  type: \"duration\",\n                  duration_days: Number(coupon.expiration_days) || 30,\n                  cap_by_campaign: coupon.expiration_cap_by_campaign,\n                  cap_at: coupon.expiration_cap_at\n                    ? new Date(coupon.expiration_cap_at).toISOString()\n                    : null,\n                },\n          max_issuance_per_order_item:\n            Number(coupon.max_issuance_per_order_item) || 1,\n          promotion_template:\n            benefitType === \"fixed_amount\" || benefitType === \"percentage\"\n              ? {\n                application_method: {\n                  target_type: targetType,\n                  allocation:\n                    targetType === \"order\" ? \"across\" : coupon.allocation,\n                },\n              }\n              : null,\n          promotion_status: coupon.promotion_status,\n          ...(allowPromotionMirror\n            ? {\n              promotion_mirror_mode:\n                benefitType === \"buy_get\" ||\n                  (benefitType === \"fixed_amount\" && coupon.amounts.length > 1)\n                  ? \"none\"\n                  : coupon.promotion_mirror_mode,\n            }\n            : {}),\n        },\n        campaign: allowPromotionMirror\n          ? campaign.mode === \"existing\"\n            ? { mode: \"existing\", campaign_id: campaign.campaign_id }\n            : campaign.mode === \"new\"\n              ? {\n                mode: \"new\",\n                campaign: {\n                  name: campaign.name,\n                  campaign_identifier: campaign.campaign_identifier,\n                  starts_at: campaign.starts_at\n                    ? new Date(campaign.starts_at).toISOString()\n                    : null,\n                  ends_at: campaign.ends_at\n                    ? new Date(campaign.ends_at).toISOString()\n                    : null,\n                },\n              }\n              : { mode: \"none\" }\n          : undefined,\n        seller_id: product.seller_id || null,\n        variant_overrides: [],\n      }\n\n      await apiFetch(\n        row\n          ? `${apiBase}/coupon-products/${row.product.id}`\n          : `${apiBase}/coupon-products`,\n        {\n          method: row ? \"PATCH\" : \"POST\",\n          body: JSON.stringify(payload),\n        },\n      )\n      toast.success(row ? \"Coupon product updated\" : \"Coupon product created\")\n      onOpenChange(false)\n      await onSaved()\n    } catch (error) {\n      toast.error(\n        error instanceof Error\n          ? error.message\n          : \"Failed to save coupon product\",\n      )\n    } finally {\n      setSaving(false)\n    }\n  }\n\n  const stepStatus = (step: WizardStep) => {\n    const index = visibleSteps.indexOf(step)\n    if (index < currentStepIndex && stepValidity[step]) {\n      return \"completed\" as const\n    }\n    if (index === currentStepIndex) return \"in-progress\" as const\n    return \"not-started\" as const\n  }\n\n  return (\n    <FocusModal open={open} onOpenChange={onOpenChange}>\n      <FocusModal.Content style={modalContentStyle}>\n        <FocusModal.Title style={visuallyHiddenStyle}>\n          {row ? \"Edit Coupon Product\" : \"Create Coupon Product\"}\n        </FocusModal.Title>\n        <ProgressTabs\n          value={activeStep}\n          onValueChange={(value) => {\n            const step = value as WizardStep\n            const index = visibleSteps.indexOf(step)\n            if (!isStepDisabled(index)) setActiveStep(step)\n          }}\n          style={modalWizardStyle}\n        >\n          <FocusModal.Header>\n            <div className=\"-my-2 w-full border-l\">\n              <ProgressTabs.List className=\"justify-start-start flex w-full items-center\">\n                {visibleSteps.map((step, index) => (\n                  <ProgressTabs.Trigger\n                    key={step}\n                    value={step}\n                    status={stepStatus(step)}\n                    disabled={isStepDisabled(index)}\n                    className=\"max-w-[200px] truncate\"\n                  >\n                    {step[0].toUpperCase() + step.slice(1)}\n                  </ProgressTabs.Trigger>\n                ))}\n              </ProgressTabs.List>\n            </div>\n          </FocusModal.Header>\n\n          <FocusModal.Body className=\"overflow-hidden p-0\" style={modalBodyStyle}>\n            <div\n              style={\n                activeStep === \"prices\"\n                  ? { height: \"100%\", overflow: \"hidden\", width: \"100%\" }\n                  : modalScrollStyle\n              }\n            >\n              <div\n                style={\n                  activeStep === \"prices\"\n                    ? { height: \"100%\", width: \"100%\" }\n                    : modalFormStyle\n                }\n              >\n                {activeStep === \"details\" && (\n                  <ProgressTabs.Content value=\"details\" style={stackStyle}>\n                    <Heading level=\"h1\">\n                      {row ? \"Edit Coupon Product\" : \"Create Coupon Product\"}\n                    </Heading>\n                    <Divider />\n                    <Section title=\"General\">\n                      <div style={threeColumnGridStyle}>\n                        <Field label=\"Title\">\n                          <Input\n                            value={product.title}\n                            placeholder=\"Winter jacket\"\n                            onChange={(event) =>\n                              setProduct((current) => ({\n                                ...current,\n                                title: event.target.value,\n                              }))\n                            }\n                          />\n                        </Field>\n                        <Field label=\"Subtitle\" optional>\n                          <Input\n                            value={product.subtitle}\n                            placeholder=\"Warm and cozy\"\n                            onChange={(event) =>\n                              setProduct((current) => ({\n                                ...current,\n                                subtitle: event.target.value,\n                              }))\n                            }\n                          />\n                        </Field>\n                        <Field\n                          label=\"Handle\"\n                          optional\n                          tooltip=\"The URL-friendly identifier for this product. If left empty, Medusa generates it from the title.\"\n                        >\n                          <HandleInput\n                            value={product.handle}\n                            onChange={(handle) =>\n                              setProduct((current) => ({ ...current, handle }))\n                            }\n                          />\n                        </Field>\n                      </div>\n                      <Field label=\"Description\" optional>\n                        <Textarea\n                          value={product.description}\n                          placeholder=\"A warm and cozy jacket\"\n                          onChange={(event) =>\n                            setProduct((current) => ({\n                              ...current,\n                              description: event.target.value,\n                            }))\n                          }\n                        />\n                      </Field>\n                      <Field label=\"Media\" optional>\n                        <MediaUpload\n                          isUploading={uploading}\n                          media={product.media}\n                          onUpload={(files) => void uploadMedia(files)}\n                          onRemove={(media) =>\n                            setProduct((current) => ({\n                              ...current,\n                              media: current.media.filter(\n                                (item) =>\n                                  (media.asset_id && item.asset_id !== media.asset_id) ||\n                                  (!media.asset_id && item.url !== media.url),\n                              ),\n                            }))\n                          }\n                        />\n                      </Field>\n                      <Field label=\"SKU\" optional>\n                        <Input\n                          value={product.sku}\n                          placeholder=\"COUPON-001\"\n                          onChange={(event) =>\n                            setProduct((current) => ({\n                              ...current,\n                              sku: event.target.value,\n                            }))\n                          }\n                        />\n                      </Field>\n                    </Section>\n                    <Divider />\n                    <PurchaseConditionsField\n                      fixedAmount={isAmountType}\n                      options={options}\n                      value={coupon.purchase_conditions}\n                      onChange={updatePurchaseConditions}\n                    />\n                  </ProgressTabs.Content>\n                )}\n\n                {activeStep === \"organize\" && (\n                  <ProgressTabs.Content value=\"organize\" style={stackStyle}>\n                    <Section title=\"Organize\">\n                      <div style={panelStyle}>\n                        <div className=\"flex items-center justify-between gap-x-4\">\n                          <div>\n                            <Text weight=\"plus\">Discountable</Text>\n                            <Text size=\"small\" className=\"text-ui-fg-muted\">\n                              Allow promotions to discount this product's sale\n                              price.\n                            </Text>\n                          </div>\n                          <Switch\n                            checked={product.discountable}\n                            onCheckedChange={(discountable) =>\n                              setProduct((current) => ({\n                                ...current,\n                                discountable: Boolean(discountable),\n                              }))\n                            }\n                          />\n                        </div>\n                      </div>\n                      <div style={twoColumnGridStyle}>\n                        {allowPromotionMirror && (\n                          <Field label=\"Seller\" optional>\n                            <OptionSelect\n                              value={product.seller_id}\n                              options={options.sellers || []}\n                              onChange={(seller_id) =>\n                                setProduct((current) => ({ ...current, seller_id }))\n                              }\n                            />\n                          </Field>\n                        )}\n                        <Field label=\"Type\" optional>\n                          <OptionSelect\n                            value={product.type_id}\n                            options={options.product_types || []}\n                            onChange={(type_id) =>\n                              setProduct((current) => ({ ...current, type_id }))\n                            }\n                          />\n                        </Field>\n                        <Field label=\"Collection\" optional>\n                          <OptionSelect\n                            value={product.collection_id}\n                            options={options.product_collections || []}\n                            onChange={(collection_id) =>\n                              setProduct((current) => ({\n                                ...current,\n                                collection_id,\n                              }))\n                            }\n                          />\n                        </Field>\n                        <Field label=\"Category\" optional>\n                          <OptionSelect\n                            value={product.category_id}\n                            options={options.product_categories || []}\n                            onChange={(category_id) =>\n                              setProduct((current) => ({ ...current, category_id }))\n                            }\n                          />\n                        </Field>\n                        <Field label=\"Tag\" optional>\n                          <OptionSelect\n                            value={product.tag_id}\n                            options={options.product_tags || []}\n                            onChange={(tag_id) =>\n                              setProduct((current) => ({ ...current, tag_id }))\n                            }\n                          />\n                        </Field>\n                      </div>\n                    </Section>\n                  </ProgressTabs.Content>\n                )}\n\n                {activeStep === \"details\" && (\n                  <div style={{ ...stackStyle, marginTop: 24 }}>\n                    <Divider />\n                    <Section\n                      title=\"Coupon\"\n                      description=\"Configure the coupon issued when this product is purchased.\"\n                    >\n                      <div style={panelStyle}>\n                        <div className=\"flex items-center justify-between gap-x-4\">\n                          <div>\n                            <Text weight=\"plus\">Coupon issuance</Text>\n                            <Text size=\"small\" className=\"text-ui-fg-muted\">\n                              Issue coupons when customers purchase this product.\n                            </Text>\n                          </div>\n                          <Switch\n                            checked={coupon.enabled}\n                            onCheckedChange={(enabled) =>\n                              setCoupon((current) => ({\n                                ...current,\n                                enabled: Boolean(enabled),\n                              }))\n                            }\n                          />\n                        </div>\n                      </div>\n\n                      <Section title=\"Type\">\n                        <RadioGroup\n                          value={coupon.type}\n                          onValueChange={(type) =>\n                            updateCouponType(type as CouponType)\n                          }\n                          className=\"flex flex-col gap-y-3\"\n                        >\n                          {typeChoices.map((choice) => (\n                            <RadioGroup.ChoiceBox\n                              key={choice.value}\n                              value={choice.value}\n                              label={choice.label}\n                              description={choice.description}\n                            />\n                          ))}\n                        </RadioGroup>\n                      </Section>\n\n                      <Section title=\"Status\">\n                        <RadioGroup\n                          value={coupon.promotion_status}\n                          onValueChange={(promotion_status) =>\n                            setCoupon((current) => ({\n                              ...current,\n                              promotion_status:\n                                promotion_status as PromotionStatus,\n                            }))\n                          }\n                          style={twoColumnGridStyle}\n                        >\n                          {statusChoices.map((choice) => (\n                            <RadioGroup.ChoiceBox\n                              key={choice.value}\n                              value={choice.value}\n                              label={choice.label}\n                              description={choice.description}\n                            />\n                          ))}\n                        </RadioGroup>\n                      </Section>\n\n                      {(isAmountType || isPercentageType) && (\n                        <Section title={isAmountType ? \"Coupon Values\" : \"Value\"}>\n                          {isAmountType ? (\n                            <div className=\"flex flex-col gap-y-2\">\n                              {coupon.amounts.map((row, rowIndex) => {\n                                const currency = currencies.find(\n                                  (item) => item.code === row.currency_code,\n                                )\n\n                                return (\n                                  <div\n                                    key={row.key}\n                                    className=\"shadow-elevation-card-rest bg-ui-bg-component rounded-md px-4 py-3\"\n                                  >\n                                    <div className=\"flex flex-col gap-y-2\">\n                                      <div className=\"flex items-center justify-between\">\n                                        <Label>\n                                          {row.currency_code.toUpperCase()} Coupon Value\n                                        </Label>\n                                        <Text size=\"small\" className=\"text-ui-fg-muted\">\n                                          {currency?.name || row.currency_code.toUpperCase()}\n                                        </Text>\n                                      </div>\n                                      <div>\n                                        <CurrencyAmountField\n                                          currencies={currencies}\n                                          currencyCode={row.currency_code}\n                                          value={row.amount}\n                                          onChange={(amount) =>\n                                            setCoupon((current) => ({\n                                              ...current,\n                                              amounts: current.amounts.map(\n                                                (item, index) =>\n                                                  index === rowIndex\n                                                    ? { ...item, amount }\n                                                    : item,\n                                              ),\n                                            }))\n                                          }\n                                        />\n                                      </div>\n                                    </div>\n                                  </div>\n                                )\n                              })}\n                              {!coupon.amounts.length && (\n                                <Text className=\"text-ui-fg-muted\">\n                                  Select at least one effective Currency Code condition value.\n                                </Text>\n                              )}\n                            </div>\n                          ) : (\n                            <Field label=\"Coupon Value\">\n                              <PercentageInput\n                                value={coupon.percentage}\n                                onChange={(percentage) =>\n                                  setCoupon((current) => ({\n                                    ...current,\n                                    percentage,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          )}\n                        </Section>\n                      )}\n\n                      {isItemScopedDiscount && (\n                          <Section title=\"Allocation\">\n                            <RadioGroup\n                              value={coupon.allocation}\n                              onValueChange={(allocation) =>\n                                setCoupon((current) => ({\n                                  ...current,\n                                  allocation: allocation as CouponAllocation,\n                                }))\n                              }\n                              style={twoColumnGridStyle}\n                            >\n                              <RadioGroup.ChoiceBox\n                                value=\"each\"\n                                label=\"Each\"\n                                description=\"Applies value on each item\"\n                              />\n                              <RadioGroup.ChoiceBox\n                                value=\"once\"\n                                label=\"Once\"\n                                description=\"Limit discount to max quantity\"\n                              />\n                            </RadioGroup>\n                          </Section>\n                        )}\n\n                      <Section\n                        title=\"Expiration\"\n                        description=\"Control when issued coupons expire.\"\n                      >\n                        <div style={twoColumnGridStyle}>\n                          <Field label=\"Expiration policy\">\n                            <Select\n                              value={coupon.expiration_type}\n                              onValueChange={(expiration_type) =>\n                                setCoupon((current) => ({\n                                  ...current,\n                                  expiration_type:\n                                    expiration_type as ExpirationPolicyType,\n                                }))\n                              }\n                            >\n                              <Select.Trigger>\n                                <Select.Value />\n                              </Select.Trigger>\n                              <Select.Content>\n                                <Select.Item value=\"none\">None</Select.Item>\n                                <Select.Item value=\"duration\">\n                                  Duration after issue\n                                </Select.Item>\n                                <Select.Item value=\"fixed\">Fixed date</Select.Item>\n                              </Select.Content>\n                            </Select>\n                          </Field>\n                          {coupon.expiration_type === \"duration\" ? (\n                            <Field label=\"Expiration days\">\n                              <Input\n                                type=\"number\"\n                                min={1}\n                                value={coupon.expiration_days}\n                                onChange={(event) =>\n                                  setCoupon((current) => ({\n                                    ...current,\n                                    expiration_days: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          ) : coupon.expiration_type === \"fixed\" ? (\n                            <Field label=\"Expires at\">\n                              <Input\n                                type=\"datetime-local\"\n                                value={coupon.expiration_date}\n                                onChange={(event) =>\n                                  setCoupon((current) => ({\n                                    ...current,\n                                    expiration_date: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          ) : null}\n                          {coupon.expiration_type !== \"none\" && (\n                            <>\n                              <Field label=\"Cap expiration\">\n                                <div\n                                  className=\"flex items-center justify-between gap-x-4\"\n                                  style={{ ...panelStyle, padding: \"8px 12px\" }}\n                                >\n                                  <Text size=\"small\" className=\"text-ui-fg-muted\">\n                                    Campaign end or cap date\n                                  </Text>\n                                  <Switch\n                                    checked={coupon.expiration_cap_by_campaign}\n                                    onCheckedChange={(\n                                      expiration_cap_by_campaign,\n                                    ) =>\n                                      setCoupon((current) => ({\n                                        ...current,\n                                        expiration_cap_by_campaign: Boolean(\n                                          expiration_cap_by_campaign,\n                                        ),\n                                      }))\n                                    }\n                                  />\n                                </div>\n                              </Field>\n                              <Field label=\"Expiration cap date\" optional>\n                                <Input\n                                  type=\"datetime-local\"\n                                  disabled={!coupon.expiration_cap_by_campaign}\n                                  value={coupon.expiration_cap_at}\n                                  onChange={(event) =>\n                                    setCoupon((current) => ({\n                                      ...current,\n                                      expiration_cap_at: event.target.value,\n                                    }))\n                                  }\n                                />\n                              </Field>\n                            </>\n                          )}\n                        </div>\n                      </Section>\n\n                      <Section\n                        title=\"Code\"\n                        description=\"Choose whether every issued coupon is unique or shares one code.\"\n                      >\n                        <div style={twoColumnGridStyle}>\n                          <Field label=\"Code strategy\">\n                            <Select\n                              value={coupon.code_strategy}\n                              onValueChange={(code_strategy) =>\n                                setCoupon((current) => ({\n                                  ...current,\n                                  code_strategy: code_strategy as CodeStrategy,\n                                }))\n                              }\n                            >\n                              <Select.Trigger>\n                                <Select.Value />\n                              </Select.Trigger>\n                              <Select.Content>\n                                <Select.Item value=\"unique_code\">\n                                  Unique code\n                                </Select.Item>\n                                <Select.Item value=\"shared_code\">\n                                  Shared code\n                                </Select.Item>\n                              </Select.Content>\n                            </Select>\n                          </Field>\n                          {coupon.code_strategy === \"unique_code\" ? (\n                            <Field label=\"Code prefix\" optional>\n                              <Input\n                                value={coupon.code_prefix}\n                                placeholder=\"COUPON\"\n                                onChange={(event) =>\n                                  setCoupon((current) => ({\n                                    ...current,\n                                    code_prefix: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          ) : (\n                            <Field label=\"Shared code\">\n                              <Input\n                                value={coupon.shared_code}\n                                placeholder=\"SUMMER15\"\n                                onChange={(event) =>\n                                  setCoupon((current) => ({\n                                    ...current,\n                                    shared_code: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          )}\n                        </div>\n                      </Section>\n\n                      <Section title=\"Issuance\">\n                        <div style={twoColumnGridStyle}>\n                          <Field label=\"Max issuance per item\">\n                            <Input\n                              type=\"number\"\n                              min={1}\n                              value={coupon.max_issuance_per_order_item}\n                              onChange={(event) =>\n                                setCoupon((current) => ({\n                                  ...current,\n                                  max_issuance_per_order_item: event.target.value,\n                                }))\n                              }\n                            />\n                          </Field>\n                          {allowPromotionMirror &&\n                            !(\n                              isAmountType && coupon.amounts.length > 1\n                            ) && (\n                              <Field label=\"Promotion mirror\">\n                                <Select\n                                  value={coupon.promotion_mirror_mode}\n                                  disabled={coupon.type === \"buy_x_get_y\"}\n                                  onValueChange={(promotion_mirror_mode) =>\n                                    setCoupon((current) => ({\n                                      ...current,\n                                      promotion_mirror_mode:\n                                        promotion_mirror_mode as MirrorMode,\n                                    }))\n                                  }\n                                >\n                                  <Select.Trigger>\n                                    <Select.Value />\n                                  </Select.Trigger>\n                                  <Select.Content>\n                                    <Select.Item value=\"none\">None</Select.Item>\n                                    <Select.Item value=\"manual\">Manual</Select.Item>\n                                    <Select.Item value=\"auto\">Auto</Select.Item>\n                                  </Select.Content>\n                                </Select>\n                              </Field>\n                            )}\n                        </div>\n                      </Section>\n                    </Section>\n                  </div>\n                )}\n\n                {allowPromotionMirror && activeStep === \"campaign\" && (\n                  <ProgressTabs.Content value=\"campaign\" style={stackStyle}>\n                    <Section title=\"Campaign\">\n                      <div style={twoColumnGridStyle}>\n                        <Field label=\"Campaign mode\">\n                          <Select\n                            value={campaign.mode}\n                            onValueChange={(mode) =>\n                              setCampaign((current) => ({\n                                ...current,\n                                mode: mode as CampaignMode,\n                              }))\n                            }\n                          >\n                            <Select.Trigger>\n                              <Select.Value />\n                            </Select.Trigger>\n                            <Select.Content>\n                              <Select.Item value=\"none\">No campaign</Select.Item>\n                              <Select.Item value=\"existing\">\n                                Existing campaign\n                              </Select.Item>\n                              <Select.Item value=\"new\">New campaign</Select.Item>\n                            </Select.Content>\n                          </Select>\n                        </Field>\n                        {campaign.mode === \"existing\" && (\n                          <Field label=\"Existing campaign\">\n                            <OptionSelect\n                              value={campaign.campaign_id}\n                              options={options.campaigns || []}\n                              onChange={(campaign_id) =>\n                                setCampaign((current) => ({\n                                  ...current,\n                                  campaign_id,\n                                }))\n                              }\n                            />\n                          </Field>\n                        )}\n                        {campaign.mode === \"new\" && (\n                          <>\n                            <Field label=\"Name\">\n                              <Input\n                                value={campaign.name}\n                                onChange={(event) =>\n                                  setCampaign((current) => ({\n                                    ...current,\n                                    name: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                            <Field label=\"Identifier\">\n                              <Input\n                                value={campaign.campaign_identifier}\n                                onChange={(event) =>\n                                  setCampaign((current) => ({\n                                    ...current,\n                                    campaign_identifier: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                            <Field label=\"Starts at\" optional>\n                              <Input\n                                type=\"datetime-local\"\n                                value={campaign.starts_at}\n                                onChange={(event) =>\n                                  setCampaign((current) => ({\n                                    ...current,\n                                    starts_at: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                            <Field label=\"Ends at\" optional>\n                              <Input\n                                type=\"datetime-local\"\n                                value={campaign.ends_at}\n                                onChange={(event) =>\n                                  setCampaign((current) => ({\n                                    ...current,\n                                    ends_at: event.target.value,\n                                  }))\n                                }\n                              />\n                            </Field>\n                          </>\n                        )}\n                      </div>\n                    </Section>\n                  </ProgressTabs.Content>\n                )}\n\n                {activeStep === \"prices\" && (\n                  <ProgressTabs.Content value=\"prices\" style={{ height: \"100%\" }}>\n                    <ProductPricesTable\n                      currencies={currencies}\n                      couponValue={formatCouponValue(coupon, currencies)}\n                      prices={product.price_amounts}\n                      onChange={(currencyCode, value) =>\n                        setProduct((current) => ({\n                          ...current,\n                          price_amounts: {\n                            ...current.price_amounts,\n                            [currencyCode]: value,\n                          },\n                        }))\n                      }\n                    />\n                  </ProgressTabs.Content>\n                )}\n              </div>\n            </div>\n          </FocusModal.Body>\n\n          <FocusModal.Footer style={{ flexShrink: 0 }}>\n            <Button variant=\"secondary\" onClick={() => onOpenChange(false)}>\n              Cancel\n            </Button>\n            {currentStepIndex > 0 && (\n              <Button\n                variant=\"secondary\"\n                onClick={() =>\n                  setActiveStep(visibleSteps[currentStepIndex - 1])\n                }\n              >\n                Back\n              </Button>\n            )}\n            {currentStepIndex < visibleSteps.length - 1 ? (\n              <Button\n                disabled={!activeStepComplete}\n                onClick={() => {\n                  const nextIndex = currentStepIndex + 1\n                  setFurthestStepIndex((current) =>\n                    Math.max(current, nextIndex),\n                  )\n                  setActiveStep(visibleSteps[nextIndex])\n                }}\n              >\n                Continue\n              </Button>\n            ) : (\n              <Button\n                disabled={!activeStepComplete}\n                isLoading={saving}\n                onClick={() => void save()}\n              >\n                Save\n              </Button>\n            )}\n          </FocusModal.Footer>\n        </ProgressTabs>\n      </FocusModal.Content>\n    </FocusModal>\n  )\n}\n\nexport function CouponProductsPage({\n  allowPromotionMirror = false,\n  apiBase,\n  title,\n}: {\n  allowPromotionMirror?: boolean\n  apiBase: ApiBase\n  title: string\n}) {\n  const [products, setProducts] = useState<CouponProductRow[]>([])\n  const [options, setOptions] = useState<OptionsPayload>({})\n  const [loading, setLoading] = useState(true)\n  const [loadError, setLoadError] = useState<string | null>(null)\n  const [modalOpen, setModalOpen] = useState(false)\n  const [editingRow, setEditingRow] = useState<CouponProductRow | null>(null)\n  const prompt = usePrompt()\n  const couponBase = `${apiBase}/coupon-products`\n\n  const load = useCallback(async () => {\n    setLoading(true)\n    setLoadError(null)\n    try {\n      const [productsPayload, optionsPayload] = await Promise.all([\n        apiFetch<{ coupon_products: CouponProductRow[] }>(couponBase),\n        apiFetch<OptionsPayload>(`${couponBase}/options`),\n      ])\n      setProducts(productsPayload.coupon_products || [])\n      setOptions(optionsPayload || {})\n    } catch (error) {\n      const message =\n        error instanceof Error\n          ? error.message\n          : \"Failed to load coupon products\"\n      setLoadError(message)\n      toast.error(message)\n    } finally {\n      setLoading(false)\n    }\n  }, [couponBase])\n\n  useEffect(() => {\n    void load()\n  }, [load])\n\n  const remove = async (row: CouponProductRow) => {\n    const confirmed = await prompt({\n      title: \"Remove coupon product?\",\n      description: `This removes coupon issuance from ${row.product.title || row.product.id\n        }. The underlying Medusa product will remain available.`,\n      confirmText: \"Remove product\",\n      cancelText: \"Cancel\",\n      variant: \"danger\",\n    })\n    if (!confirmed) return\n\n    try {\n      await apiFetch(`${couponBase}/${row.product.id}`, { method: \"DELETE\" })\n      toast.success(\"Coupon configuration removed\")\n      await load()\n    } catch (error) {\n      toast.error(error instanceof Error ? error.message : \"Delete failed\")\n    }\n  }\n\n  const mirror = async (row: CouponProductRow) => {\n    try {\n      await apiFetch(\n        `/admin/coupon-products/${row.product.id}/mirror-promotion`,\n        {\n          method: \"POST\",\n          body: JSON.stringify({}),\n        },\n      )\n      toast.success(\"Promotion mirror created\")\n    } catch (error) {\n      toast.error(error instanceof Error ? error.message : \"Mirror failed\")\n    }\n  }\n\n  return (\n    <Container className=\"divide-y p-0\">\n      <div className=\"flex items-center justify-between px-6 py-4\">\n        <Heading level=\"h1\">{title}</Heading>\n        <div className=\"flex items-center gap-x-2\">\n          <Button size=\"small\" variant=\"secondary\" onClick={() => void load()}>\n            <ArrowPath /> Refresh\n          </Button>\n          <Button\n            size=\"small\"\n            onClick={() => {\n              setEditingRow(null)\n              setModalOpen(true)\n            }}\n          >\n            <Plus /> Create\n          </Button>\n        </div>\n      </div>\n\n      {loading ? (\n        <CouponEmptyState title=\"Loading coupon products\" />\n      ) : loadError ? (\n        <CouponEmptyState title={loadError} />\n      ) : products.length ? (\n        <Table>\n          <Table.Header>\n            <Table.Row>\n              <Table.HeaderCell>Product</Table.HeaderCell>\n              <Table.HeaderCell>Status</Table.HeaderCell>\n              <Table.HeaderCell>Type</Table.HeaderCell>\n              <Table.HeaderCell>Code</Table.HeaderCell>\n              <Table.HeaderCell>Campaign</Table.HeaderCell>\n              <Table.HeaderCell>Issued</Table.HeaderCell>\n              <Table.HeaderCell />\n            </Table.Row>\n          </Table.Header>\n          <Table.Body\n            style={{ borderBottom: 'none' }}>\n            {products.map((row) => {\n              const config = row.coupon_product_config\n              return (\n                <Table.Row key={row.id}\n                  style={{ borderBottom: 'none', background: 'none' }}>\n                  <Table.Cell>\n                    <div className=\"flex flex-col\">\n                      <Text weight=\"plus\">\n                        {row.product.title || row.product.id}\n                      </Text>\n                      <Text size=\"small\" className=\"text-ui-fg-muted\">\n                        {row.product.handle || row.product.id}\n                      </Text>\n                    </div>\n                  </Table.Cell>\n                  <Table.Cell>\n                    <StatusBadge\n                      color={couponStatusColor(config.promotion_status)}\n                    >\n                      {config.promotion_status || \"draft\"}\n                    </StatusBadge>\n                  </Table.Cell>\n                  <Table.Cell>{couponTypeLabel(config)}</Table.Cell>\n                  <Table.Cell>\n                    {config.code_strategy === \"shared_code\"\n                      ? config.shared_code || \"Shared\"\n                      : `${config.code_prefix || \"COUPON\"}-*`}\n                  </Table.Cell>\n                  <Table.Cell>{campaignLabel(config)}</Table.Cell>\n                  <Table.Cell>{row.entitlements_count || 0}</Table.Cell>\n                  <Table.Cell>\n                    <div className=\"flex justify-end gap-x-2\">\n                      {allowPromotionMirror &&\n                        !(\n                          config.benefit_type === \"fixed_amount\" &&\n                          (config.amounts?.length || 0) > 1\n                        ) && (\n                          <Button\n                            size=\"small\"\n                            variant=\"secondary\"\n                            onClick={() => void mirror(row)}\n                          >\n                            Mirror\n                          </Button>\n                        )}\n                      <Button\n                        size=\"small\"\n                        variant=\"secondary\"\n                        onClick={() => {\n                          setEditingRow(row)\n                          setModalOpen(true)\n                        }}\n                      >\n                        <PencilSquare />\n                      </Button>\n                      <Button\n                        size=\"small\"\n                        variant=\"danger\"\n                        onClick={() => void remove(row)}\n                      >\n                        <Trash />\n                      </Button>\n                    </div>\n                  </Table.Cell>\n                </Table.Row>\n              )\n            })}\n          </Table.Body>\n        </Table>\n      ) : (\n        <CouponEmptyState\n          title=\"No coupon products found\"\n          description=\"Create a new coupon product to get started.\"\n        />\n      )}\n\n      <CouponProductModal\n        open={modalOpen}\n        row={editingRow}\n        apiBase={apiBase}\n        options={options}\n        allowPromotionMirror={allowPromotionMirror}\n        onOpenChange={setModalOpen}\n        onSaved={load}\n      />\n    </Container>\n  )\n}\n", "import { Text } from \"@medusajs/ui\"\n\nexport function CouponEmptyState({\n  description,\n  title,\n}: {\n  description?: string\n  title: string\n}) {\n  return (\n    <div className=\"flex w-full flex-1 flex-col overflow-hidden\">\n      <div className=\"flex min-h-[250px] w-full flex-1 flex-col items-center justify-center px-6 py-4\">\n        <div className=\"flex size-full flex-col items-center justify-center gap-2 text-center\">\n          <Text weight=\"plus\">{title}</Text>\n          {description ? <Text>{description}</Text> : null}\n        </div>\n      </div>\n    </div>\n  )\n}\n", "import { CouponDetailPageView } from \"../../../../dashboard/coupons/coupon-manager\"\n\nexport default function CouponDetailPage() {\n  return <CouponDetailPageView apiBase=\"/admin\" />\n}\n", "import type { RouteConfig } from \"@mercurjs/dashboard-sdk\"\nimport { ReceiptPercent } from \"@medusajs/icons\"\nimport { CouponProductsPageView } from \"../../../../dashboard/coupons/coupon-manager\"\n\nexport const config: RouteConfig = {\n  label: \"Coupon Products\",\n  icon: ReceiptPercent,\n}\n\nexport default function CouponProductsPage() {\n  return (\n    <CouponProductsPageView\n      apiBase=\"/admin\"\n      title=\"Coupon Products\"\n      allowPromotionMirror\n    />\n  )\n}\n", "import i18nResources from \"./i18n\"\nimport CouponsPage, { config as couponsConfig } from \"./routes/coupons/page\"\nimport CouponDetailPage from \"./routes/coupons/[id]/page\"\nimport CouponProductsPage, {\n  config as couponProductsConfig,\n} from \"./routes/coupons/products/page\"\n\nconst routeModule = {\n  routes: [\n    {\n      Component: CouponsPage,\n      path: \"/coupons\",\n    },\n    {\n      Component: CouponProductsPage,\n      path: \"/coupons/products\",\n    },\n    {\n      Component: CouponDetailPage,\n      path: \"/coupons/:id\",\n    },\n  ],\n}\n\nconst menuItemModule = {\n  menuItems: [\n    {\n      label: couponsConfig.label,\n      icon: couponsConfig.icon,\n      path: \"/coupons\",\n      rank: couponsConfig.rank,\n      nested: couponsConfig.nested,\n      translationNs: couponsConfig.translationNs,\n    },\n    {\n      label: couponProductsConfig.label,\n      icon: couponProductsConfig.icon,\n      path: \"/coupons/products\",\n      rank: 11,\n      nested: \"/coupons\",\n      translationNs: couponProductsConfig.translationNs,\n    },\n  ],\n}\n\nexport default {\n  widgetModule: {\n    widgets: [],\n  },\n  routeModule,\n  menuItemModule,\n  formModule: {\n    customFields: {},\n  },\n  displayModule: {\n    displays: {},\n  },\n  i18nModule: i18nResources,\n}\n"],
  "mappings": "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",
  "names": ["useCallback", "useEffect", "useMemo", "useState", "ArrowPath", "PencilSquare", "Plus", "Trash", "Button", "Container", "CurrencyInput", "FocusModal", "Heading", "Input", "Label", "ProgressTabs", "Select", "StatusBadge", "Switch", "Table", "Text", "Textarea", "toast", "usePrompt", "Text", "jsx", "jsxs", "config", "row", "Text", "jsx", "jsxs", "Text", "value", "values", "payload", "row", "config", "Fragment", "jsx", "jsxs", "backendUrl", "apiErrorMessage", "apiFetch", "amount", "currency", "jsxs", "jsx", "Text", "Heading", "Container", "StatusBadge", "Fragment", "useState", "useEffect", "apiFetch", "toast", "Table", "useCallback", "Button", "ArrowPath", "jsx", "jsx", "ReceiptPercent", "jsx", "config", "ReceiptPercent", "CouponProductsPage", "CouponProductsPage", "config"]
}
