@feedmepos/mf-connect 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/index-BXTQ6onZ.js

@@ -0,0 +1,1067 @@
+import { z as e, F as n, e as b, m as l, g as se, d as _ } from "./loading-CYFsZ9UB.js";
+import { c as f, F as P, e as m, f as ae, g as re, i as p, j as le, k as ce } from "./index-S6sFiBxK.js";
+import { b as S } from "./index-BPc3wxOE.js";
+import { d as x, e as de } from "./index-CBzSPD25.js";
+import "vue";
+const L = e.enum([
+  "VOUCHER",
+  "PROMOTION",
+  "POINT",
+  "CREDIT",
+  "MEMBERSHIP",
+  "BROADCAST",
+  "COIN",
+  "REWARD_POOL",
+  "GAME",
+  "MISSION"
+]), T = e.enum(["TIME_BASED_PROMOTION", "GAME_PROMOTION"]), bn = {
+  [T.enum.TIME_BASED_PROMOTION]: "7.7.4",
+  [T.enum.GAME_PROMOTION]: "7.7.4"
+};
+e.object({
+  location: n,
+  memberId: n,
+  nettTotal: b,
+  remark: e.string().optional()
+});
+const me = e.enum(["COUNTER", "POS"]);
+e.object({
+  id: e.string(),
+  userId: e.string(),
+  name: e.string().nullish(),
+  birthday: e.string().nullish(),
+  phoneNumber: e.string().nullish(),
+  balance: e.number().nullish(),
+  level: e.number().nullish(),
+  mostPurchasedItems: e.array(e.string()).nullish()
+});
+const ue = {
+  collectionName: "Bills"
+}, pe = e.object({
+  _id: e.string(),
+  items: e.record(e.string(), e.number()).nullish(),
+  // business: z.string(),
+  // adjustments: z.record(FdoBillAdjustment),
+  // refundedFrom: z.string().nullish(),
+  user: e.string().nullish(),
+  memberid: e.string().nullish(),
+  // roundToNearest: z.number().nullish(),
+  nettTotal: b,
+  // activeItems: z.array(z.string()),
+  remark: e.string().nullish(),
+  createdAt: e.coerce.date(),
+  completedAt: e.coerce.date(),
+  location: e.string(),
+  channel: me.optional()
+}).transform((t) => ({
+  ...t,
+  createdTime: t.createdAt,
+  completedTime: t.completedAt,
+  get amount() {
+    return t.nettTotal.amount / 10 ** t.nettTotal.precision;
+  }
+})).describe(l.describe(ue)), ge = e.object({
+  _id: e.string(),
+  rating: e.coerce.number(),
+  user: e.string(),
+  restaurant: e.string(),
+  message: e.string(),
+  submittedAt: e.coerce.date()
+}), s = e.enum([
+  "SIMPLE_CLAIM",
+  "LINK_CLAIM",
+  "BILL_COMPLETED",
+  "SCHEDULE",
+  "BIRTHDAY",
+  "FEEDBACK",
+  "ENTER_SEGMENT",
+  "MEMBERSHIP_JOINED",
+  "TIER_UPGRADED",
+  "MAKING_ORDER",
+  "ISSUE_REWARD",
+  "MEMBER_REWARD",
+  "GAME_COMPLETED",
+  "PAGINATE_SCHEDULE",
+  "REFERRAL_ADDED"
+]), yn = s.extract([
+  "BILL_COMPLETED",
+  "FEEDBACK",
+  "GAME_COMPLETED",
+  "MAKING_ORDER",
+  "MEMBERSHIP_JOINED",
+  "SCHEDULE",
+  "SIMPLE_CLAIM",
+  "TIER_UPGRADED",
+  "ISSUE_REWARD"
+]);
+e.enum(["START_OF", "BEFORE"]);
+e.enum(["WEEK", "MONTH"]);
+const a = e.object({
+  // type: F_EVENT_TYPE,
+  rule: f.optional()
+}), Ee = a.extend({
+  type: e.literal(s.enum.BILL_COMPLETED)
+}), be = a.extend({
+  type: e.literal(s.enum.FEEDBACK)
+}), ye = a.extend({
+  type: e.literal(s.enum.SIMPLE_CLAIM)
+});
+a.extend({
+  type: e.literal(s.enum.ENTER_SEGMENT),
+  segment: e.string()
+});
+const he = a.extend({
+  type: e.literal(s.enum.MEMBER_REWARD)
+}), Ce = a.extend({
+  type: e.literal(s.enum.SCHEDULE)
+  // option: FdoCronRule,
+}), fe = a.extend({
+  type: e.literal(s.enum.MEMBERSHIP_JOINED)
+}), Ie = a.extend({
+  type: e.literal(s.enum.TIER_UPGRADED)
+}), Re = a.extend({
+  type: e.literal(s.enum.MAKING_ORDER)
+}), _e = a.extend({
+  type: e.literal(s.enum.ISSUE_REWARD)
+}), Fe = a.extend({
+  type: e.literal(s.enum.GAME_COMPLETED)
+});
+a.extend({
+  type: e.literal(s.enum.REFERRAL_ADDED)
+});
+const De = e.discriminatedUnion("type", [
+  ye,
+  Ee,
+  Ce,
+  be,
+  fe,
+  Ie,
+  Re,
+  _e,
+  he,
+  Fe
+]);
+e.object({
+  _id: n,
+  type: s,
+  ref: e.string(),
+  context: e.record(e.string(), e.any()).optional()
+}).describe(JSON.stringify({ collectionName: "EventLogs" }));
+const u = e.object({
+  type: s,
+  context: e.any(),
+  businessIds: e.array(n).optional(),
+  campaignIds: e.array(n).optional(),
+  slackWebhookUrl: e.string().optional(),
+  emittedAt: e.coerce.date().default(/* @__PURE__ */ new Date())
+}), Me = u.extend({
+  type: e.literal(s.enum.BILL_COMPLETED),
+  context: e.object({
+    bill: pe,
+    rawBill: e.any()
+  })
+}), Oe = u.extend({
+  type: e.literal(s.enum.SCHEDULE),
+  context: e.object({
+    triggeredAt: e.coerce.date()
+  })
+}), Te = u.extend({
+  type: e.literal(s.enum.PAGINATE_SCHEDULE),
+  context: e.object({
+    triggeredAt: e.coerce.date(),
+    business: n,
+    skip: e.coerce.number(),
+    limit: e.coerce.number()
+  })
+}), Ae = u.extend({
+  type: e.literal(s.enum.FEEDBACK),
+  context: e.object({
+    feedback: ge
+  })
+}), Pe = u.extend({
+  type: e.literal(s.enum.MEMBERSHIP_JOINED),
+  context: e.object({
+    user: S
+  })
+}), Se = u.extend({
+  type: e.literal(s.enum.TIER_UPGRADED),
+  context: e.object({
+    transaction: x
+  })
+}), xe = u.extend({
+  type: e.literal(s.enum.ISSUE_REWARD),
+  context: e.object({
+    transaction: x,
+    collection: de
+  })
+});
+u.extend({
+  type: e.literal(s.enum.ISSUE_REWARD),
+  context: e.object({})
+});
+e.discriminatedUnion("type", [
+  Me,
+  Oe,
+  Ae,
+  Pe,
+  Se,
+  xe,
+  Te
+]);
+const Le = e.object({
+  from: e.coerce.number(),
+  to: e.coerce.number().optional()
+}).superRefine((t, i) => {
+  t.from && t.to && t.from > t.to && i.addIssue({
+    code: "custom",
+    message: "Max experience must be more than min experience"
+  });
+}), Ne = e.enum(["MULTIPLIER", "FIXED"]);
+e.object({
+  type: Ne
+});
+const je = e.object({
+  _id: n.optional(),
+  rule: f,
+  tierExpression: e.string().nullish(),
+  expExpression: e.string().nullish()
+}), F = e.object({
+  _id: n,
+  name: e.string().min(1),
+  image: e.string().nullish(),
+  option: Le,
+  cycleOptions: e.array(e.lazy(() => je)).nullish(),
+  member_count: e.number().optional()
+});
+F.partial({
+  _id: !0
+});
+const hn = F.partial({
+  _id: !0
+}), Be = e.object({
+  icon: e.string(),
+  label: e.string(),
+  value: e.string()
+}), Ue = e.object({
+  gatewayKey: e.enum([
+    "REVENUE_MONSTER",
+    "FEEDME",
+    "FEEDME_MEMBER_CREDIT",
+    "RAZER_MERCHANT_SERVICE"
+  ]),
+  checkoutUrl: e.string().optional(),
+  checkoutId: e.string().optional(),
+  callbackUrl: e.string().optional(),
+  vcode: e.string().optional(),
+  merchantId: e.string().optional(),
+  amount: e.string().optional(),
+  currency: e.string().optional(),
+  returnUrl: e.string().optional(),
+  notifyUrl: e.string().optional(),
+  channels: e.array(Be).optional(),
+  transactionId: e.string().optional()
+});
+e.object({
+  trx: e.lazy(() => H),
+  onlineTrx: Ue.optional(),
+  url: e.string().optional()
+});
+const N = e.enum(["POS", "APP", "ADMIN"]), j = e.enum(["topupCount"]), Ge = e.object({
+  line1: e.string(),
+  line2: e.string().optional(),
+  state: e.string(),
+  city: e.string(),
+  postcode: e.string(),
+  country: e.string()
+}), B = e.object({
+  name: e.string(),
+  regNo: e.string(),
+  address: Ge,
+  phoneNo: e.string(),
+  sstRegNo: e.string().optional()
+}), U = e.object({
+  systemCode: e.string(),
+  inclusive: e.boolean()
+}), we = e.object({
+  id: n,
+  dayToExpire: e.number()
+}), ze = e.object({
+  normal: e.coerce.number(),
+  free: e.object({
+    day: e.coerce.number(),
+    amount: e.coerce.number(),
+    remark: e.string().nullish()
+  }).nullish()
+}), He = e.object({
+  systemCode: e.string(),
+  taxCode: e.string()
+}), ke = e.object({
+  name: e.string(),
+  systemCode: e.string(),
+  taxCode: e.string(),
+  rate: se,
+  total: b
+});
+e.object({
+  canPurchase: e.boolean(),
+  reason: e.string()
+});
+e.object({
+  type: j
+});
+e.object({
+  type: j,
+  min: e.number().nullish(),
+  max: e.number().nullish()
+});
+const ve = e.object({
+  options: e.object({
+    maxReceive: e.number().min(0).nullish(),
+    maxPerUser: e.number().min(0).nullish()
+  }),
+  rule: f.nullish()
+}), Ve = (t, i) => {
+  const r = t;
+  r.isFeedvibe && _.Dinero.fromFdoDinero(r.price).toUnit() < 0.1 && i.addIssue({
+    code: "custom",
+    path: ["price"],
+    message: "Price must be at least RM10"
+  });
+}, G = e.object({
+  _id: e.string(),
+  isFeedvibe: e.boolean().nullish(),
+  //   conditions: z.array(FdoTopupCountCondition),
+  image: e.string().nullish(),
+  rule: f.nullish(),
+  name: e.string(),
+  price: b,
+  originalPrice: b.nullish(),
+  // new field to indicate coinPrice
+  coinPrice: e.number().nullish(),
+  titles: e.array(we),
+  credit: ze,
+  taxes: e.array(He),
+  taxTotals: e.array(ke),
+  priceWithTaxes: b.nullish(),
+  vouchers: e.array(n),
+  _inclusiveTaxes: e.array(U).nullish(),
+  _taxSystem: e.array(e.string()).nullish(),
+  stripePriceId: e.string().nullish(),
+  subscriptionValidity: e.number().min(1, "Must be at least 1 day").max(365, "Maximum is 365").nullish(),
+  redeemWithCode: e.boolean().nullish(),
+  internal: e.boolean().optional(),
+  hideInPos: e.boolean().optional(),
+  config: ve.optional(),
+  pf_titles: e.array(e.any()).optional(),
+  pf_vouchers: e.array(e.any()).optional(),
+  pf_credit: e.number().optional()
+}).superRefine((t, i) => {
+  var r, g;
+  t.stripePriceId && !t.subscriptionValidity && i.addIssue({
+    code: "custom",
+    message: "Validity is required when stripePriceId is provided",
+    path: ["subscriptionValidity"]
+  }), t.originalPrice && t.originalPrice.amount && t.originalPrice.amount < t.price.amount && i.addIssue({
+    code: "custom",
+    message: "Original price must be greater than price",
+    path: ["originalPrice"]
+  }), t.price.amount < 0 && i.addIssue({
+    code: "custom",
+    path: ["price"],
+    message: "Price cannot be less than 0"
+  }), t.coinPrice && t.coinPrice < 0 && i.addIssue({
+    code: "custom",
+    path: ["coinPrice"],
+    message: "Point price cannot be less than 0"
+  }), t.credit.normal < 0 && i.addIssue({
+    code: "custom",
+    path: ["credit", "normal"],
+    message: "Normal credit cannot be less than 0"
+  }), t.credit.free && (t.credit.free.amount < 0 && i.addIssue({
+    code: "custom",
+    path: ["credit", "free", "amount"],
+    message: "Free credit cannot be less than 0"
+  }), t.credit.free.amount && t.credit.free.day < 0 && i.addIssue({
+    code: "custom",
+    path: ["credit", "free", "day"],
+    message: "Expiry must be at least 0 (expire same day)"
+  })), t.credit.normal && t.coinPrice && i.addIssue({
+    code: "custom",
+    message: "Bundle redeem with point cannot set normal credit.",
+    path: ["credit", "normal"]
+  }), t.credit.normal > _.Dinero.fromFdoDinero(t.price).toUnit() && i.addIssue({
+    code: "custom",
+    message: `Normal credit cannot be more than price. Max: ${_.Dinero.fromFdoDinero(
+      t.price
+    ).toUnit()}`,
+    path: ["credit", "normal"]
+  }), t.titles.length > 0 && t.titles.some((I) => I.dayToExpire < 0) && i.addIssue({
+    code: "custom",
+    path: ["titles"],
+    message: "Title expiry must be at least 0 day (expire same day)"
+  }), (((g = (r = t.config) == null ? void 0 : r.options) == null ? void 0 : g.maxPerUser) || 0) < 0 && i.addIssue({
+    code: "custom",
+    path: ["config.options.maxPerUser"],
+    message: "Max purchase per user cannot be negative"
+  });
+}).superRefine(Ve), w = e.object({
+  name: e.string(),
+  bundles: e.array(G)
+});
+e.object({
+  _id: e.string(),
+  name: e.string(),
+  expiredAt: e.string()
+});
+const We = e.object({
+  apiKey: e.string(),
+  webhookSecret: e.string()
+}), Ke = e.object({
+  company: B.nullish(),
+  inclusiveTaxes: e.array(U).nullish(),
+  stripe: We.nullable().optional()
+}), Ye = {
+  collectionName: "Stores",
+  transform: {
+    _id: "oid",
+    business: "oid"
+  }
+};
+Ke.extend({
+  _id: n,
+  business: n,
+  categories: e.array(w)
+}).describe(l.describe(Ye));
+const Je = e.object({
+  refundedAt: e.coerce.date(),
+  reason: e.string(),
+  transactions: e.array(n)
+}), z = e.object({
+  type: e.enum(["ONLINE", "OFFLINE", "COIN", "STRIPE", "CARD", "FEEDVIBE", "ADMIN"]),
+  extra: e.string().nullish()
+}), qe = {
+  collectionName: "StoreTransactions",
+  transform: {
+    _id: "oid",
+    business: "oid",
+    location: "oid",
+    member: "oid",
+    transactions: "oid"
+  },
+  lookups: {
+    member: {
+      fromCollection: "UsersV2",
+      as: "pf_member"
+    }
+  }
+}, H = e.object({
+  _id: n,
+  source: N,
+  // can be memberStorePurchase
+  ref: e.string(),
+  business: n,
+  company: B,
+  location: n.optional(),
+  member: n,
+  // createdAt: z.coerce.date(),
+  bundle: G,
+  transactions: e.array(n),
+  // array of transaction id (voucher, credit, title)
+  status: e.enum([
+    "PENDING_PAYMENT",
+    "PENDING_TRANSACTION",
+    "COMPLETED",
+    "REFUNDED"
+  ]),
+  refund: Je.nullish(),
+  paymentType: z.nullish(),
+  paymentRef: e.string().nullish(),
+  webhookUrl: e.string().optional(),
+  webhookSent: e.boolean().optional(),
+  pf_transactions: e.array(e.any()).optional(),
+  pf_member: e.any().optional(),
+  pf_location: e.any().optional(),
+  pf_ref: e.any().optional()
+}).describe(l.describe(qe));
+e.object({
+  bundle: n,
+  member: e.string(),
+  ref: e.string(),
+  paymentType: z.nullish(),
+  withCoin: e.boolean().optional(),
+  card: e.string().optional(),
+  location: n.optional(),
+  source: N,
+  webhookUrl: e.string().optional()
+});
+e.object({
+  categories: e.array(w)
+});
+e.object({
+  id: n,
+  reason: e.string(),
+  location: n.optional()
+});
+e.object({
+  _id: n,
+  business: n,
+  user: n,
+  bundleId: e.string(),
+  transaction: e.array(n),
+  subscriptionId: e.string(),
+  expiredAt: e.coerce.date()
+}).describe(
+  l.describe({
+    collectionName: "StoreSubscriptions",
+    transform: {
+      _id: "oid",
+      business: "oid",
+      user: "oid",
+      transaction: "oid",
+      expiredAt: "date"
+    }
+  })
+);
+e.object({
+  member: e.string(),
+  subscriptionId: e.string()
+});
+const Ze = {
+  collectionName: "Cards",
+  transform: {
+    _id: "oid",
+    business: "oid",
+    member: "oid",
+    redeemedAt: "date"
+  },
+  lookups: {
+    business: {
+      as: "business",
+      fromCollection: "Business"
+    },
+    member: {
+      as: "pf_member",
+      fromCollection: "UsersV2"
+    }
+  }
+};
+e.object({
+  _id: n,
+  business: n,
+  serialNumber: e.string(),
+  setCardOnBind: e.boolean().nullish(),
+  redeemedAt: e.date().nullish(),
+  member: n.nullish(),
+  design: e.string().nullish(),
+  bundle: e.string().nullish(),
+  subscriptionBundle: e.string().nullish(),
+  pf_member: e.lazy(() => S).nullish(),
+  pf_transaction: e.lazy(() => H).nullish()
+}).describe(l.describe(Ze));
+const Xe = e.object({
+  length: e.coerce.number().optional(),
+  charset: e.string(),
+  prefix: e.string().optional(),
+  suffix: e.string().optional(),
+  pattern: e.string().optional()
+});
+e.object({
+  quantity: e.number(),
+  code: e.string(),
+  codeConfig: Xe,
+  setCardOnBind: e.boolean().optional(),
+  design: e.string().nullish(),
+  bundle: e.string().optional(),
+  subscriptionBundle: e.string().optional()
+});
+const $e = e.enum(["SMS", "EMAIL"]), y = e.object({
+  channel: $e,
+  variables: e.array(e.string()),
+  title: e.string().nullish(),
+  design: e.any(),
+  content: e.string(),
+  language: e.string(),
+  imageUrl: e.string().nullish()
+}).superRefine((t, i) => {
+  t.content.length == 0 && i.addIssue({
+    code: e.ZodIssueCode.custom,
+    message: "Content is required"
+  });
+  const r = /{{(.*?)}}/g, g = [...t.content.matchAll(r)].map((E) => E[1]), I = t.variables, C = g.filter((E) => I.indexOf(E) < 0);
+  C.length && i.addIssue({
+    code: e.ZodIssueCode.custom,
+    message: "Invalid variable(s): " + C.join(", ")
+  });
+});
+function Cn(t, i) {
+  return t.replace(/{{(.*?)}}/g, (r, g) => {
+    const C = g.trim().split(".").reduce((E, ie) => (E != null ? E[ie] : null) ?? null, i);
+    return C !== null ? C : r;
+  });
+}
+const D = e.enum(["NO_REWARD", "VOUCHER", "LOYALTY"]), M = e.number().min(0, "Weight need to be at least 0"), k = e.number().int("Must be integer").min(0, "Threshold need to be at least 0"), v = e.object({
+  type: e.literal(D.enum.NO_REWARD),
+  collectible: e.null(),
+  weight: M
+}), V = e.object({
+  type: e.literal(D.enum.VOUCHER),
+  collectible: n,
+  collectibleConfig: e.lazy(() => P._def.right.options[0]),
+  earningOption: e.lazy(() => m)
+}), O = e.object({
+  type: e.literal(D.enum.LOYALTY),
+  collectible: n,
+  earningOption: e.lazy(() => m),
+  validityOption: e.lazy(() => ae)
+}), W = V.extend({
+  weight: M
+}), K = O.extend({
+  weight: e.number().min(0, "Weight need to be at least 0")
+}), fn = O.extend({
+  validityOption: re,
+  weight: M
+}), Qe = e.discriminatedUnion("type", [
+  W,
+  K,
+  v
+]), A = e.discriminatedUnion("type", [
+  W.extend({
+    collectible: n.nullish(),
+    business: n.nullish()
+  }),
+  K.extend({
+    collectible: n.nullish(),
+    business: n.nullish()
+  }),
+  v
+]), Y = V.extend({
+  threshold: k
+}), J = O.extend({
+  threshold: k
+}), q = e.discriminatedUnion("type", [
+  Y,
+  J
+]), en = e.discriminatedUnion("type", [
+  Y.extend({
+    collectible: n.nullish(),
+    business: n.nullish()
+  }),
+  J.extend({
+    collectible: n.nullish(),
+    collectibleConfig: P.nullish(),
+    business: n.nullish()
+  })
+]), nn = {
+  collectionName: "Locations",
+  transform: {
+    _id: "oid",
+    business: "oid"
+  }
+}, Z = e.object({
+  _id: n,
+  business: n,
+  name: e.string(),
+  code: e.string().nullish(),
+  otp: e.string().nullish(),
+  otpExpiredAt: e.coerce.date().nullish(),
+  apiToken: e.string().nullish()
+}).describe(l.describe(nn));
+e.object({
+  _id: n,
+  name: e.string(),
+  location: n,
+  os: e.string(),
+  apiToken: e.string().nullish()
+}).describe(l.describe({
+  collectionName: "LocationDevices",
+  transform: {
+    _id: "oid",
+    location: "oid"
+  }
+}));
+const tn = e.enum(["PROGRESSIVE", "STAMP"]), on = e.object({
+  type: tn,
+  end: e.number().int().min(0, "Threshold need to be at least 1"),
+  rewards: e.array(e.lazy(() => q)).nullish()
+}).superRefine((t, i) => {
+  t.type == "STAMP" && t.end > 40 && (i.addIssue({
+    code: "custom",
+    path: [],
+    message: "Stamp mission can have at most 40 threshold"
+  }), i.addIssue({
+    code: "custom",
+    path: ["end"],
+    message: "Stamp mission can have at most 40 threshold"
+  }));
+}), sn = {
+  collectionName: "Groups",
+  transform: {
+    _id: "oid",
+    business: "oid"
+  },
+  lookups: {
+    business: {
+      fromCollection: "Businesses",
+      as: "pf_business"
+    },
+    pf_campaigns: {
+      fromCollection: "Campaigns",
+      as: "pf_campaigns",
+      localField: "_id",
+      foreignField: "group"
+    }
+  }
+}, In = e.object({
+  _id: n,
+  name: e.string().min(1).max(300),
+  business: n,
+  pf_campaigns: e.array(e.any()).optional()
+}).describe(l.describe(sn)), an = e.object({
+  from: e.string().email().nullish(),
+  name: e.string().min(1).max(50).nullish()
+}), rn = e.object({
+  type: e.literal(L.enum.MEMBERSHIP),
+  business: n,
+  name: e.string().min(1).max(50),
+  image: e.string().nullish(),
+  url: e.string().nullish(),
+  tiers: e.array(e.lazy(() => F)),
+  titles: e.array(n),
+  tierCycleEnable: e.boolean().optional(),
+  tierCycle: e.lazy(() => f).nullish(),
+  welcomeMessage: y.optional(),
+  advertisements: e.array(e.string()).optional(),
+  cardEnable: e.boolean().optional(),
+  design: e.array(
+    e.object({
+      _id: n,
+      image: e.string()
+    })
+  ).optional(),
+  targetLocation: e.array(n).nullish(),
+  brand: e.string().nullish(),
+  email: an.nullish(),
+  freeCreditAsDiscount: e.boolean().optional(),
+  pf_title: e.array(e.lazy(() => p)).optional(),
+  pf_targetLocation: e.array(e.lazy(() => Z)).optional(),
+  // new structure
+  group: e.string().nullish(),
+  templateId: n.nullish()
+}), o = L.exclude(["MEMBERSHIP"]), c = e.object({
+  _id: n.nullish(),
+  type: o,
+  // common information
+  business: n,
+  name: e.string().min(1).max(50),
+  image: e.string().nullish(),
+  description: e.string().max(500).nullish(),
+  timeframeOptions: le.superRefine((t, i) => {
+    t.start && t.end && t.end < t.start && i.addIssue({
+      code: "custom",
+      path: [],
+      params: {
+        i18n: { key: "timeframe.end_before_start" }
+      }
+    });
+  }).nullish(),
+  targetLocation: e.array(n).nullish(),
+  event: De,
+  config: ce.nullish(),
+  currentReceive: e.coerce.number().optional(),
+  // new group structure
+  group: n.nullish(),
+  templateId: n.nullish(),
+  pf_targetLocation: e.array(e.lazy(() => Z)).optional()
+}), d = {
+  [o.enum.VOUCHER]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "MEMBERSHIP_JOINED",
+    "TIER_UPGRADED",
+    "SCHEDULE",
+    "SIMPLE_CLAIM"
+  ],
+  [o.enum.PROMOTION]: ["MAKING_ORDER"],
+  [o.enum.POINT]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "MEMBERSHIP_JOINED",
+    "TIER_UPGRADED",
+    "SCHEDULE"
+  ],
+  [o.enum.CREDIT]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "MEMBERSHIP_JOINED",
+    "TIER_UPGRADED",
+    "SCHEDULE"
+  ],
+  [o.enum.BROADCAST]: [
+    "SCHEDULE",
+    "ISSUE_REWARD",
+    "FEEDBACK"
+  ],
+  [o.enum.COIN]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "MEMBERSHIP_JOINED",
+    "TIER_UPGRADED",
+    "SCHEDULE"
+  ],
+  [o.enum.REWARD_POOL]: ["GAME_COMPLETED"],
+  [o.enum.GAME]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "MEMBERSHIP_JOINED",
+    "TIER_UPGRADED",
+    "SCHEDULE",
+    "SIMPLE_CLAIM"
+  ],
+  [o.enum.MISSION]: [
+    "BILL_COMPLETED",
+    "FEEDBACK",
+    "SCHEDULE"
+  ]
+}, X = c.extend({
+  type: e.literal(o.enum.VOUCHER),
+  // event
+  code: e.string().min(0).max(15).optional(),
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.VOUCHER])
+    })
+  ),
+  earningOption: m.default({
+    amount: 1,
+    type: "FIXED"
+  }),
+  collectible: n,
+  hideInApp: e.boolean().optional(),
+  notify: e.boolean().optional(),
+  notifyMessage: e.lazy(() => y).optional(),
+  notifyCampaign: n.nullish(),
+  pf_collectible: e.lazy(() => p).optional(),
+  pf_notifyCampaign: e.lazy(() => h).optional()
+}), ln = e.object({
+  gameType: e.string()
+}), $ = c.extend({
+  type: e.literal(o.enum.PROMOTION),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.PROMOTION])
+    })
+  ),
+  effect: e.custom().superRefine((t, i) => {
+    t || i.addIssue({
+      code: "custom",
+      path: [],
+      params: {
+        i18n: { key: "zodCustom.campaign.effect_required" }
+      }
+    });
+  }),
+  gameConfig: ln.nullish()
+}), Q = c.extend({
+  type: e.literal(o.enum.POINT),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.POINT])
+    })
+  ),
+  earningOption: m,
+  collectible: n,
+  notify: e.boolean().optional(),
+  notifyMessage: e.lazy(() => y).optional(),
+  notifyCampaign: n.nullish(),
+  pf_collectible: e.lazy(() => p).optional(),
+  pf_notifyCampaign: e.lazy(() => h).optional()
+}), ee = c.extend({
+  type: e.literal(o.enum.CREDIT),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.CREDIT])
+    })
+  ),
+  earningOption: m,
+  collectible: n,
+  notify: e.boolean().optional(),
+  notifyMessage: e.lazy(() => y).optional(),
+  notifyCampaign: n.nullish(),
+  pf_collectible: e.lazy(() => p).optional(),
+  pf_notifyCampaign: e.lazy(() => h).optional()
+}), h = c.extend({
+  type: e.literal(o.enum.BROADCAST),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.BROADCAST])
+    })
+  ),
+  message: y,
+  linkedCampaign: n.nullish()
+}), ne = c.extend({
+  type: e.literal(o.enum.COIN),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.COIN])
+    })
+  ),
+  earningOption: m,
+  collectible: n,
+  notify: e.boolean().optional(),
+  notifyMessage: e.lazy(() => y).optional(),
+  notifyCampaign: n.nullish(),
+  pf_collectible: e.lazy(() => p).optional(),
+  pf_notifyCampaign: e.lazy(() => h).optional()
+}), R = c.extend({
+  type: e.literal(o.enum.REWARD_POOL),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.REWARD_POOL])
+    })
+  ),
+  rewards: e.array(e.lazy(() => Qe)).min(1, "Requires at least 1 reward")
+}), te = c.extend({
+  type: e.literal(o.enum.GAME),
+  // event
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.GAME])
+    })
+  ),
+  earningOption: m,
+  collectible: n,
+  game: e.lazy(() => R).optional(),
+  pf_collectible: e.lazy(() => p).optional(),
+  rewardPool: n.optional()
+}), oe = c.extend({
+  type: e.literal(o.enum.MISSION),
+  event: a.merge(
+    e.object({
+      type: e.enum(d[o.enum.MISSION])
+    })
+  ),
+  earningOption: m,
+  collectible: n,
+  pf_collectible: e.lazy(() => p).optional(),
+  mission: e.lazy(() => on),
+  rewards: e.array(e.lazy(() => q)).min(1, "Requires at least 1 reward")
+}), cn = {
+  collectionName: "Campaigns",
+  transform: {
+    _id: "oid",
+    business: "oid",
+    collectible: "oid",
+    templateId: "oid",
+    group: "oid",
+    notifyCampaign: "oid",
+    linkedCampaign: "oid",
+    rewardPool: "oid"
+  },
+  lookups: {
+    business: {
+      fromCollection: "Businesses",
+      as: "pf_business"
+    },
+    targetLocation: {
+      fromCollection: "Locations",
+      as: "pf_targetLocation"
+    },
+    collectible: {
+      fromCollection: "CollectibleConfigs",
+      as: "pf_collectible"
+    },
+    titles: {
+      fromCollection: "CollectibleConfigs",
+      as: "pf_title"
+    },
+    templateId: {
+      fromCollection: "Templates",
+      as: "template"
+    },
+    notifyCampaign: {
+      fromCollection: "Campaigns",
+      as: "pf_notifyCampaign"
+    },
+    rewardPool: {
+      fromCollection: "Campaigns",
+      as: "game"
+    }
+  }
+}, Rn = e.object({ _id: n }).and(
+  e.discriminatedUnion("type", [
+    rn,
+    X,
+    $,
+    Q,
+    ee,
+    h,
+    ne,
+    R,
+    te,
+    oe
+  ])
+).describe(l.describe(cn)), _n = e.discriminatedUnion("type", [
+  X.extend({
+    business: n.nullish()
+  }),
+  $.extend({
+    business: n.nullish()
+  }),
+  Q.extend({
+    business: n.nullish()
+  }),
+  ee.extend({
+    business: n.nullish()
+  }),
+  h.extend({
+    business: n.nullish()
+  }),
+  ne.extend({
+    business: n.nullish()
+  }),
+  R.extend({
+    rewards: e.array(e.lazy(() => A)).min(1, "Requires at least 1 reward")
+  }),
+  te.extend({
+    business: n.nullish(),
+    game: R.extend({
+      business: n.nullish(),
+      rewards: e.array(e.lazy(() => A)).min(1, "Requires at least 1 reward")
+    })
+  }),
+  oe.extend({
+    business: n.nullish(),
+    rewards: e.array(e.lazy(() => en)).min(1, "Requires at least 1 reward")
+  })
+]);
+export {
+  d as C,
+  hn as F,
+  o as a,
+  fn as b,
+  A as c,
+  tn as d,
+  en as e,
+  on as f,
+  bn as g,
+  L as h,
+  In as i,
+  _n as j,
+  Rn as k,
+  yn as l,
+  s as m,
+  Ke as n,
+  B as o,
+  Ge as p,
+  G as q,
+  N as r,
+  De as s,
+  rn as t,
+  Cn as u
+};