@timardex/cluemart-shared 2.2.29 → 2.2.40

package/dist/hooks/index.mjs

@@ -1,18 +1,18 @@
-import "../chunk-MQHX5BD6.mjs";
+import "../chunk-NMJ2CR2F.mjs";
 import "../chunk-VA5YN2K3.mjs";
 import "../chunk-VPANTTZI.mjs";
 import "../chunk-DWO35OY4.mjs";
-import "../chunk-J5N3IEGR.mjs";
+import "../chunk-VL275KFW.mjs";
 import {
   SCHOOL_MIN_STUDENT_COUNT,
   isValidIrdNumber,
   normalizeUrl
-} from "../chunk-NRNLARYC.mjs";
+} from "../chunk-BCMBTEGJ.mjs";
 import "../chunk-RE4NZPYY.mjs";
 import {
   dateFormat,
   timeFormat
-} from "../chunk-YFFCHTJS.mjs";
+} from "../chunk-T5ZOYS3L.mjs";
 import {
   EnumAdShowOn,
   EnumAdStatus,
@@ -21,11 +21,11 @@ import {
   EnumAffiliateParticipantType,
   EnumPostContentType,
   EnumPostType
-} from "../chunk-IKRXLKJ3.mjs";
+} from "../chunk-5AAYX364.mjs";
 import "../chunk-RAYUJODN.mjs";
 import "../chunk-DQ7ZHIXW.mjs";
-import "../chunk-LLP7OWX5.mjs";
-import "../chunk-BR4XNXE7.mjs";
+import "../chunk-MKHXXZWF.mjs";
+import "../chunk-TKSBCN3N.mjs";
 import "../chunk-7DQBUZXY.mjs";
 import {
   EnumEventDateStatus,
@@ -36,7 +36,7 @@ import {
   EnumResourceType,
   EnumSocialMedia,
   EnumVendorType
-} from "../chunk-U3KUTQ43.mjs";
+} from "../chunk-XGGFB7HY.mjs";
 import "../chunk-NPFJ2CN2.mjs";
 
 // src/hooks/useLocationSearch.ts
@@ -145,9 +145,6 @@ import * as React from "react";
 import { useForm } from "react-hook-form";
 
 // src/yupSchema/global.ts
-import dayjs from "dayjs";
-import customParseFormat from "dayjs/plugin/customParseFormat.js";
-import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
 import * as yup from "yup";
 var nzBankAccountRegex = /^\d{2}-\d{4}-\d{7}-\d{2}$/;
 var nzIrdNumberRegex = /^\d{3}-\d{3}-\d{2,3}$/;
@@ -187,8 +184,6 @@ var toOptionalNumber = (originalValue) => {
   }
   return Number.isNaN(parsed) ? void 0 : parsed;
 };
-dayjs.extend(isSameOrAfter);
-dayjs.extend(customParseFormat);
 var emailRequiredSchema = yup.string().email("Invalid email address").required("Email is required").label("Email").transform(
   (value) => typeof value === "string" ? value.trim().toLowerCase() : value
 );
@@ -218,32 +213,98 @@ var contactDetailsSchema = yup.object({
   mobilePhone: mobilePhoneSchema,
   landlinePhone: landlinePhoneSchema
 }).nullable().default(void 0);
-var endDateNotInPastTest = yup.string().test("not-in-past", "End date cannot be in the past", (value) => {
+var locationSchema = yup.object().shape({
+  city: yup.string().label("City").required("City is required"),
+  country: yup.string().label("Country").required("Country is required"),
+  fullAddress: yup.string().label("Address").required("Address is required"),
+  geo: yup.object().shape({
+    coordinates: yup.array().of(yup.number().required("Coordinates must be numbers")).length(
+      2,
+      "Coordinates must contain exactly two numbers (longitude, latitude)"
+    ).required("Coordinates are required"),
+    type: yup.string().oneOf(["Point"], "Type must be 'Point'").default("Point").required("Type is required")
+  }),
+  latitude: yup.number().label("Latitude").required("Latitude is required"),
+  longitude: yup.number().label("Longitude").required("Longitude is required"),
+  region: yup.string().label("Region").required("Region is required")
+});
+var passwordSchema = yup.string().trim().label("Password").min(8, "Password must be at least 8 characters long").required("Password is required");
+var socialMediaSchema = yup.object({
+  name: yup.mixed().oneOf(Object.values(EnumSocialMedia)).label("Social Media Name").optional(),
+  link: yup.string().when("name", {
+    is: (name) => !!name,
+    // If name has a value
+    then: () => normalizedUrlTransform().required("Link is required when name is set").url("Link must be a valid URL").label("Social Media Link"),
+    otherwise: (schema) => schema.notRequired()
+  })
+});
+var globalResourceSchema = yup.object().shape({
+  active: yup.boolean().required("Active is required"),
+  cover: yup.object({
+    active: yup.boolean().default(true),
+    source: yup.string().label("Cover").required("Cover Image is required"),
+    title: yup.string().label("Cover Title").required("Cover Title is required")
+  }),
+  contactDetails: contactDetailsSchema,
+  description: yup.string().label("Description").trim().min(50).required("Description is required"),
+  name: yup.string().label("Name").trim().min(3).required("Name is required"),
+  region: yup.string().label("Region").required("Region is required"),
+  socialMedia: yup.array().of(socialMediaSchema).nullable().default(null)
+});
+var categorySchema = yup.array().of(
+  yup.object().shape({
+    id: yup.string().required("Category id is required"),
+    name: yup.string().required("Category name is required"),
+    subcategories: yup.array().of(
+      yup.object().shape({
+        id: yup.string().defined(),
+        items: yup.array().of(
+          yup.object().shape({
+            id: yup.string().defined(),
+            name: yup.string().defined()
+          })
+        ).nullable(),
+        name: yup.string().defined()
+      })
+    ).min(1, "At least one subcategory is required").required("Subcategories are required")
+  })
+);
+
+// src/yupSchema/date.ts
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
+import * as yup2 from "yup";
+dayjs.extend(isSameOrAfter);
+dayjs.extend(customParseFormat);
+var endDateNotInPastTest = yup2.string().test("not-in-past", "End date cannot be in the past", (value) => {
+  if (!value) return true;
   const now = dayjs();
-  return value ? dayjs(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+  return dayjs(value, dateFormat, true).isSameOrAfter(now, "day");
 });
-var startDateNotInPastTest = yup.string().test("not-in-past", "Start date cannot be in the past", (value) => {
+var startDateNotInPastTest = yup2.string().test("not-in-past", "Start date cannot be in the past", (value) => {
+  if (!value) return true;
   const now = dayjs();
-  return value ? dayjs(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+  return dayjs(value, dateFormat, true).isSameOrAfter(now, "day");
 });
-var endDateAfterStartDateTest = yup.string().test(
+var endDateAfterStartDateTest = yup2.string().test(
   "end-after-start",
   "End date cannot be before start date",
   function(value) {
     const { startDate } = this.parent;
-    if (!startDate || !value) return false;
+    if (!startDate || !value) return true;
     return dayjs(value, dateFormat, true).isSameOrAfter(
       dayjs(startDate, dateFormat, true),
       "day"
     );
   }
 );
-var endTimeMustBeAfterStartTimeTest = yup.string().test(
+var endTimeMustBeAfterStartTimeTest = yup2.string().test(
   "valid-end-time",
   "End time must be after start time",
   function(value) {
     const { startDate, endDate, startTime } = this.parent;
-    if (!startDate || !endDate || !startTime || !value) return false;
+    if (!startDate || !endDate || !startTime || !value) return true;
     const startDateTime = dayjs(
       `${startDate} ${startTime}`,
       `${dateFormat} ${timeFormat}`,
@@ -257,13 +318,13 @@ var endTimeMustBeAfterStartTimeTest = yup.string().test(
     return endDateTime.isAfter(startDateTime);
   }
 );
-var startTimeCannotBeInPastTest = yup.string().test(
+var startTimeCannotBeInPastTest = yup2.string().test(
   "valid-start-time",
   "Start time cannot be in the past",
   function(value) {
     const now = dayjs();
     const { startDate } = this.parent;
-    if (!startDate || !value) return false;
+    if (!startDate || !value) return true;
     const startDateTime = dayjs(
       `${startDate} ${value}`,
       `${dateFormat} ${timeFormat}`,
@@ -272,102 +333,67 @@ var startTimeCannotBeInPastTest = yup.string().test(
     return startDateTime.isSameOrAfter(now);
   }
 );
-var dateTimeSchema = yup.object().shape({
-  dateStatus: yup.mixed().oneOf(Object.values(EnumEventDateStatus)).required("Date status is required"),
-  endDate: yup.string().label("End Date").when("dateStatus", {
-    is: (status) => status !== "Canceled" /* CANCELED */,
-    then: (schema) => schema.concat(endDateNotInPastTest).concat(endDateAfterStartDateTest).required("End date is required"),
-    otherwise: (schema) => schema.notRequired()
+var resolveWhenDateStatus = (values) => Array.isArray(values) ? values[0] : values;
+var SKIP_SCHEDULE_STATUSES = /* @__PURE__ */ new Set([
+  "Canceled" /* CANCELED */,
+  "Invalid" /* INVALID */
+]);
+var SKIP_START_PAST_STATUSES = /* @__PURE__ */ new Set([
+  "Started" /* STARTED */,
+  "Ended" /* ENDED */
+]);
+var SKIP_END_PAST_STATUSES = /* @__PURE__ */ new Set([
+  "Ended" /* ENDED */
+]);
+var dateTimeSchema = yup2.object().shape({
+  dateStatus: yup2.mixed().oneOf(Object.values(EnumEventDateStatus)).required("Date status is required"),
+  endDate: yup2.string().label("End Date").when("dateStatus", (values, schema) => {
+    const dateStatus = resolveWhenDateStatus(values);
+    if (SKIP_SCHEDULE_STATUSES.has(dateStatus)) return schema.notRequired();
+    const rules = schema.required("End date is required").concat(endDateAfterStartDateTest);
+    return SKIP_END_PAST_STATUSES.has(dateStatus) ? rules : rules.concat(endDateNotInPastTest);
   }),
-  endTime: yup.string().label("End Time").when("dateStatus", {
-    is: (status) => status !== "Canceled" /* CANCELED */,
-    then: (schema) => schema.concat(endTimeMustBeAfterStartTimeTest).required("End time is required"),
-    otherwise: (schema) => schema.notRequired()
+  endTime: yup2.string().label("End Time").when("dateStatus", (values, schema) => {
+    const dateStatus = resolveWhenDateStatus(values);
+    if (SKIP_SCHEDULE_STATUSES.has(dateStatus)) return schema.notRequired();
+    return schema.required("End time is required").concat(endTimeMustBeAfterStartTimeTest);
   }),
-  startDate: yup.string().label("Start Date").when("dateStatus", {
-    is: (status) => status !== "Canceled" /* CANCELED */,
-    then: (schema) => schema.concat(startDateNotInPastTest).required("Start date is required"),
-    otherwise: (schema) => schema.notRequired()
+  startDate: yup2.string().label("Start Date").when("dateStatus", (values, schema) => {
+    const dateStatus = resolveWhenDateStatus(values);
+    if (SKIP_SCHEDULE_STATUSES.has(dateStatus)) return schema.notRequired();
+    const rules = schema.required("Start date is required");
+    return SKIP_START_PAST_STATUSES.has(dateStatus) ? rules : rules.concat(startDateNotInPastTest);
   }),
-  startTime: yup.string().label("Start Time").when("dateStatus", {
-    is: (status) => status !== "Canceled" /* CANCELED */,
-    then: (schema) => schema.concat(startTimeCannotBeInPastTest).required("Start time is required"),
-    otherwise: (schema) => schema.notRequired()
+  startTime: yup2.string().label("Start Time").when("dateStatus", (values, schema) => {
+    const dateStatus = resolveWhenDateStatus(values);
+    if (SKIP_SCHEDULE_STATUSES.has(dateStatus)) return schema.notRequired();
+    const rules = schema.required("Start time is required");
+    return SKIP_START_PAST_STATUSES.has(dateStatus) ? rules : rules.concat(startTimeCannotBeInPastTest);
   })
 });
-var stallTypesSchema = yup.object({
-  label: yup.string().trim().label("Stall Type").required("Stall type is required"),
-  price: yup.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Stall Price").min(0.1, "Stall price must be at least 0.1").required("Stall price is required").test(
+var stallTypesSchema = yup2.object({
+  label: yup2.string().trim().label("Stall Type").required("Stall type is required"),
+  price: yup2.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Stall Price").min(0.1, "Stall price must be at least 0.1").required("Stall price is required").test(
     "no-leading-zeros",
     "",
     noLeadingZeros("Stall price", { allowDecimal: true })
   ),
-  stallCapacity: yup.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Stall Capacity").typeError("Stall capacity must be a number").min(0, "Stall capacity cannot be negative").integer("Stall capacity must be a whole number").required("Stall capacity is required").test("no-leading-zeros", "", noLeadingZeros("Stall capacity"))
+  stallCapacity: yup2.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Stall Capacity").typeError("Stall capacity must be a number").min(0, "Stall capacity cannot be negative").integer("Stall capacity must be a whole number").required("Stall capacity is required").test("no-leading-zeros", "", noLeadingZeros("Stall capacity"))
 });
 var dateTimeWithPriceSchema = dateTimeSchema.shape({
-  stallTypes: yup.array().of(stallTypesSchema).min(1, "At least one stall type is required").required("Stall types are required")
-});
-var locationSchema = yup.object().shape({
-  city: yup.string().label("City").required("City is required"),
-  country: yup.string().label("Country").required("Country is required"),
-  fullAddress: yup.string().label("Address").required("Address is required"),
-  geo: yup.object().shape({
-    coordinates: yup.array().of(yup.number().required("Coordinates must be numbers")).length(
-      2,
-      "Coordinates must contain exactly two numbers (longitude, latitude)"
-    ).required("Coordinates are required"),
-    type: yup.string().oneOf(["Point"], "Type must be 'Point'").default("Point").required("Type is required")
-  }),
-  latitude: yup.number().label("Latitude").required("Latitude is required"),
-  longitude: yup.number().label("Longitude").required("Longitude is required"),
-  region: yup.string().label("Region").required("Region is required")
-});
-var passwordSchema = yup.string().trim().label("Password").min(8, "Password must be at least 8 characters long").required("Password is required");
-var socialMediaSchema = yup.object({
-  name: yup.mixed().oneOf(Object.values(EnumSocialMedia)).label("Social Media Name").optional(),
-  link: yup.string().when("name", {
-    is: (name) => !!name,
-    // If name has a value
-    then: () => normalizedUrlTransform().required("Link is required when name is set").url("Link must be a valid URL").label("Social Media Link"),
-    otherwise: (schema) => schema.notRequired()
+  // Keep `required` unconditionally so the static type stays `StallType[]`
+  // (matching `DateTimeWithPriceFormValue`); only the min-count rule is
+  // conditional. Skipped statuses may carry an empty stallTypes array.
+  stallTypes: yup2.array().of(stallTypesSchema).required("Stall types are required").when("dateStatus", (values, schema) => {
+    const dateStatus = resolveWhenDateStatus(values);
+    return SKIP_SCHEDULE_STATUSES.has(dateStatus) ? schema : schema.min(1, "At least one stall type is required");
   })
 });
-var globalResourceSchema = yup.object().shape({
-  active: yup.boolean().required("Active is required"),
-  cover: yup.object({
-    active: yup.boolean().default(true),
-    source: yup.string().label("Cover").required("Cover Image is required"),
-    title: yup.string().label("Cover Title").required("Cover Title is required")
-  }),
-  contactDetails: contactDetailsSchema,
-  description: yup.string().label("Description").trim().min(50).required("Description is required"),
-  name: yup.string().label("Name").trim().min(3).required("Name is required"),
-  region: yup.string().label("Region").required("Region is required"),
-  socialMedia: yup.array().of(socialMediaSchema).nullable().default(null)
-});
-var categorySchema = yup.array().of(
-  yup.object().shape({
-    id: yup.string().required("Category id is required"),
-    name: yup.string().required("Category name is required"),
-    subcategories: yup.array().of(
-      yup.object().shape({
-        id: yup.string().defined(),
-        items: yup.array().of(
-          yup.object().shape({
-            id: yup.string().defined(),
-            name: yup.string().defined()
-          })
-        ).nullable(),
-        name: yup.string().defined()
-      })
-    ).min(1, "At least one subcategory is required").required("Subcategories are required")
-  })
-);
 
 // src/yupSchema/event.ts
-import * as yup2 from "yup";
+import * as yup3 from "yup";
 var eventSchema = globalResourceSchema.shape({
-  dateTime: yup2.array().of(dateTimeSchema).min(1, "At least one Event date required").max(50, "You can only add up to 50 Event dates").required("DateTime is required").test(
+  dateTime: yup3.array().of(dateTimeSchema).min(1, "At least one Event date required").max(50, "You can only add up to 50 Event dates").required("DateTime is required").test(
     "unique-start-date-time",
     "Start Date and Start Time must be unique",
     function(value) {
@@ -384,23 +410,23 @@ var eventSchema = globalResourceSchema.shape({
       return true;
     }
   ),
-  eventType: yup2.mixed().oneOf(Object.values(EnumEventType), "Please select a valid Event type").required("Please select an Event type"),
+  eventType: yup3.mixed().oneOf(Object.values(EnumEventType), "Please select a valid Event type").required("Please select an Event type"),
   location: locationSchema,
-  nzbn: yup2.string().required("NZBN is required").matches(nzbnRegex, "NZBN must be 13 digits and start with 94"),
-  rainOrShine: yup2.boolean().label("Rain or Shine").required("Please specify if the event is rain or shine"),
-  tags: yup2.array().of(yup2.string().defined()).min(1, "Tags are required").required("Tags are required")
+  nzbn: yup3.string().required("NZBN is required").matches(nzbnRegex, "NZBN must be 13 digits and start with 94"),
+  rainOrShine: yup3.boolean().label("Rain or Shine").required("Please specify if the event is rain or shine"),
+  tags: yup3.array().of(yup3.string().defined()).min(1, "Tags are required").required("Tags are required")
 });
-var paymentInfoSchema = yup2.object({
-  paymentMethod: yup2.mixed().oneOf(
+var paymentInfoSchema = yup3.object({
+  paymentMethod: yup3.mixed().oneOf(
     Object.values(EnumPaymentMethod),
     "Please select a valid Payment method"
   ).required("Please select a Payment method"),
-  accountHolderName: yup2.string().when("paymentMethod", {
+  accountHolderName: yup3.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
     then: (schema) => schema.required("Account holder name is required for bank transfer").trim(),
     otherwise: (schema) => schema.notRequired()
   }),
-  accountNumber: yup2.string().when("paymentMethod", {
+  accountNumber: yup3.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
     then: (schema) => schema.required("Account number is required for bank transfer").matches(
       nzBankAccountRegex,
@@ -408,18 +434,18 @@ var paymentInfoSchema = yup2.object({
     ).trim(),
     otherwise: (schema) => schema.notRequired()
   }),
-  link: yup2.string().when("paymentMethod", {
+  link: yup3.string().when("paymentMethod", {
     is: (val) => val === "paypal" /* PAYPAL */ || val === "stripe" /* STRIPE */,
     then: () => normalizedUrlTransform().url("Link must be a valid URL").required("Link is required for PayPal/Stripe"),
     otherwise: (schema) => schema.notRequired()
   })
 });
-var eventInfoSchema = yup2.object().shape({
-  applicationDeadlineHours: yup2.number().label("Application Deadline Hours").nullable().transform((value, originalValue) => originalValue === "" ? null : value).typeError("Application deadline hours must be a number").min(1, "Application deadline hours must be at least 1").required("Application deadline hours is required").test("no-leading-zeros", "", noLeadingZeros("Application deadline hours")),
-  dateTime: yup2.array().of(dateTimeWithPriceSchema).required("DateTime is required"),
-  eventId: yup2.string().trim().required("Event ID is required"),
-  packInTime: yup2.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Pack In Time").typeError("Pack in time must be a number").min(1, "Pack in time must be at least 1").required("Pack in time is required").test("no-leading-zeros", "", noLeadingZeros("Pack in time")),
-  paymentDueHours: yup2.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Payment Due Hours").typeError("Payment due hours must be a number").min(1, "Payment due hours must be at least 1").required("Payment due hours is required").test("no-leading-zeros", "", noLeadingZeros("Payment due hours")).test(
+var eventInfoSchema = yup3.object().shape({
+  applicationDeadlineHours: yup3.number().label("Application Deadline Hours").nullable().transform((value, originalValue) => originalValue === "" ? null : value).typeError("Application deadline hours must be a number").min(1, "Application deadline hours must be at least 1").required("Application deadline hours is required").test("no-leading-zeros", "", noLeadingZeros("Application deadline hours")),
+  dateTime: yup3.array().of(dateTimeWithPriceSchema).required("DateTime is required"),
+  eventId: yup3.string().trim().required("Event ID is required"),
+  packInTime: yup3.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Pack In Time").typeError("Pack in time must be a number").min(1, "Pack in time must be at least 1").required("Pack in time is required").test("no-leading-zeros", "", noLeadingZeros("Pack in time")),
+  paymentDueHours: yup3.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Payment Due Hours").typeError("Payment due hours must be a number").min(1, "Payment due hours must be at least 1").required("Payment due hours is required").test("no-leading-zeros", "", noLeadingZeros("Payment due hours")).test(
     "payment-before-deadline",
     "Payment due hours must be less than application deadline hours",
     function(value) {
@@ -427,12 +453,12 @@ var eventInfoSchema = yup2.object().shape({
       return value < applicationDeadlineHours;
     }
   ),
-  paymentInfo: yup2.array().of(paymentInfoSchema).min(1, "At least one payment method is required").required("Payment info is required"),
-  refundPolicy: yup2.array().of(
-    yup2.object({
-      category: yup2.mixed().required("Category is required"),
-      label: yup2.string().required("Label is required"),
-      value: yup2.boolean().required("Value is required")
+  paymentInfo: yup3.array().of(paymentInfoSchema).min(1, "At least one payment method is required").required("Payment info is required"),
+  refundPolicy: yup3.array().of(
+    yup3.object({
+      category: yup3.mixed().required("Category is required"),
+      label: yup3.string().required("Label is required"),
+      value: yup3.boolean().required("Value is required")
     })
   ).min(1, "At least one refund policy item is required").test(
     "at-least-one-true",
@@ -445,12 +471,12 @@ var eventInfoSchema = yup2.object().shape({
 });
 
 // src/yupSchema/vendor.ts
-import * as yup3 from "yup";
-var vendorMenuSchema = yup3.object({
-  description: yup3.string().trim().nullable().optional(),
-  name: yup3.string().trim().nullable().min(3, "Product name must be at least 3 characters").required("Product name is required"),
-  price: yup3.number().transform((v, o) => o === "" ? null : v).min(1, "Product price must be greater than 0").required("Product price is required"),
-  priceMax: yup3.number().transform((v, o) => o === "" ? null : v).min(1, "Product max price must be greater than 0").nullable().optional().test(
+import * as yup4 from "yup";
+var vendorMenuSchema = yup4.object({
+  description: yup4.string().trim().nullable().optional(),
+  name: yup4.string().trim().nullable().min(3, "Product name must be at least 3 characters").required("Product name is required"),
+  price: yup4.number().transform((v, o) => o === "" ? null : v).min(1, "Product price must be greater than 0").required("Product price is required"),
+  priceMax: yup4.number().transform((v, o) => o === "" ? null : v).min(1, "Product max price must be greater than 0").nullable().optional().test(
     "is-greater",
     "Max price must be greater than Product price",
     function(priceMaxValue) {
@@ -462,33 +488,33 @@ var vendorMenuSchema = yup3.object({
       return maxNum > priceNum;
     }
   ),
-  priceUnit: yup3.string().required("Product unit is required")
+  priceUnit: yup4.string().required("Product unit is required")
 });
 var vendorSchema = globalResourceSchema.shape({
   categories: categorySchema.min(1, "Category list must contain at least one item").required("Categories are required"),
-  foodTruck: yup3.boolean().label("Food Truck").required("Please specify if the vendor is a food truck"),
-  products: yup3.object().shape({
-    active: yup3.boolean().nullable().optional(),
-    productsList: yup3.array().of(vendorMenuSchema).nullable().optional()
+  foodTruck: yup4.boolean().label("Food Truck").required("Please specify if the vendor is a food truck"),
+  products: yup4.object().shape({
+    active: yup4.boolean().nullable().optional(),
+    productsList: yup4.array().of(vendorMenuSchema).nullable().optional()
   }).nullable().optional(),
-  vendorType: yup3.mixed().oneOf(Object.values(EnumVendorType)).required("Please select a Vendor type")
+  vendorType: yup4.mixed().oneOf(Object.values(EnumVendorType)).required("Please select a Vendor type")
 });
-var unregisteredVendorSchema = yup3.object().shape({
-  categoryIds: yup3.array().of(yup3.string().defined()).min(1, "Category list must contain at least one item").required("Categories are required"),
-  dateTime: yup3.array().of(dateTimeSchema).min(1, "Select at least one event date").required("DateTime is required"),
+var unregisteredVendorSchema = yup4.object().shape({
+  categoryIds: yup4.array().of(yup4.string().defined()).min(1, "Category list must contain at least one item").required("Categories are required"),
+  dateTime: yup4.array().of(dateTimeSchema).min(1, "Select at least one event date").required("DateTime is required"),
   email: emailRequiredSchema,
-  inviterId: yup3.string().required("Inviter ID is required"),
-  name: yup3.string().label("Stallholder Name").trim().min(3, "Name must be at least 3 characters").required("Name is required"),
-  region: yup3.string().label("Region").required("Region is required")
+  inviterId: yup4.string().required("Inviter ID is required"),
+  name: yup4.string().label("Stallholder Name").trim().min(3, "Name must be at least 3 characters").required("Name is required"),
+  region: yup4.string().label("Region").required("Region is required")
 });
-var vendorInfoSchema = yup3.object().shape({
-  product: yup3.object().shape({
-    foodFlavors: yup3.array().of(
-      yup3.mixed().oneOf(Object.values(EnumFoodFlavor), "Invalid flavor selected").required("Flavor is required")
+var vendorInfoSchema = yup4.object().shape({
+  product: yup4.object().shape({
+    foodFlavors: yup4.array().of(
+      yup4.mixed().oneOf(Object.values(EnumFoodFlavor), "Invalid flavor selected").required("Flavor is required")
     ).min(1, "Food flavors list must contain at least one item").required("Food flavors are required"),
-    packaging: yup3.array().of(yup3.string().defined()).min(1, "Packaging list must contain at least one item").required("Packaging is required"),
-    priceRange: yup3.object().shape({
-      max: yup3.string().required("Max price is required").test(
+    packaging: yup4.array().of(yup4.string().defined()).min(1, "Packaging list must contain at least one item").required("Packaging is required"),
+    priceRange: yup4.object().shape({
+      max: yup4.string().required("Max price is required").test(
         "is-number",
         "Max price must be a valid number",
         (value) => value !== void 0 && value !== "" && !Number.isNaN(Number(value))
@@ -504,49 +530,49 @@ var vendorInfoSchema = yup3.object().shape({
           return maxNum >= minNum;
         }
       ),
-      min: yup3.string().required("Min price is required").test(
+      min: yup4.string().required("Min price is required").test(
         "is-number",
         "Min price must be a valid number",
         (value) => value !== void 0 && value !== "" && !Number.isNaN(Number(value))
       )
     }),
-    producedIn: yup3.array().of(yup3.string().defined()).min(1, "Produced in list must contain at least one item").required("Produced in is required")
+    producedIn: yup4.array().of(yup4.string().defined()).min(1, "Produced in list must contain at least one item").required("Produced in is required")
   }),
-  requirements: yup3.object().shape({
-    electricity: yup3.object().shape({
-      details: yup3.string().trim().test(
+  requirements: yup4.object().shape({
+    electricity: yup4.object().shape({
+      details: yup4.string().trim().test(
         "details-required",
         "Please add electricity details",
         function(value) {
           return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
         }
       ).nullable(),
-      isRequired: yup3.boolean().required("Electricity requirement is required")
+      isRequired: yup4.boolean().required("Electricity requirement is required")
     }),
-    gazebo: yup3.object().shape({
-      details: yup3.string().trim().test(
+    gazebo: yup4.object().shape({
+      details: yup4.string().trim().test(
         "details-required",
         "Please add gazebo details",
         function(value) {
           return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
         }
       ).nullable(),
-      isRequired: yup3.boolean().required("Gazebo requirement is required")
+      isRequired: yup4.boolean().required("Gazebo requirement is required")
     }),
-    table: yup3.object().shape({
-      details: yup3.string().trim().test(
+    table: yup4.object().shape({
+      details: yup4.string().trim().test(
         "details-required",
         "Please add table details",
         function(value) {
           return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
         }
       ).nullable(),
-      isRequired: yup3.boolean().required("Table requirement is required")
+      isRequired: yup4.boolean().required("Table requirement is required")
     })
   }).optional(),
-  stallInfo: yup3.object().shape({
-    size: yup3.object().shape({
-      depth: yup3.string().required("Depth is required").test(
+  stallInfo: yup4.object().shape({
+    size: yup4.object().shape({
+      depth: yup4.string().required("Depth is required").test(
         "is-number",
         "Depth must be a valid number",
         (value) => value !== void 0 && value !== "" && !Number.isNaN(Number(value))
@@ -555,7 +581,7 @@ var vendorInfoSchema = yup3.object().shape({
         "Depth must be greater than 0",
         (value) => value !== void 0 && value !== "" && Number(value) > 0
       ),
-      width: yup3.string().required("Width is required").test(
+      width: yup4.string().required("Width is required").test(
         "is-number",
         "Width must be a valid number",
         (value) => value !== void 0 && value !== "" && !Number.isNaN(Number(value))
@@ -566,79 +592,79 @@ var vendorInfoSchema = yup3.object().shape({
       )
     })
   }),
-  vendorId: yup3.string().trim().required("Vendor ID is required")
+  vendorId: yup4.string().trim().required("Vendor ID is required")
 });
 
 // src/yupSchema/user.ts
-import * as yup4 from "yup";
-var userSchema = yup4.object().shape({
-  active: yup4.boolean().required("Active is required"),
+import * as yup5 from "yup";
+var userSchema = yup5.object().shape({
+  active: yup5.boolean().required("Active is required"),
   email: emailRequiredSchema,
-  firstName: yup4.string().label("First Name").trim().required("First name is required"),
-  lastName: yup4.string().label("Last Name").trim().required("Last name is required"),
-  nickName: yup4.string().nullable().label("Nickname").trim().notRequired(),
-  isTester: yup4.boolean().required("Tester status is required"),
-  password: yup4.string().nullable().trim().label("Password").min(8, "Password must be at least 8 characters long").notRequired(),
-  preferredRegion: yup4.string().label("Preferred Region").required("Preferred region is required"),
-  confirmPassword: yup4.string().nullable().trim().label("Confirm Password").when("password", {
+  firstName: yup5.string().label("First Name").trim().required("First name is required"),
+  lastName: yup5.string().label("Last Name").trim().required("Last name is required"),
+  nickName: yup5.string().nullable().label("Nickname").trim().notRequired(),
+  isTester: yup5.boolean().required("Tester status is required"),
+  password: yup5.string().nullable().trim().label("Password").min(8, "Password must be at least 8 characters long").notRequired(),
+  preferredRegion: yup5.string().label("Preferred Region").required("Preferred region is required"),
+  confirmPassword: yup5.string().nullable().trim().label("Confirm Password").when("password", {
     is: (val) => !!val,
     // only necessary if password typed
-    then: (schema) => schema.required("Confirm Password is required").oneOf([yup4.ref("password")], "Passwords must match"),
+    then: (schema) => schema.required("Confirm Password is required").oneOf([yup5.ref("password")], "Passwords must match"),
     otherwise: (schema) => schema.notRequired()
   })
 });
 
 // src/yupSchema/auth.ts
-import * as yup5 from "yup";
-var loginSchema = yup5.object().shape({
+import * as yup6 from "yup";
+var loginSchema = yup6.object().shape({
   email: emailRequiredSchema,
   password: passwordSchema
 });
-var registerSchema = yup5.object().shape({
+var registerSchema = yup6.object().shape({
   email: emailRequiredSchema,
-  firstName: yup5.string().label("First Name").required("First Name is required"),
-  interests: yup5.array().of(
-    yup5.mixed().oneOf(
+  firstName: yup6.string().label("First Name").required("First Name is required"),
+  interests: yup6.array().of(
+    yup6.mixed().oneOf(
       Object.values(EnumResourceType),
       "Please select a valid interest"
     ).defined()
   ).label("Who will you be on ClueMart?").min(1, "Select at least one interest").required("Interests are required"),
-  lastName: yup5.string().label("Last Name").required("Last Name is required"),
-  nickName: yup5.string().nullable().label("Nickname").trim().notRequired(),
+  lastName: yup6.string().label("Last Name").required("Last Name is required"),
+  nickName: yup6.string().nullable().label("Nickname").trim().notRequired(),
   password: passwordSchema,
-  preferredRegion: yup5.string().label("Preferred Region").required("Preferred Region is required")
+  preferredRegion: yup6.string().label("Preferred Region").required("Preferred Region is required")
 });
-var requestPasswordResetSchema = yup5.object().shape({
+var requestPasswordResetSchema = yup6.object().shape({
   email: emailRequiredSchema
 });
-var resetPasswordSchema = yup5.object().shape({
+var resetPasswordSchema = yup6.object().shape({
   email: emailRequiredSchema,
   password: passwordSchema,
   // eslint-disable-next-line sort-keys
-  confirmPassword: yup5.string().oneOf([yup5.ref("password")], "Passwords must match").required("Confirm Password is required")
+  confirmPassword: yup6.string().oneOf([yup6.ref("password")], "Passwords must match").required("Confirm Password is required")
 });
-var validateVerificationTokenSchema = yup5.object().shape({
+var validateVerificationTokenSchema = yup6.object().shape({
   email: emailRequiredSchema,
-  verificationToken: yup5.string().required("Verification code is required").matches(/^\d{6}$/, "Verification code must be exactly 6 digits")
+  verificationToken: yup6.string().required("Verification code is required").matches(/^\d{6}$/, "Verification code must be exactly 6 digits")
 });
 
 // src/yupSchema/ad.ts
-import * as yup6 from "yup";
-var adResourceSchema = yup6.object({
-  adDescription: yup6.string().trim().required("Ad description is required").max(150, "Ad description must be at most 150 characters"),
-  adImage: yup6.string().required("Ad image is required"),
-  adStyle: yup6.mixed().oneOf(Object.values(EnumAdStyle), "Please select a valid ad style").required("Ad style is required"),
-  adTitle: yup6.string().trim().required("Ad title is required").max(30, "Ad title must be at most 30 characters"),
-  adType: yup6.mixed().oneOf(Object.values(EnumAdType), "Please select a valid ad type").required("Ad type is required"),
-  resourceId: yup6.string().required("Resource ID is required"),
-  resourceName: yup6.string().required("Resource name is required"),
-  resourceRegion: yup6.string().required("Resource region is required"),
-  resourceType: yup6.mixed().oneOf(Object.values(EnumResourceType), "Please select Event or Vendor").required("Resource type is required"),
-  resourceSlug: yup6.string().required("Resource slug is required")
+import * as yup7 from "yup";
+var adResourceSchema = yup7.object({
+  adDescription: yup7.string().trim().required("Ad description is required").max(150, "Ad description must be at most 150 characters"),
+  adImage: yup7.string().required("Ad image is required"),
+  adStyle: yup7.mixed().oneOf(Object.values(EnumAdStyle), "Please select a valid ad style").required("Ad style is required"),
+  adTitle: yup7.string().trim().required("Ad title is required").max(30, "Ad title must be at most 30 characters"),
+  adType: yup7.mixed().oneOf(Object.values(EnumAdType), "Please select a valid ad type").required("Ad type is required"),
+  resourceId: yup7.string().required("Resource ID is required"),
+  resourceName: yup7.string().required("Resource name is required"),
+  resourceRegion: yup7.string().required("Resource region is required"),
+  resourceType: yup7.mixed().oneOf(Object.values(EnumResourceType), "Please select Event or Vendor").required("Resource type is required"),
+  resourceSlug: yup7.string().required("Resource slug is required")
 });
-var adSchema = yup6.object().shape({
-  active: yup6.boolean().required("Active status is required"),
-  end: yup6.date().required("End date is required").test("is-future-date", "End date must be in the future", (value) => {
+var adSchema = yup7.object().shape({
+  active: yup7.boolean().required("Active status is required"),
+  end: yup7.date().required("End date is required").test("is-future-date", "End date must be in the future", (value) => {
     if (!value) return false;
     const endDate = new Date(value);
     const now = /* @__PURE__ */ new Date();
@@ -656,93 +682,93 @@ var adSchema = yup6.object().shape({
     )
   }),
   resource: adResourceSchema.required("Resource information is required"),
-  showOn: yup6.array().of(yup6.mixed().oneOf(Object.values(EnumAdShowOn)).required()).min(1, "At least one display location is required").required("Display location is required"),
-  status: yup6.mixed().oneOf(Object.values(EnumAdStatus)).required("Ad status is required"),
-  start: yup6.date().when("status", {
+  showOn: yup7.array().of(yup7.mixed().oneOf(Object.values(EnumAdShowOn)).required()).min(1, "At least one display location is required").required("Display location is required"),
+  status: yup7.mixed().oneOf(Object.values(EnumAdStatus)).required("Ad status is required"),
+  start: yup7.date().when("status", {
     is: (status) => status !== "Active" /* ACTIVE */,
-    then: () => yup6.date().required("Start date is required").test("is-future-date", "Start date must be in the future", (value) => {
+    then: () => yup7.date().required("Start date is required").test("is-future-date", "Start date must be in the future", (value) => {
       if (!value) return false;
       return value > /* @__PURE__ */ new Date();
     }),
     // Keep `start` optional (not null) when ACTIVE to match TS type `start?: Date`.
-    otherwise: () => yup6.date().notRequired()
+    otherwise: () => yup7.date().notRequired()
   }),
-  targetRegion: yup6.array().of(yup6.string().required()).min(1, "At least one target region is required").required("Target region is required")
+  targetRegion: yup7.array().of(yup7.string().required()).min(1, "At least one target region is required").required("Target region is required")
 });
 
 // src/yupSchema/partner.ts
-import * as yup7 from "yup";
+import * as yup8 from "yup";
 var partnerSchema = globalResourceSchema.shape({
   location: locationSchema,
-  nzbn: yup7.string().required("NZBN is required").matches(nzbnRegex, "NZBN must be 13 digits and start with 94"),
-  partnerType: yup7.mixed().oneOf(Object.values(EnumPartnerType), "Please select a valid Partner type").required("Please select a Partner type")
+  nzbn: yup8.string().required("NZBN is required").matches(nzbnRegex, "NZBN must be 13 digits and start with 94"),
+  partnerType: yup8.mixed().oneOf(Object.values(EnumPartnerType), "Please select a valid Partner type").required("Please select a Partner type")
 });
 
 // src/yupSchema/post.ts
-import * as yup8 from "yup";
-var postContentSchema = yup8.object().shape({
-  contentData: yup8.mixed().optional().nullable(),
-  contentOrder: yup8.number().nullable(),
-  contentType: yup8.mixed().oneOf(Object.values(EnumPostContentType)).nullable()
+import * as yup9 from "yup";
+var postContentSchema = yup9.object().shape({
+  contentData: yup9.mixed().optional().nullable(),
+  contentOrder: yup9.number().nullable(),
+  contentType: yup9.mixed().oneOf(Object.values(EnumPostContentType)).nullable()
 });
-var postSchema = yup8.object().shape({
-  active: yup8.boolean().required(),
-  caption: yup8.string().required(),
-  content: yup8.array().of(postContentSchema).required(),
-  postType: yup8.mixed().oneOf(Object.values(EnumPostType)).required(),
-  resource: yup8.object({
-    resourceId: yup8.string().required(),
-    resourceRegion: yup8.string().required(),
-    resourceSlug: yup8.string().required(),
-    resourceType: yup8.mixed().oneOf(Object.values(EnumResourceType)).required()
+var postSchema = yup9.object().shape({
+  active: yup9.boolean().required(),
+  caption: yup9.string().required(),
+  content: yup9.array().of(postContentSchema).required(),
+  postType: yup9.mixed().oneOf(Object.values(EnumPostType)).required(),
+  resource: yup9.object({
+    resourceId: yup9.string().required(),
+    resourceRegion: yup9.string().required(),
+    resourceSlug: yup9.string().required(),
+    resourceType: yup9.mixed().oneOf(Object.values(EnumResourceType)).required()
   }).nullable().optional(),
-  tags: yup8.array().of(yup8.string().required()).nullable().optional(),
-  title: yup8.string().required()
+  tags: yup9.array().of(yup9.string().required()).nullable().optional(),
+  title: yup9.string().required()
 });
 
 // src/yupSchema/appSettings.ts
-import * as yup9 from "yup";
-var appSettingsSchema = yup9.object({
-  adSettings: yup9.object({
-    mobileDisplayEnabled: yup9.boolean().label("Mobile Ad Display").required("Mobile Ad Display is required"),
-    webDisplayEnabled: yup9.boolean().label("Web Ad Display").required("Web Ad Display is required")
+import * as yup10 from "yup";
+var appSettingsSchema = yup10.object({
+  adSettings: yup10.object({
+    mobileDisplayEnabled: yup10.boolean().label("Mobile Ad Display").required("Mobile Ad Display is required"),
+    webDisplayEnabled: yup10.boolean().label("Web Ad Display").required("Web Ad Display is required")
   }).label("Ad Settings").required("Ad Settings is required"),
-  appVersion: yup9.string().trim().label("App Version").matches(
+  appVersion: yup10.string().trim().label("App Version").matches(
     /^\d+\.\d+\.\d+$/,
     "App Version must be in the format X.Y.Z (e.g. 1.12.50)"
   ).required("App Version is required"),
-  isOfflineMode: yup9.boolean().label("Is Offline Mode").required("Is Offline Mode is required"),
-  minimumRedeemableAffiliatePoints: yup9.number().label("Minimum Redeemable Affiliate Points").min(0, "Minimum Redeemable Affiliate Points must be greater than 0").required("Minimum Redeemable Affiliate Points is required")
+  isOfflineMode: yup10.boolean().label("Is Offline Mode").required("Is Offline Mode is required"),
+  minimumRedeemableAffiliatePoints: yup10.number().label("Minimum Redeemable Affiliate Points").min(0, "Minimum Redeemable Affiliate Points must be greater than 0").required("Minimum Redeemable Affiliate Points is required")
 });
 
 // src/yupSchema/coupon.ts
-import * as yup10 from "yup";
-var couponPurchaseOptionSchema = yup10.object().shape({
-  buy: yup10.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("How many do they need to buy?").typeError("Buy must be a number").integer("Buy must be a whole number").min(1, "Buy must be at least 1").max(15, "Buy must be at most 15").required("Buy is required"),
-  get: yup10.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("How many do they get?").typeError("Get must be a number").integer("Get must be a whole number").min(1, "Get must be at least 1").required("Get is required").test("get-less-than-buy", "Get must be less than Buy", function(value) {
+import * as yup11 from "yup";
+var couponPurchaseOptionSchema = yup11.object().shape({
+  buy: yup11.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("How many do they need to buy?").typeError("Buy must be a number").integer("Buy must be a whole number").min(1, "Buy must be at least 1").max(15, "Buy must be at most 15").required("Buy is required"),
+  get: yup11.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("How many do they get?").typeError("Get must be a number").integer("Get must be a whole number").min(1, "Get must be at least 1").required("Get is required").test("get-less-than-buy", "Get must be less than Buy", function(value) {
     const { buy } = this.parent;
     if (value === void 0 || buy === void 0) return true;
     return value < buy;
   }),
-  maxRewardCount: yup10.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Max coupon count").typeError("Max coupon count must be a number").integer("Max coupon count must be a whole number").min(20, "Max coupon count must be at least 20").max(200, "Max coupon count cannot exceed 200").required("Max coupon count is required"),
-  type: yup10.mixed().oneOf(["PURCHASE" /* PURCHASE */], "Type must be PURCHASE").required("Type is required"),
-  unit: yup10.string().label("Unit").trim().required("Unit is required")
+  maxRewardCount: yup11.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Max coupon count").typeError("Max coupon count must be a number").integer("Max coupon count must be a whole number").min(20, "Max coupon count must be at least 20").max(200, "Max coupon count cannot exceed 200").required("Max coupon count is required"),
+  type: yup11.mixed().oneOf(["PURCHASE" /* PURCHASE */], "Type must be PURCHASE").required("Type is required"),
+  unit: yup11.string().label("Unit").trim().required("Unit is required")
 }).nullable().defined("Coupon option is required");
-var couponMarketVisitOptionSchema = yup10.object().shape({
-  type: yup10.mixed().oneOf(
+var couponMarketVisitOptionSchema = yup11.object().shape({
+  type: yup11.mixed().oneOf(
     ["MARKET_VISIT" /* MARKET_VISIT */],
     "Type must be MARKET_VISIT"
   ).required("Type is required"),
-  visits: yup10.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Visits").typeError("Visits must be a number").integer("Visits must be a whole number").min(1, "Visits must be at least 1").required("Visits is required")
+  visits: yup11.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Visits").typeError("Visits must be a number").integer("Visits must be a whole number").min(1, "Visits must be at least 1").required("Visits is required")
 }).nullable().defined("Coupon option is required");
-var couponMarketPassportOptionSchema = yup10.object().shape({
-  type: yup10.mixed().oneOf(
+var couponMarketPassportOptionSchema = yup11.object().shape({
+  type: yup11.mixed().oneOf(
     ["MARKET_PASSPORT" /* MARKET_PASSPORT */],
     "Type must be MARKET_PASSPORT"
   ).required("Type is required"),
-  visits: yup10.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Visits").typeError("Visits must be a number").integer("Visits must be a whole number").min(1, "Visits must be at least 1").required("Visits is required")
+  visits: yup11.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Visits").typeError("Visits must be a number").integer("Visits must be a whole number").min(1, "Visits must be at least 1").required("Visits is required")
 }).nullable().defined("Coupon option is required");
-var couponOptionSchema = yup10.lazy((value) => {
+var couponOptionSchema = yup11.lazy((value) => {
   const type = value?.type;
   if (type === "MARKET_VISIT" /* MARKET_VISIT */) {
     return couponMarketVisitOptionSchema;
@@ -752,16 +778,16 @@ var couponOptionSchema = yup10.lazy((value) => {
   }
   return couponPurchaseOptionSchema;
 });
-var couponVendorProductSchema = yup10.object().shape({
-  couponId: yup10.string().label("Coupon").trim().required("Coupon is required"),
-  productId: yup10.string().label("Product").trim().required("Product is required"),
-  vendorCouponId: yup10.string().label("Vendor Coupon").trim().nullable().optional(),
-  vendorId: yup10.string().label("Vendor").trim().required("Vendor is required")
+var couponVendorProductSchema = yup11.object().shape({
+  couponId: yup11.string().label("Coupon").trim().required("Coupon is required"),
+  productId: yup11.string().label("Product").trim().required("Product is required"),
+  vendorCouponId: yup11.string().label("Vendor Coupon").trim().nullable().optional(),
+  vendorId: yup11.string().label("Vendor").trim().required("Vendor is required")
 });
 var createCouponSchema = ({
   enforceFutureStartDate
 }) => {
-  let startDateSchema = yup10.date().label("Start Date").typeError("Start date is required").required("Start date is required");
+  let startDateSchema = yup11.date().label("Start Date").typeError("Start date is required").required("Start date is required");
   if (enforceFutureStartDate) {
     startDateSchema = startDateSchema.test(
       "is-future-date",
@@ -772,11 +798,11 @@ var createCouponSchema = ({
       }
     );
   }
-  return yup10.object().shape({
-    couponDescription: yup10.string().label("Description").trim().required("Description is required"),
+  return yup11.object().shape({
+    couponDescription: yup11.string().label("Description").trim().required("Description is required"),
     couponOption: couponOptionSchema,
-    couponVendorProducts: yup10.array().of(couponVendorProductSchema).optional(),
-    endDate: yup10.date().label("End Date").typeError("End date is required").required("End date is required").test("is-future-date", "End date must be in the future", (value) => {
+    couponVendorProducts: yup11.array().of(couponVendorProductSchema).optional(),
+    endDate: yup11.date().label("End Date").typeError("End date is required").required("End date is required").test("is-future-date", "End date must be in the future", (value) => {
       if (!value) return false;
       return new Date(value) > /* @__PURE__ */ new Date();
     }).when("startDate", {
@@ -791,8 +817,8 @@ var createCouponSchema = ({
         }
       )
     }),
-    resourceId: yup10.string().label("Resource ID").trim().required("Resource ID is required"),
-    resourceType: yup10.mixed().oneOf(
+    resourceId: yup11.string().label("Resource ID").trim().required("Resource ID is required"),
+    resourceType: yup11.mixed().oneOf(
       Object.values(EnumResourceType),
       "Resource type must be a valid EnumResourceType"
     ).required("Resource type is required"),
@@ -1643,12 +1669,12 @@ import React7 from "react";
 import { useForm as useForm12 } from "react-hook-form";
 
 // src/yupSchema/contactUs.ts
-import * as yup11 from "yup";
-var contactUsSchema = yup11.object().shape({
+import * as yup12 from "yup";
+var contactUsSchema = yup12.object().shape({
   email: emailRequiredSchema,
-  firstName: yup11.string().label("First Name").required("First name is required"),
-  lastName: yup11.string().label("Last Name").required("Last name is required"),
-  message: yup11.string().label("Message").required("Message is required")
+  firstName: yup12.string().label("First Name").required("First name is required"),
+  lastName: yup12.string().label("Last Name").required("Last name is required"),
+  message: yup12.string().label("Message").required("Message is required")
 });
 
 // src/hooks/useContactUsForm.ts
@@ -2004,15 +2030,15 @@ import { useEffect as useEffect8 } from "react";
 import { useForm as useForm17 } from "react-hook-form";
 
 // src/yupSchema/school.ts
-import * as yup12 from "yup";
-var schoolSchema = yup12.object().shape({
-  active: yup12.boolean().required("Active is required"),
+import * as yup13 from "yup";
+var schoolSchema = yup13.object().shape({
+  active: yup13.boolean().required("Active is required"),
   contactDetails: contactDetailsSchema,
   location: locationSchema,
-  name: yup12.string().trim().required("Name is required"),
-  region: yup12.string().trim().required("Region is required"),
-  socialMedia: yup12.array().of(socialMediaSchema).nullable().default(null),
-  studentCount: yup12.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Student Count").nullable().typeError("Student count must be a number").min(
+  name: yup13.string().trim().required("Name is required"),
+  region: yup13.string().trim().required("Region is required"),
+  socialMedia: yup13.array().of(socialMediaSchema).nullable().default(null),
+  studentCount: yup13.number().transform((_, originalValue) => toOptionalNumber(originalValue)).label("Student Count").nullable().typeError("Student count must be a number").min(
     SCHOOL_MIN_STUDENT_COUNT,
     `Student count must be at least ${SCHOOL_MIN_STUDENT_COUNT}`
   ).required("Student count is required").test("no-leading-zeros", "", noLeadingZeros("Student Count"))
@@ -2107,29 +2133,29 @@ import { useEffect as useEffect9 } from "react";
 import { useForm as useForm18 } from "react-hook-form";
 
 // src/yupSchema/affiliate.ts
-import * as yup13 from "yup";
-var affiliateContactDetailsSchema = yup13.object({
-  mobilePhone: yup13.string().trim().required("Mobile phone is required").test(
+import * as yup14 from "yup";
+var affiliateContactDetailsSchema = yup14.object({
+  mobilePhone: yup14.string().trim().required("Mobile phone is required").test(
     "mobile-phone",
     "Mobile must start with 02 and be 9\u201311 digits",
     (value) => mobileRegex.test(value)
   )
 });
-var bankAccountDetailsSchema = yup13.object({
-  accountHolderName: yup13.string().required("Account holder name is required"),
-  accountNumber: yup13.string().required("Account number is required for bank transfer").matches(
+var bankAccountDetailsSchema = yup14.object({
+  accountHolderName: yup14.string().required("Account holder name is required"),
+  accountNumber: yup14.string().required("Account number is required for bank transfer").matches(
     nzBankAccountRegex,
     "Account number must be in format: XX-XXXX-XXXXXXX-XX"
   ).trim()
 });
-var affiliateSchema = yup13.object().shape({
+var affiliateSchema = yup14.object().shape({
   bankAccountDetails: bankAccountDetailsSchema.required(
     "Bank account details are required"
   ),
   contactDetails: affiliateContactDetailsSchema.required(
     "Contact details are required"
   ),
-  irdNumber: yup13.string().trim().required("IRD number is required").matches(
+  irdNumber: yup14.string().trim().required("IRD number is required").matches(
     nzIrdNumberRegex,
     "IRD number must be in format: XXX-XXX-XX or XXX-XXX-XXX"
   ).test(
@@ -2138,11 +2164,11 @@ var affiliateSchema = yup13.object().shape({
     (value) => !!value && isValidIrdNumber(value)
   ),
   location: locationSchema.required("Location is required"),
-  participantType: yup13.mixed().oneOf(
+  participantType: yup14.mixed().oneOf(
     Object.values(EnumAffiliateParticipantType),
     "Please select a valid participant type"
   ).required("Participant type is required"),
-  socialMedia: yup13.array().of(socialMediaSchema).nullable().default(null)
+  socialMedia: yup14.array().of(socialMediaSchema).nullable().default(null)
 });
 
 // src/hooks/useAffiliateForm.ts