@timardex/cluemart-shared 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3155 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EnumInviteStatus: () => EnumInviteStatus,
+  EnumRegions: () => EnumRegions,
+  EnumRejectionPolicy: () => EnumRejectionPolicy,
+  EnumRelationResource: () => EnumRelationResource,
+  EnumResourceType: () => EnumResourceType,
+  EnumResourceTypeIcon: () => EnumResourceTypeIcon,
+  EnumUserLicence: () => EnumUserLicence,
+  EnumUserRole: () => EnumUserRole,
+  GOOGLE_API_KEY: () => GOOGLE_API_KEY,
+  ImageTypeEnum: () => ImageTypeEnum,
+  availableCategories: () => availableCategories,
+  availableCityOptions: () => availableCityOptions,
+  availableRegionOptions: () => availableRegionOptions,
+  availableRegionTypes: () => availableRegionTypes,
+  availableTagTypes: () => availableTagTypes,
+  capitalizeFirstLetter: () => capitalizeFirstLetter,
+  categoryColors: () => categoryColors,
+  dateFormat: () => dateFormat,
+  dateTimeSchema: () => dateTimeSchema,
+  defaultMarketFormValues: () => defaultMarketFormValues,
+  defaultRegion: () => defaultRegion,
+  defaultStallholderApplyFormValues: () => defaultStallholderApplyFormValues,
+  defaultStallholderFormValues: () => defaultStallholderFormValues,
+  emailSchema: () => emailSchema,
+  endDateAfterStartDateTest: () => endDateAfterStartDateTest,
+  endDateNotInPastTest: () => endDateNotInPastTest,
+  endTimeMustBeAfterStartTimeTest: () => endTimeMustBeAfterStartTimeTest,
+  forgotPasswordFields: () => forgotPasswordFields,
+  forgotPasswordSchema: () => forgotPasswordSchema,
+  formatDate: () => formatDate,
+  formatTimestamp: () => formatTimestamp,
+  getCurrentAndFutureDates: () => getCurrentAndFutureDates,
+  getFutureDatesAfterThreshold: () => getFutureDatesAfterThreshold,
+  globalDefaultValues: () => globalDefaultValues,
+  globalResourceSchema: () => globalResourceSchema,
+  locationSchema: () => locationSchema,
+  loginFields: () => loginFields,
+  loginSchema: () => loginSchema,
+  mapArrayToOptions: () => mapArrayToOptions,
+  marketBasicInfoFields: () => marketBasicInfoFields,
+  marketEndDateFields: () => marketEndDateFields,
+  marketSchema: () => marketSchema,
+  marketStartDateFields: () => marketStartDateFields,
+  packagingOptions: () => packagingOptions,
+  passwordSchema: () => passwordSchema,
+  paymentMethodOptions: () => paymentMethodOptions,
+  producedIngOptions: () => producedIngOptions,
+  profileFields: () => profileFields,
+  registerFields: () => registerFields,
+  registerSchema: () => registerSchema,
+  rejectionPolicyOptions: () => rejectionPolicyOptions,
+  removeTypename: () => removeTypename,
+  resetPasswordFields: () => resetPasswordFields,
+  resetPasswordSchema: () => resetPasswordSchema,
+  sortDatesByProximity: () => sortDatesByProximity,
+  stallApplicationInfo: () => stallApplicationInfo,
+  stallHolderSchema: () => stallHolderSchema,
+  stallholderApplyFormSchema: () => stallholderApplyFormSchema,
+  stallholderBasicInfoFields: () => stallholderBasicInfoFields,
+  stallholderElectricity: () => stallholderElectricity,
+  stallholderEndDateFields: () => stallholderEndDateFields,
+  stallholderFullAddress: () => stallholderFullAddress,
+  stallholderGazebo: () => stallholderGazebo,
+  stallholderLocationDescription: () => stallholderLocationDescription,
+  stallholderMultiLocation: () => stallholderMultiLocation,
+  stallholderPackaging: () => stallholderPackaging,
+  stallholderPaymentMethod: () => stallholderPaymentMethod,
+  stallholderPriceRange: () => stallholderPriceRange,
+  stallholderProducedIn: () => stallholderProducedIn,
+  stallholderStallSize: () => stallholderStallSize,
+  stallholderStartDateFields: () => stallholderStartDateFields,
+  stallholderTable: () => stallholderTable,
+  startDateNotInPastTest: () => startDateNotInPastTest,
+  startTimeCannotBeInPastTest: () => startTimeCannotBeInPastTest,
+  statusOptions: () => statusOptions,
+  tagOptions: () => tagOptions,
+  timeFormat: () => timeFormat,
+  truncateText: () => truncateText,
+  useAddUserFavouriteResource: () => useAddUserFavouriteResource,
+  useCreateMarket: () => useCreateMarket,
+  useCreateRelation: () => useCreateRelation,
+  useCreateStallholder: () => useCreateStallholder,
+  useCreateStallholderApplyForm: () => useCreateStallholderApplyForm,
+  useCreateUser: () => useCreateUser,
+  useDeleteMarket: () => useDeleteMarket,
+  useDeleteRelation: () => useDeleteRelation,
+  useDeleteStallholder: () => useDeleteStallholder,
+  useForgotPassword: () => useForgotPassword,
+  useGetMarket: () => useGetMarket,
+  useGetMarketRelations: () => useGetMarketRelations,
+  useGetMarkets: () => useGetMarkets,
+  useGetMarketsByRegion: () => useGetMarketsByRegion,
+  useGetMarketsNearMe: () => useGetMarketsNearMe,
+  useGetNotification: () => useGetNotification,
+  useGetRelation: () => useGetRelation,
+  useGetRelationByMarketAndStallholder: () => useGetRelationByMarketAndStallholder,
+  useGetResourceConnections: () => useGetResourceConnections,
+  useGetStallholder: () => useGetStallholder,
+  useGetStallholderApplyForm: () => useGetStallholderApplyForm,
+  useGetStallholderRelations: () => useGetStallholderRelations,
+  useGetStallholders: () => useGetStallholders,
+  useGetStallholdersByRegion: () => useGetStallholdersByRegion,
+  useGetUser: () => useGetUser,
+  useGetUserFavourites: () => useGetUserFavourites,
+  useGetUserMarkets: () => useGetUserMarkets,
+  useGetUserNotifications: () => useGetUserNotifications,
+  useGetUsers: () => useGetUsers,
+  useLocationSearch: () => useLocationSearch,
+  useLogin: () => useLogin,
+  useLoginForm: () => useLoginForm,
+  useMarketForm: () => useMarketForm,
+  useRegister: () => useRegister,
+  useRegisterForm: () => useRegisterForm,
+  useRemoveUserFavouriteResource: () => useRemoveUserFavouriteResource,
+  useSearchMarkets: () => useSearchMarkets,
+  useSearchStallholders: () => useSearchStallholders,
+  useStallholderApplyForm: () => useStallholderApplyForm,
+  useStallholderForm: () => useStallholderForm,
+  useUpdateMarket: () => useUpdateMarket,
+  useUpdateRelation: () => useUpdateRelation,
+  useUpdateStallholder: () => useUpdateStallholder,
+  useUpdateStallholderApplyForm: () => useUpdateStallholderApplyForm,
+  useUpdateUser: () => useUpdateUser,
+  useUserForm: () => useUserForm,
+  useVerifyEmail: () => useVerifyEmail,
+  userSchema: () => userSchema,
+  validateEmailSchema: () => validateEmailSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+
+// src/enums.ts
+var EnumInviteStatus = /* @__PURE__ */ ((EnumInviteStatus2) => {
+  EnumInviteStatus2["ACCEPTED"] = "ACCEPTED";
+  EnumInviteStatus2["COMPLETED"] = "COMPLETED";
+  EnumInviteStatus2["PENDING"] = "PENDING";
+  EnumInviteStatus2["REJECTED"] = "REJECTED";
+  EnumInviteStatus2["NO_STATUS"] = "NO_STATUS";
+  return EnumInviteStatus2;
+})(EnumInviteStatus || {});
+var EnumRejectionPolicy = /* @__PURE__ */ ((EnumRejectionPolicy2) => {
+  EnumRejectionPolicy2["SINGLE_DATE_ALLOWED"] = "single_date_allowed";
+  EnumRejectionPolicy2["MULTI_DATE_ALLOWED"] = "multi_date_allowed";
+  return EnumRejectionPolicy2;
+})(EnumRejectionPolicy || {});
+var EnumResourceType = /* @__PURE__ */ ((EnumResourceType2) => {
+  EnumResourceType2["MARKET"] = "market";
+  EnumResourceType2["STALLHOLDER"] = "stallholder";
+  return EnumResourceType2;
+})(EnumResourceType || {});
+var EnumRelationResource = /* @__PURE__ */ ((EnumRelationResource2) => {
+  EnumRelationResource2["CREATED_MARKET"] = "created_market";
+  EnumRelationResource2["CREATED_STALLHOLDER"] = "created_stallholder";
+  EnumRelationResource2["STALLHOLDER_APPLICATION_TO_MARKET"] = "stallholder_application_to_market";
+  EnumRelationResource2["MARKET_INVITE_STALLHOLDER"] = "market_invite_stallholder";
+  return EnumRelationResource2;
+})(EnumRelationResource || {});
+var EnumResourceTypeIcon = /* @__PURE__ */ ((EnumResourceTypeIcon2) => {
+  EnumResourceTypeIcon2["MARKET"] = "compass";
+  EnumResourceTypeIcon2["STALLHOLDER"] = "store";
+  return EnumResourceTypeIcon2;
+})(EnumResourceTypeIcon || {});
+var EnumRegions = /* @__PURE__ */ ((EnumRegions2) => {
+  EnumRegions2["Auckland"] = "Auckland";
+  EnumRegions2["BayOfPlenty"] = "Bay of Plenty";
+  EnumRegions2["Canterbury"] = "Canterbury";
+  EnumRegions2["Gisborne"] = "Gisborne";
+  EnumRegions2["HawkesBay"] = "Hawke's Bay";
+  EnumRegions2["ManawatuWanganui"] = "Manawatu-Wanganui";
+  EnumRegions2["Marlborough"] = "Marlborough";
+  EnumRegions2["Nelson"] = "Nelson";
+  EnumRegions2["Northland"] = "Northland";
+  EnumRegions2["Otago"] = "Otago";
+  EnumRegions2["Southland"] = "Southland";
+  EnumRegions2["Taranaki"] = "Taranaki";
+  EnumRegions2["Tasman"] = "Tasman";
+  EnumRegions2["Waikato"] = "Waikato";
+  EnumRegions2["Wellington"] = "Wellington";
+  EnumRegions2["WestCoast"] = "West Coast";
+  return EnumRegions2;
+})(EnumRegions || {});
+var ImageTypeEnum = /* @__PURE__ */ ((ImageTypeEnum2) => {
+  ImageTypeEnum2["AVATAR"] = "avatar";
+  ImageTypeEnum2["COVER"] = "cover";
+  ImageTypeEnum2["IMAGE"] = "image";
+  ImageTypeEnum2["LOGO"] = "logo";
+  return ImageTypeEnum2;
+})(ImageTypeEnum || {});
+var EnumUserLicence = /* @__PURE__ */ ((EnumUserLicence2) => {
+  EnumUserLicence2["ENTERPRISE_MARKET"] = "enterprise_market";
+  EnumUserLicence2["ENTERPRISE_STALLHOLDER"] = "enterprise_stallholder";
+  EnumUserLicence2["PRO_MARKET"] = "pro_market";
+  EnumUserLicence2["PRO_STALLHOLDER"] = "pro_stallholder";
+  EnumUserLicence2["STANDARD_MARKET"] = "standard_market";
+  EnumUserLicence2["STANDARD_STALLHOLDER"] = "standard_stallholder";
+  return EnumUserLicence2;
+})(EnumUserLicence || {});
+var EnumUserRole = /* @__PURE__ */ ((EnumUserRole2) => {
+  EnumUserRole2["ADMIN"] = "admin";
+  EnumUserRole2["CUSTOMER"] = "customer";
+  return EnumUserRole2;
+})(EnumUserRole || {});
+
+// src/utils.ts
+var dateFormat = "DD-MM-YYYY";
+var timeFormat = "HH:mm";
+(0, import_dayjs.extend)(import_customParseFormat.default);
+(0, import_dayjs.extend)(import_utc.default);
+(0, import_dayjs.extend)(import_timezone.default);
+var formatDate = (dateStr, display = "datetime", timeStr) => {
+  const dateTimeStr = timeStr ? `${dateStr} ${timeStr}` : dateStr;
+  const dateTime = timeStr ? (0, import_dayjs.default)(dateTimeStr, `${dateFormat} ${timeFormat}`) : (0, import_dayjs.default)(dateStr, dateFormat);
+  const formattedDate = dateTime.format("dddd, D MMMM, YYYY");
+  const formattedTime = dateTime.format("h:mm a");
+  switch (display) {
+    case "date":
+      return formattedDate;
+    case "time":
+      return formattedTime;
+    case "datetime":
+      return `${formattedDate} at ${formattedTime}`;
+    default:
+      return formattedDate;
+  }
+};
+var getCurrentAndFutureDates = (dates) => {
+  const today = (0, import_dayjs.default)().startOf("day");
+  return dates.filter((dateObj) => {
+    const dateTime = (0, import_dayjs.default)(dateObj.startDate, dateFormat);
+    return dateTime.isSameOrAfter(today);
+  });
+};
+var getFutureDatesAfterThreshold = (dates, minHoursFromNow) => {
+  const threshold = minHoursFromNow ? (0, import_dayjs.default)().add(minHoursFromNow, "hour") : (0, import_dayjs.default)().startOf("day");
+  return dates.filter((dateObj) => {
+    const dateTime = (0, import_dayjs.default)(
+      `${dateObj.startDate} ${dateObj.startTime}`,
+      `${dateFormat} ${timeFormat}`
+    );
+    return dateTime.isSameOrAfter(threshold);
+  });
+};
+var formatTimestamp = (timestamp) => {
+  const formattedDate = (0, import_dayjs.default)(timestamp).tz("Pacific/Auckland").format(dateFormat);
+  const formattedTime = (0, import_dayjs.default)(timestamp).tz("Pacific/Auckland").format(timeFormat);
+  return formatDate(formattedDate, "date");
+};
+var GOOGLE_API_KEY = "AIzaSyC8UkMGkrF6lIInF9yHxaVQQvlN-zqCfMc";
+var defaultRegion = {
+  latitude: -36.8624942,
+  // Default: New Zealand
+  latitudeDelta: 5,
+  longitude: 174.7450494,
+  longitudeDelta: 5
+};
+var removeTypename = (obj) => {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => removeTypename(item));
+  } else if (obj !== null && typeof obj === "object") {
+    const { __typename, ...cleanedObj } = obj;
+    return Object.keys(cleanedObj).reduce(
+      (acc, key) => {
+        acc[key] = removeTypename(cleanedObj[key]);
+        return acc;
+      },
+      {}
+    );
+  }
+  return obj;
+};
+var truncateText = (text, maxLength = 30) => {
+  return text.length > maxLength ? text.substring(0, maxLength) + "..." : text;
+};
+var mapArrayToOptions = (items) => items.map((item) => ({
+  label: item.replace(/_/g, " "),
+  value: item.replace(/\s+/g, "_").toLowerCase()
+}));
+var capitalizeFirstLetter = (str) => {
+  return str.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+};
+var statusOptions = [
+  ...Object.values(EnumInviteStatus).map((status) => ({
+    label: status,
+    value: status
+  })).sort((a, b) => a.label.localeCompare(b.label))
+  // Sort the options alphabetically
+];
+function sortDatesByProximity(dates) {
+  if (!dates || !dates.length) {
+    return [];
+  }
+  const reference = (0, import_dayjs.default)();
+  return [...dates].sort((a, b) => {
+    const dateA = (0, import_dayjs.default)(a.startDate, dateFormat);
+    const dateB = (0, import_dayjs.default)(b.startDate, dateFormat);
+    const diffA = Math.abs(dateA.diff(reference));
+    const diffB = Math.abs(dateB.diff(reference));
+    return diffA - diffB;
+  });
+}
+
+// src/hooks/useLocationSearch.ts
+var handleApiError = (error, message) => {
+  console.error(message, error);
+};
+var useLocationSearch = () => {
+  const getPredictions = async (text) => {
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${text}&components=country:nz&key=${GOOGLE_API_KEY}`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.predictions;
+    } catch (error) {
+      console.error("Error fetching predictions:", error);
+      handleApiError(error, "Failed to fetch address predictions.");
+    }
+  };
+  const getPlaceDetails = async (placeId) => {
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/place/details/json?place_id=${placeId}&key=${GOOGLE_API_KEY}`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      const { result } = data;
+      const { lat, lng } = result.geometry.location;
+      const { address_components, formatted_address } = result;
+      const address = address_components.reduce((acc, item) => {
+        if (item.types.includes("street_number")) {
+          return { ...acc, streetNumber: item.long_name };
+        }
+        if (item.types.includes("route")) {
+          return { ...acc, streetName: item.long_name };
+        }
+        if (item.types.includes("locality")) {
+          return { ...acc, city: item.long_name };
+        }
+        if (item.types.includes("administrative_area_level_1")) {
+          return { ...acc, region: item.long_name };
+        }
+        if (item.types.includes("country")) {
+          return { ...acc, country: item.long_name };
+        }
+        return acc;
+      }, {});
+      const newLocation = {
+        city: address.city.toLowerCase(),
+        coordinates: [lng, lat],
+        // [longitude, latitude]
+        country: address.country,
+        fullAddress: formatted_address,
+        latitude: lat,
+        longitude: lng,
+        region: address.region.replace(/ Region$/, ""),
+        // Remove " Region" suffix
+        type: "Point"
+        // Mongoose GeoJSON type
+      };
+      return newLocation;
+    } catch (error) {
+      handleApiError(error, "Failed to fetch place details.");
+    }
+  };
+  return {
+    getPlaceDetails,
+    getPredictions
+  };
+};
+
+// src/hooks/stallholder/useStallholderForm.ts
+var import_yup = require("@hookform/resolvers/yup");
+var React = __toESM(require("react"));
+var import_react_hook_form = require("react-hook-form");
+
+// src/yupSchema/global.ts
+var import_dayjs2 = __toESM(require("dayjs"));
+var import_customParseFormat2 = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var yup = __toESM(require("yup"));
+(0, import_dayjs2.extend)(import_isSameOrAfter.default);
+(0, import_dayjs2.extend)(import_customParseFormat2.default);
+var now = (0, import_dayjs2.default)();
+var endDateNotInPastTest = yup.string().test("not-in-past", "End date cannot be in the past", (value) => {
+  return value ? (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+});
+var startDateNotInPastTest = yup.string().test("not-in-past", "Start date cannot be in the past", (value) => {
+  return value ? (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+});
+var endDateAfterStartDateTest = yup.string().test(
+  "end-after-start",
+  "End date cannot be before start date",
+  function(value) {
+    const { startDate } = this.parent;
+    if (!startDate || !value) return false;
+    return (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(
+      (0, import_dayjs2.default)(startDate, dateFormat, true),
+      "day"
+    );
+  }
+);
+var endTimeMustBeAfterStartTimeTest = yup.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;
+    const startDateTime = (0, import_dayjs2.default)(
+      `${startDate} ${startTime}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    const endDateTime = (0, import_dayjs2.default)(
+      `${endDate} ${value}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    return endDateTime.isAfter(startDateTime);
+  }
+);
+var startTimeCannotBeInPastTest = yup.string().test(
+  "valid-start-time",
+  "Start time cannot be in the past",
+  function(value) {
+    const { startDate } = this.parent;
+    if (!startDate || !value) return false;
+    const startDateTime = (0, import_dayjs2.default)(
+      `${startDate} ${value}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    return startDateTime.isSameOrAfter(now);
+  }
+);
+var dateTimeSchema = yup.object().shape({
+  endDate: yup.string().concat(endDateNotInPastTest).concat(endDateAfterStartDateTest).required("End date is required"),
+  endTime: yup.string().concat(endTimeMustBeAfterStartTimeTest).required("End time is required"),
+  startDate: yup.string().concat(startDateNotInPastTest).required("Start date is required"),
+  startTime: yup.string().concat(startTimeCannotBeInPastTest).required("Start time is required")
+});
+var locationSchema = yup.object().shape({
+  city: yup.string().required("City is required"),
+  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"),
+  country: yup.string().required("Country is required"),
+  fullAddress: yup.string().required("Address is required"),
+  latitude: yup.number().required("Latitude is required"),
+  longitude: yup.number().required("Longitude is required"),
+  region: yup.string().required("Region is required"),
+  type: yup.string().oneOf(["Point"], "Type must be 'Point'").default("Point").required("Type is required")
+});
+var emailSchema = yup.string().email("Invalid email address").required("Email is required").transform(
+  (value) => typeof value === "string" ? value.toLowerCase() : value
+);
+var passwordSchema = yup.string().trim().min(8, "Password must be at least 8 characters long").required("Password is required");
+var globalResourceSchema = yup.object().shape({
+  active: yup.boolean().required("Active is required"),
+  cover: yup.object({
+    source: yup.string().required("Cover is required"),
+    title: yup.string().required("Cover is required")
+  }),
+  description: yup.string().trim().min(3).required("Description is required"),
+  name: yup.string().trim().min(3).required("Name is required"),
+  region: yup.string().required("Region is required")
+});
+
+// src/yupSchema/market.ts
+var yup2 = __toESM(require("yup"));
+var marketSchema = globalResourceSchema.shape({
+  dateTime: yup2.array().of(dateTimeSchema).required("DateTime is required"),
+  location: locationSchema,
+  provider: yup2.string().trim().min(3).required("Provider is required"),
+  stallApplicationInfo: yup2.object().shape({
+    applicationDeadlineHours: yup2.number().min(1).required("Application deadline hours is required"),
+    rejectionPolicy: yup2.mixed().oneOf(Object.values(EnumRejectionPolicy)).required("Rejection policy is required"),
+    stallCapacity: yup2.number().min(1).required("Stall capacity is required")
+  }),
+  tags: yup2.array().of(yup2.string().defined()).nullable()
+});
+
+// src/yupSchema/stallholder.ts
+var yup3 = __toESM(require("yup"));
+var stallHolderSchema = globalResourceSchema.shape({
+  categories: yup3.array().of(
+    yup3.object().shape({
+      id: yup3.string().required("Category id is required"),
+      name: yup3.string().required("Category name is required"),
+      subcategories: yup3.array().of(
+        yup3.object().shape({
+          id: yup3.string().defined(),
+          items: yup3.array().of(yup3.string().defined()).nullable(),
+          name: yup3.string().defined()
+        })
+      ).nullable()
+    })
+  ).min(1, "Category list must contain at least one item").required("Categories are required"),
+  multiLocation: yup3.boolean().required("Multi location is required"),
+  products: yup3.array().of(yup3.string().defined()).min(1, "Product list must contain at least one item").required("Products are required")
+});
+var stallholderApplyFormSchema = yup3.object().shape({
+  active: yup3.boolean().required("Active is required"),
+  electricity: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Electricity requirement is required")
+  }),
+  foodSafetyGradeFiles: yup3.array().of(yup3.string().defined()).nullable(),
+  foodSafetyGradeFilesUpload: yup3.array().of(yup3.string().defined()).nullable(),
+  gazebo: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Gazebo requirement is required")
+  }),
+  packaging: yup3.array().of(yup3.string().defined()).min(1, "Packaging list must contain at least one item").required("Packaging is required"),
+  paymentMethod: yup3.string().required("Please select a Payment method"),
+  priceRange: yup3.object().shape({
+    max: yup3.number().min(1).required("Max price is required").test(
+      "is-greater",
+      "Max price must be greater than or equal to Min price",
+      function(max) {
+        const { min } = this.parent;
+        return max >= min;
+      }
+    ),
+    min: yup3.number().min(1).required("Min price is required")
+  }),
+  producedIn: yup3.array().of(yup3.string().defined()).min(1, "Produced in list must contain at least one item").required("Produced in is required"),
+  stallSize: yup3.object().shape({
+    depth: yup3.number().min(1).required("Depth is required"),
+    width: yup3.number().min(1).required("Width is required")
+  }),
+  table: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Table requirement is required")
+  })
+});
+
+// src/yupSchema/user.ts
+var yup4 = __toESM(require("yup"));
+var userSchema = yup4.object().shape({
+  active: yup4.boolean().required("Active is required"),
+  email: emailSchema,
+  firstName: yup4.string().required("First name is required"),
+  lastName: yup4.string().required("Last name is required"),
+  password: passwordSchema,
+  // eslint-disable-next-line sort-keys
+  confirmPassword: yup4.string().oneOf([yup4.ref("password")], "Passwords must match").required("Confirm Password is required"),
+  role: yup4.mixed().oneOf(Object.values(EnumUserRole)).required("Role is required")
+});
+
+// src/yupSchema/auth.ts
+var yup5 = __toESM(require("yup"));
+var loginSchema = yup5.object().shape({
+  email: emailSchema,
+  password: passwordSchema
+});
+var registerSchema = yup5.object().shape({
+  email: emailSchema,
+  firstName: yup5.string().required("First Name is required"),
+  lastName: yup5.string().required("Last Name is required"),
+  password: passwordSchema,
+  role: yup5.mixed().oneOf(Object.values(EnumUserRole)).required("Role is required")
+});
+var forgotPasswordSchema = yup5.object().shape({
+  email: emailSchema
+});
+var resetPasswordSchema = yup5.object().shape({
+  password: passwordSchema,
+  // eslint-disable-next-line sort-keys
+  confirmPassword: yup5.string().oneOf([yup5.ref("password")], "Passwords must match").required("Confirm Password is required")
+});
+var validateEmailSchema = yup5.object().shape({
+  token: yup5.string().required("Token is required")
+});
+
+// src/hooks/utils.ts
+var globalDefaultValues = {
+  active: false,
+  cover: {
+    source: "",
+    title: ""
+  },
+  coverUpload: {
+    source: "",
+    title: ""
+  },
+  description: "Lorem Ipsum is a placeholder text commonly used in design and publishing to represent the visual form of a document without relying on meaningful content. It's a jumbled Latin text, not intended to be read or understood, and is used to show the layout and typography before actual content is added.",
+  images: null,
+  imagesUpload: null,
+  logo: null,
+  logoUpload: null,
+  name: "Resource name",
+  promoCode: "",
+  region: ""
+};
+var defaultMarketFormValues = {
+  ...globalDefaultValues,
+  dateTime: [
+    {
+      endDate: "04-05-2025",
+      endTime: "15:00",
+      startDate: "04-05-2025",
+      startTime: "09:00"
+    },
+    {
+      endDate: "05-05-2025",
+      endTime: "15:00",
+      startDate: "05-05-2025",
+      startTime: "09:00"
+    }
+  ],
+  location: {
+    city: "",
+    coordinates: [0, 0],
+    // [longitude, latitude]
+    country: "",
+    fullAddress: "",
+    latitude: 0,
+    longitude: 0,
+    region: "",
+    type: "Point"
+    // Default type for GeoJSON
+  },
+  provider: "Provider name",
+  stallApplicationInfo: {
+    applicationDeadlineHours: 72,
+    rejectionPolicy: "multi_date_allowed" /* MULTI_DATE_ALLOWED */,
+    stallCapacity: 4
+  },
+  tags: null
+};
+var defaultStallholderFormValues = {
+  ...globalDefaultValues,
+  categories: [],
+  locations: null,
+  multiLocation: false,
+  products: ["Prod uct 1", "Product 2"],
+  specialities: null
+};
+var defaultStallholderApplyFormValues = {
+  active: false,
+  electricity: { details: null, isRequired: false },
+  foodSafetyGradeFiles: null,
+  foodSafetyGradeFilesUpload: null,
+  gazebo: { details: null, isRequired: false },
+  packaging: [],
+  paymentMethod: "",
+  priceRange: { max: 0, min: 0 },
+  producedIn: [],
+  stallSize: { depth: 0, width: 0 },
+  table: { details: null, isRequired: false }
+};
+
+// src/hooks/stallholder/useStallholderForm.ts
+function useStallholderForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form.useForm)({
+    defaultValues: defaultStallholderFormValues,
+    resolver: (0, import_yup.yupResolver)(stallHolderSchema)
+  });
+  React.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        categories: data.categories,
+        cover: data.cover,
+        coverUpload: data.coverUpload,
+        description: data.description,
+        images: data.images,
+        imagesUpload: data.imagesUpload,
+        locations: data.locations,
+        logo: data.logo,
+        logoUpload: data.logoUpload,
+        multiLocation: data.multiLocation,
+        name: data.name,
+        products: data.products,
+        promoCode: data.promoCode,
+        region: data.region,
+        specialities: data.specialities
+      });
+    } else {
+      reset(defaultStallholderFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    categories,
+    cover,
+    coverUpload,
+    description,
+    images,
+    imagesUpload,
+    locations,
+    logo,
+    logoUpload,
+    multiLocation,
+    name,
+    products,
+    promoCode,
+    region,
+    specialities
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      categories,
+      cover,
+      coverUpload,
+      description,
+      images,
+      imagesUpload,
+      locations,
+      logo,
+      logoUpload,
+      multiLocation,
+      name,
+      products,
+      promoCode,
+      region,
+      specialities
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/stallholder/useStallholderApplyForm.ts
+var import_yup2 = require("@hookform/resolvers/yup");
+var React2 = __toESM(require("react"));
+var import_react_hook_form2 = require("react-hook-form");
+function useStallholderApplyForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form2.useForm)({
+    defaultValues: defaultStallholderApplyFormValues,
+    resolver: (0, import_yup2.yupResolver)(stallholderApplyFormSchema)
+  });
+  React2.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        electricity: data.electricity,
+        foodSafetyGradeFiles: data.foodSafetyGradeFiles,
+        foodSafetyGradeFilesUpload: data.foodSafetyGradeFilesUpload,
+        gazebo: data.gazebo,
+        packaging: data.packaging,
+        paymentMethod: data.paymentMethod,
+        priceRange: data.priceRange,
+        producedIn: data.producedIn,
+        stallSize: data.stallSize,
+        table: data.table
+      });
+    } else {
+      reset(defaultStallholderApplyFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    electricity,
+    foodSafetyGradeFiles,
+    foodSafetyGradeFilesUpload,
+    gazebo,
+    packaging,
+    paymentMethod,
+    priceRange,
+    producedIn,
+    stallSize,
+    table
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      electricity,
+      foodSafetyGradeFiles,
+      foodSafetyGradeFilesUpload,
+      gazebo,
+      packaging,
+      paymentMethod,
+      priceRange,
+      producedIn,
+      stallSize,
+      table
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/useMarketForm.ts
+var import_yup3 = require("@hookform/resolvers/yup");
+var React3 = __toESM(require("react"));
+var import_react_hook_form3 = require("react-hook-form");
+function useMarketForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form3.useForm)({
+    defaultValues: defaultMarketFormValues,
+    resolver: (0, import_yup3.yupResolver)(marketSchema)
+  });
+  React3.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        cover: data.cover,
+        coverUpload: data.coverUpload,
+        dateTime: data.dateTime,
+        description: data.description,
+        images: data.images,
+        imagesUpload: data.imagesUpload,
+        location: data.location,
+        logo: data.logo,
+        logoUpload: data.logoUpload,
+        name: data.name,
+        promoCode: data.promoCode,
+        provider: data.provider,
+        region: data.region,
+        stallApplicationInfo: data.stallApplicationInfo,
+        tags: data.tags
+      });
+    } else {
+      reset(defaultMarketFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    cover,
+    coverUpload,
+    dateTime,
+    description,
+    images,
+    imagesUpload,
+    location,
+    logo,
+    logoUpload,
+    name,
+    provider,
+    region,
+    stallApplicationInfo: stallApplicationInfo2,
+    tags
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      cover,
+      coverUpload,
+      dateTime,
+      description,
+      images,
+      imagesUpload,
+      location,
+      logo,
+      logoUpload,
+      name,
+      provider,
+      region,
+      stallApplicationInfo: stallApplicationInfo2,
+      tags
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/useUserForm.ts
+var import_yup4 = require("@hookform/resolvers/yup");
+var React4 = __toESM(require("react"));
+var import_react_hook_form4 = require("react-hook-form");
+var defaultValues = {
+  active: false,
+  avatar: null,
+  avatarUpload: null,
+  confirmPassword: "",
+  email: "",
+  firstName: "",
+  lastName: "",
+  password: "",
+  role: "customer" /* CUSTOMER */
+};
+function useUserForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form4.useForm)({
+    defaultValues,
+    resolver: (0, import_yup4.yupResolver)(userSchema)
+  });
+  React4.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        avatar: data.avatar,
+        avatarUpload: data.avatarUpload,
+        confirmPassword: data.confirmPassword,
+        email: data.email,
+        firstName: data.firstName,
+        lastName: data.lastName,
+        password: data.password,
+        role: data.role
+      });
+    } else {
+      reset(defaultValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    avatar,
+    avatarUpload,
+    confirmPassword,
+    email,
+    firstName,
+    lastName,
+    password,
+    role
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      avatar,
+      avatarUpload,
+      confirmPassword,
+      email,
+      firstName,
+      lastName,
+      password,
+      role
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useLoginForm.ts
+var import_yup5 = require("@hookform/resolvers/yup");
+var import_react_hook_form5 = require("react-hook-form");
+var defaultValues2 = {
+  email: "",
+  password: ""
+};
+function useLoginForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form5.useForm)({
+    defaultValues: defaultValues2,
+    resolver: (0, import_yup5.yupResolver)(loginSchema)
+  });
+  const { email, password } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      password
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useRegisterForm.ts
+var import_yup6 = require("@hookform/resolvers/yup");
+var import_react_hook_form6 = require("react-hook-form");
+var defaultValues3 = {
+  email: "timardex@gmail.com",
+  firstName: "Csaba",
+  lastName: "Timar",
+  password: "qwertyui",
+  role: "admin" /* ADMIN */
+};
+function useRegisterForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form6.useForm)({
+    defaultValues: defaultValues3,
+    resolver: (0, import_yup6.yupResolver)(registerSchema)
+  });
+  const { email, firstName, lastName, password, role } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      firstName,
+      lastName,
+      password,
+      role
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/graphql/hooks/auth.ts
+var import_client3 = require("@apollo/client");
+
+// src/graphql/mutations/auth.ts
+var import_client2 = require("@apollo/client");
+
+// src/graphql/queries/global.ts
+var import_client = require("@apollo/client");
+var RESOURCE_IMAGE_FIELDS_FRAGMENT = import_client.gql`
+  fragment ResourceImageFields on ResourceImageType {
+    source
+    title
+  }
+`;
+var OWNER_FIELDS_FRAGMENT = import_client.gql`
+  fragment OwnerFields on OwnerType {
+    _id
+    email
+    licences
+  }
+`;
+var CATEGORY_FIELDS_FRAGMENT = import_client.gql`
+  fragment CategoryFields on CategoryType {
+    id
+    name
+    subcategories {
+      id
+      items
+      name
+    }
+  }
+`;
+var USER_FIELDS_FRAGMENT = import_client.gql`
+  fragment UserFields on UserType {
+    _id
+    active
+    avatar {
+      ...ResourceImageFields
+    }
+    createdAt
+    email
+    favourites {
+      markets
+      stallholders
+    }
+    firstName
+    lastName
+    licences
+    markets
+    role
+    stallholder
+    updatedAt
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/auth.ts
+var LOGIN_MUTATION = import_client2.gql`
+  mutation login($input: LoginInputType!) {
+    login(input: $input) {
+      message
+      token
+      user {
+        ...UserFields
+      }
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REGISTER_MUTATION = import_client2.gql`
+  mutation register($input: RegisterInputType!) {
+    register(input: $input) {
+      message
+      token
+      user {
+        ...UserFields
+      }
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var RESET_PASSWORD_MUTATION = import_client2.gql`
+  mutation resetPassword($input: ResetPasswordInputType!) {
+    resetPassword(input: $input) {
+      message
+    }
+  }
+`;
+var FORGOT_PASSWORD_MUTATION = import_client2.gql`
+  mutation forgotPassword($input: ForgotPasswordInputType!) {
+    forgotPassword(input: $input) {
+      message
+    }
+  }
+`;
+var VERYFY_EMAIL_MUTATION = import_client2.gql`
+  mutation verifyEmail($input: VerifyEmailInputType!) {
+    verifyEmail(input: $input) {
+      message
+    }
+  }
+`;
+
+// src/graphql/hooks/auth.ts
+var useLogin = () => {
+  const [login, { loading, error }] = (0, import_client3.useMutation)(LOGIN_MUTATION);
+  return { error, loading, login };
+};
+var useRegister = () => {
+  const [register, { loading, error }] = (0, import_client3.useMutation)(REGISTER_MUTATION);
+  return { error, loading, register };
+};
+var useForgotPassword = () => {
+  const [forgotPassword, { loading, error }] = (0, import_client3.useMutation)(
+    FORGOT_PASSWORD_MUTATION
+  );
+  return { error, forgotPassword, loading };
+};
+var useVerifyEmail = () => {
+  const [verifyEmail, { loading, error }] = (0, import_client3.useMutation)(VERYFY_EMAIL_MUTATION);
+  return { error, loading, verifyEmail };
+};
+
+// src/graphql/hooks/market/hooksMutation.ts
+var import_client8 = require("@apollo/client");
+
+// src/graphql/mutations/market.ts
+var import_client5 = require("@apollo/client");
+
+// src/graphql/queries/market.ts
+var import_client4 = require("@apollo/client");
+var MARKET_DATETIME_FIELDS_FRAGMENT = import_client4.gql`
+  fragment MarketDateTimeFields on MarketDateTimeType {
+    endDate
+    endTime
+    startDate
+    startTime
+  }
+`;
+var MARKET_LOCATION_FIELDS_FRAGMENT = import_client4.gql`
+  fragment MarketLocationFields on MarketLocationType {
+    city
+    coordinates
+    country
+    fullAddress
+    latitude
+    longitude
+    region
+    type
+  }
+`;
+var MARKET = import_client4.gql`
+  fragment MarketFields on MarketType {
+    _id
+    active
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    dateTime {
+      ...MarketDateTimeFields
+    }
+    description
+    images {
+      ...ResourceImageFields
+    }
+    location {
+      ...MarketLocationFields
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    name
+    owner {
+      ...OwnerFields
+    }
+    promoCode
+    provider
+    region
+    relationIds
+    stallApplicationInfo {
+      applicationDeadlineHours
+      rejectionPolicy
+      stallCapacity
+    }
+    tags
+    updatedAt
+  }
+  ${MARKET_DATETIME_FIELDS_FRAGMENT}
+  ${MARKET_LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+var GET_MARKETS = import_client4.gql`
+  query getMarkets {
+    markets {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var GET_MARKET = import_client4.gql`
+  query getMarket($_id: ID!) {
+    market(_id: $_id) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var GET_MARKETS_BY_REGION = import_client4.gql`
+  query getMarketsByRegion($region: String!) {
+    marketsByRegion(region: $region) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var SEARCH_MARKETS = import_client4.gql`
+  query searchMarkets($search: String!, $region: String) {
+    marketSearch(search: $search, region: $region) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var GET_MARKETS_NEAR_ME = import_client4.gql`
+  query getMarketsNearMe($latitude: Float!, $longitude: Float!, $radius: Int) {
+    marketsNearMe(latitude: $latitude, longitude: $longitude, radius: $radius) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+
+// src/graphql/mutations/market.ts
+var CREATE_MARKET_MUTATION = import_client5.gql`
+  mutation createMarket($input: MarketInputType!) {
+    createMarket(input: $input) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var UPDATE_MARKET_MUTATION = import_client5.gql`
+  mutation updateMarket($_id: ID!, $input: MarketInputType!) {
+    updateMarket(_id: $_id, input: $input) {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var DELETE_MARKET_MUTATION = import_client5.gql`
+  mutation deleteMarket($_id: ID!) {
+    deleteMarket(_id: $_id)
+  }
+`;
+
+// src/graphql/queries/user.ts
+var import_client7 = require("@apollo/client");
+
+// src/graphql/queries/stallholder.ts
+var import_client6 = require("@apollo/client");
+var STALLHOLDER_LOCATION_FIELDS_FRAGMENT = import_client6.gql`
+  fragment StallholderLocationFields on StallholderLocationType {
+    city
+    coordinates
+    country
+    fullAddress
+    latitude
+    longitude
+    region
+    type
+  }
+`;
+var STALLHOLDER_DATETIME_FIELDS_FRAGMENT = import_client6.gql`
+  fragment StallholderDateTimeFields on StallholderDateTimeType {
+    endDate
+    endTime
+    startDate
+    startTime
+  }
+`;
+var STALLHOLDER = import_client6.gql`
+  fragment StallholderFields on StallholderType {
+    _id
+    active
+    applyFormId
+    categories {
+      ...CategoryFields
+    }
+    cover {
+      ...ResourceImageFields
+    }
+    createdAt
+    description
+    images {
+      ...ResourceImageFields
+    }
+    locations {
+      dateTime {
+        ...StallholderDateTimeFields
+      }
+      description
+      location {
+        ...StallholderLocationFields
+      }
+    }
+    logo {
+      ...ResourceImageFields
+    }
+    multiLocation
+    name
+    owner {
+      ...OwnerFields
+    }
+    products
+    promoCode
+    region
+    relationIds
+    specialities
+    updatedAt
+  }
+  ${CATEGORY_FIELDS_FRAGMENT}
+  ${STALLHOLDER_DATETIME_FIELDS_FRAGMENT}
+  ${STALLHOLDER_LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+var STALLHOLDER_APPLY_FORM = import_client6.gql`
+  fragment StallholderApplyFormFields on StallholderApplyFormType {
+    _id
+    active
+    electricity {
+      details
+      isRequired
+    }
+    foodSafetyGradeFiles
+    gazebo {
+      details
+      isRequired
+    }
+    packaging
+    paymentMethod
+    priceRange {
+      max
+      min
+    }
+    producedIn
+    stallholderId
+    stallSize {
+      depth
+      width
+    }
+    table {
+      details
+      isRequired
+    }
+  }
+`;
+var GET_STALLHOLDERS = import_client6.gql`
+  query getStallHolders {
+    stallholders {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var GET_STALLHOLDER = import_client6.gql`
+  query getStallHolder($_id: ID!) {
+    stallholder(_id: $_id) {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var GET_STALLHOLDERS_BY_REGION = import_client6.gql`
+  query getStallholdersByRegion($region: String!) {
+    stallholdersByRegion(region: $region) {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var SEARCH_STALLHOLDERS = import_client6.gql`
+  query searchStallholders($search: String!, $region: String) {
+    stallholderSearch(search: $search, region: $region) {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var GET_STALLHOLDER_APPLY_FORM = import_client6.gql`
+  query getStallholderApplyForm($stallholderId: ID!) {
+    stallholderApplyForm(stallholderId: $stallholderId) {
+      ...StallholderApplyFormFields
+    }
+  }
+  ${STALLHOLDER_APPLY_FORM}
+`;
+
+// src/graphql/queries/user.ts
+var GET_USERS = import_client7.gql`
+  query getUsers {
+    users {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var GET_USER = import_client7.gql`
+  query getUser($id: ID!) {
+    user(_id: $id) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var GET_USER_MARKETS = import_client7.gql`
+  query getUserMarkets {
+    userMarkets {
+      ...MarketFields
+    }
+  }
+  ${MARKET}
+`;
+var GET_USER_FAVOURITES = import_client7.gql`
+  query getUserFavourites {
+    userFavourites {
+      markets {
+        ...MarketFields
+      }
+      stallholders {
+        ...StallholderFields
+      }
+    }
+  }
+  ${MARKET}
+  ${STALLHOLDER}
+`;
+var GET_USER_NOTIFICATIONS = import_client7.gql`
+  query getMissedNotifications {
+    userNotifications
+  }
+`;
+
+// src/graphql/hooks/market/hooksMutation.ts
+var useCreateMarket = () => {
+  const [createMarket, { loading, error }] = (0, import_client8.useMutation)(
+    CREATE_MARKET_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_USER_MARKETS }, { query: GET_MARKETS }]
+    }
+  );
+  return { createMarket, error, loading };
+};
+var useUpdateMarket = () => {
+  const [updateMarket, { loading, error }] = (0, import_client8.useMutation)(
+    UPDATE_MARKET_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_USER_MARKETS }, { query: GET_MARKETS }]
+    }
+  );
+  return { error, loading, updateMarket };
+};
+var useDeleteMarket = () => {
+  const [deleteMarket, { loading, error }] = (0, import_client8.useMutation)(
+    DELETE_MARKET_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_USER_MARKETS }, { query: GET_MARKETS }]
+    }
+  );
+  return { deleteMarket, error, loading };
+};
+
+// src/graphql/hooks/market/hooksQuery.ts
+var import_client9 = require("@apollo/client");
+var useGetMarkets = () => {
+  const { loading, error, data, refetch } = (0, import_client9.useQuery)(GET_MARKETS, {
+    fetchPolicy: "network-only"
+  });
+  const markets = data?.markets;
+  return { error, loading, markets, refetch };
+};
+var useGetMarket = (_id) => {
+  const { loading, error, data, refetch } = (0, import_client9.useQuery)(GET_MARKET, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: { _id }
+  });
+  const market = data?.market;
+  return { error, loading, market, refetch };
+};
+var useGetMarketsByRegion = (region) => {
+  const { loading, error, data, refetch } = (0, import_client9.useQuery)(GET_MARKETS_BY_REGION, {
+    fetchPolicy: "network-only",
+    skip: !region,
+    variables: { region }
+  });
+  const markets = data?.marketsByRegion;
+  return { error, loading, markets, refetch };
+};
+var useSearchMarkets = (search, region) => {
+  const { loading, error, data, refetch } = (0, import_client9.useQuery)(SEARCH_MARKETS, {
+    fetchPolicy: "network-only",
+    skip: search.length < 3,
+    variables: { region, search }
+  });
+  const markets = data?.marketSearch;
+  return { error, loading, markets, refetch };
+};
+var useGetMarketsNearMe = (location) => {
+  const { loading, error, data, refetch } = (0, import_client9.useQuery)(GET_MARKETS_NEAR_ME, {
+    fetchPolicy: "network-only",
+    skip: !location.latitude || !location.longitude,
+    variables: {
+      latitude: location.latitude,
+      longitude: location.longitude,
+      radius: location.radius || 1e4
+      // Default to 10km if no radius is provided
+    }
+  });
+  const markets = data?.marketsNearMe;
+  return { error, loading, markets, refetch };
+};
+
+// src/graphql/hooks/relation/hooksMutation.ts
+var import_client12 = require("@apollo/client");
+
+// src/graphql/mutations/relation.ts
+var import_client11 = require("@apollo/client");
+
+// src/graphql/queries/relation.ts
+var import_client10 = require("@apollo/client");
+var RELATION_UPDATE_BY_FRAGMENT = import_client10.gql`
+  fragment RelationUpdateBy on RelationUpdateByType {
+    resourceId
+    resourceName
+    resourceType
+    startDate
+    toStatus
+  }
+`;
+var RELATION_LOGS_FRAGMENT = import_client10.gql`
+  fragment RelationLogs on RelationLogType {
+    createdAt
+    updatedAt
+    updatedBy {
+      ...RelationUpdateBy
+    }
+  }
+  ${RELATION_UPDATE_BY_FRAGMENT}
+`;
+var RELATION_DATES_FRAGMENT = import_client10.gql`
+  fragment RelationDates on RelationDateType {
+    lastUpdateBy
+    startDate
+    status
+  }
+`;
+var RELATION_FIELDS_FRAGMENT = import_client10.gql`
+  fragment RelationFields on RelationType {
+    _id
+    createdAt
+    lastUpdateBy
+    marketId
+    relationDates {
+      ...RelationDates
+    }
+    relationLogs {
+      ...RelationLogs
+    }
+    relationType
+    stallholderId
+    updatedAt
+  }
+  ${RELATION_DATES_FRAGMENT}
+  ${RELATION_LOGS_FRAGMENT}
+`;
+var GET_RELATION = import_client10.gql`
+  query getRelation($id: ID!) {
+    relation(_id: $id) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_RELATION_BY_MARKET_AND_STALLHOLDER = import_client10.gql`
+  query getRelationByMarketAndStallholder($marketId: ID!, $stallholderId: ID!) {
+    relationByMarketAndStallholder(
+      marketId: $marketId
+      stallholderId: $stallholderId
+    ) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_MARKET_RELATIONS = import_client10.gql`
+  query getMarketRelations($marketId: ID!) {
+    marketRelations(marketId: $marketId) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_STALLHOLDER_RELATIONS = import_client10.gql`
+  query getStallholderRelations($stallholderId: ID!) {
+    stallholderRelations(stallholderId: $stallholderId) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var GET_RESOURCE_CONNECTIONS = import_client10.gql`
+  query getResourceConnections(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+  ) {
+    resourceConnections(resourceId: $resourceId, resourceType: $resourceType) {
+      markets {
+        _id
+        active
+        cover {
+          ...ResourceImageFields
+        }
+        createdAt
+        dateTime {
+          ...MarketDateTimeFields
+        }
+        description
+        images {
+          ...ResourceImageFields
+        }
+        location {
+          ...MarketLocationFields
+        }
+        logo {
+          ...ResourceImageFields
+        }
+        name
+        owner {
+          ...OwnerFields
+        }
+        promoCode
+        provider
+        relationDates {
+          ...RelationDates
+        }
+        relationIds
+        stallApplicationInfo {
+          applicationDeadlineHours
+          rejectionPolicy
+          stallCapacity
+        }
+        tags
+        updatedAt
+      }
+      stallholders {
+        _id
+        active
+        applyFormId
+        categories {
+          ...CategoryFields
+        }
+        cover {
+          ...ResourceImageFields
+        }
+        createdAt
+        description
+        images {
+          ...ResourceImageFields
+        }
+        locations {
+          dateTime {
+            ...StallholderDateTimeFields
+          }
+          location {
+            ...StallholderLocationFields
+          }
+        }
+        logo {
+          ...ResourceImageFields
+        }
+        multiLocation
+        name
+        owner {
+          ...OwnerFields
+        }
+        products
+        promoCode
+        relationDates {
+          ...RelationDates
+        }
+        relationIds
+        specialities
+        updatedAt
+      }
+    }
+  }
+  ${MARKET_DATETIME_FIELDS_FRAGMENT}
+  ${MARKET_LOCATION_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+  ${RELATION_DATES_FRAGMENT}
+  ${CATEGORY_FIELDS_FRAGMENT}
+  ${STALLHOLDER_DATETIME_FIELDS_FRAGMENT}
+  ${STALLHOLDER_LOCATION_FIELDS_FRAGMENT}
+  ${OWNER_FIELDS_FRAGMENT}
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/mutations/relation.ts
+var CREATE_RELATION_MUTATION = import_client11.gql`
+  mutation createRelation($input: RelationInputType!) {
+    createRelation(input: $input) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var UPDATE_RELATION_MUTATION = import_client11.gql`
+  mutation updateRelation($_id: ID!, $input: RelationInputType!) {
+    updateRelation(_id: $_id, input: $input) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+var DELETE_RELATION_MUTATION = import_client11.gql`
+  mutation deleteRelation($_id: ID!) {
+    deleteRelation(_id: $_id) {
+      ...RelationFields
+    }
+  }
+  ${RELATION_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/relation/hooksMutation.ts
+var useCreateRelation = () => {
+  const [createRelation, { loading, error }] = (0, import_client12.useMutation)(
+    CREATE_RELATION_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: (mutationResult) => {
+        const marketId = mutationResult?.data?.createRelation?.marketId;
+        const stallholderId = mutationResult?.data?.createRelation?.stallholderId;
+        return [
+          {
+            query: GET_MARKET_RELATIONS,
+            variables: { marketId }
+          },
+          {
+            query: GET_MARKET,
+            variables: { _id: marketId }
+          },
+          {
+            query: GET_STALLHOLDER_RELATIONS,
+            variables: { stallholderId }
+          },
+          {
+            query: GET_STALLHOLDER,
+            variables: { _id: stallholderId }
+          },
+          {
+            query: GET_RELATION_BY_MARKET_AND_STALLHOLDER,
+            variables: { marketId, stallholderId }
+          }
+        ];
+      }
+    }
+  );
+  return { createRelation, error, loading };
+};
+var useUpdateRelation = () => {
+  const [updateRelation, { loading, error }] = (0, import_client12.useMutation)(
+    UPDATE_RELATION_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: (mutationResult) => {
+        const marketId = mutationResult?.data?.updateRelation?.marketId;
+        const stallholderId = mutationResult?.data?.updateRelation?.stallholderId;
+        return [
+          {
+            query: GET_MARKET_RELATIONS,
+            variables: { marketId }
+          },
+          {
+            query: GET_MARKET,
+            variables: { _id: marketId }
+          },
+          {
+            query: GET_STALLHOLDER_RELATIONS,
+            variables: { stallholderId }
+          },
+          {
+            query: GET_STALLHOLDER,
+            variables: { _id: stallholderId }
+          },
+          {
+            query: GET_RELATION_BY_MARKET_AND_STALLHOLDER,
+            variables: { marketId, stallholderId }
+          }
+        ];
+      }
+    }
+  );
+  return { error, loading, updateRelation };
+};
+var useDeleteRelation = () => {
+  const [deleteRelation, { loading, error }] = (0, import_client12.useMutation)(
+    DELETE_RELATION_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: (mutationResult) => {
+        const marketId = mutationResult?.data?.deleteRelation?.marketId;
+        const stallholderId = mutationResult?.data?.deleteRelation?.stallholderId;
+        return [
+          {
+            query: GET_MARKET_RELATIONS,
+            variables: { marketId }
+          },
+          {
+            query: GET_STALLHOLDER_RELATIONS,
+            variables: { stallholderId }
+          },
+          {
+            query: GET_RELATION_BY_MARKET_AND_STALLHOLDER,
+            variables: { marketId, stallholderId }
+          }
+        ];
+      }
+    }
+  );
+  return { deleteRelation, error, loading };
+};
+
+// src/graphql/hooks/relation/hooksQuery.ts
+var import_client13 = require("@apollo/client");
+var useGetRelation = (id) => {
+  const { loading, error, data, refetch } = (0, import_client13.useQuery)(GET_RELATION, {
+    fetchPolicy: "network-only",
+    skip: id === "",
+    variables: { id }
+  });
+  const relation = data?.relation;
+  return { error, loading, refetch, relation };
+};
+var useGetRelationByMarketAndStallholder = (marketId, stallholderId) => {
+  const { loading, error, data, refetch } = (0, import_client13.useQuery)(
+    GET_RELATION_BY_MARKET_AND_STALLHOLDER,
+    {
+      fetchPolicy: "no-cache",
+      skip: marketId === "" || stallholderId === "",
+      variables: { marketId, stallholderId }
+    }
+  );
+  const relationByMarketAndStallholder = data?.relationByMarketAndStallholder;
+  return { error, loading, refetch, relationByMarketAndStallholder };
+};
+var useGetMarketRelations = (marketId) => {
+  const { loading, error, data, refetch } = (0, import_client13.useQuery)(GET_MARKET_RELATIONS, {
+    fetchPolicy: "network-only",
+    skip: marketId === "",
+    variables: { marketId }
+  });
+  const marketRelations = data?.marketRelations;
+  return { error, loading, marketRelations, refetch };
+};
+var useGetStallholderRelations = (stallholderId) => {
+  const { loading, error, data, refetch } = (0, import_client13.useQuery)(
+    GET_STALLHOLDER_RELATIONS,
+    {
+      fetchPolicy: "network-only",
+      skip: stallholderId === "",
+      variables: { stallholderId }
+    }
+  );
+  const stallholderRelations = data?.stallholderRelations;
+  return { error, loading, refetch, stallholderRelations };
+};
+var useGetResourceConnections = (resourceId, resourceType) => {
+  const { loading, error, data, refetch } = (0, import_client13.useQuery)(GET_RESOURCE_CONNECTIONS, {
+    fetchPolicy: "network-only",
+    variables: { resourceId, resourceType }
+  });
+  const resourceConnections = data?.resourceConnections;
+  return { error, loading, refetch, resourceConnections };
+};
+
+// src/graphql/hooks/stallholder/hooksMutation.ts
+var import_client15 = require("@apollo/client");
+
+// src/graphql/mutations/stallholder.ts
+var import_client14 = require("@apollo/client");
+var CREATE_STALLHOLDER_MUTATION = import_client14.gql`
+  mutation createStallholder($input: StallholderInputType!) {
+    createStallholder(input: $input) {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var UPDATE_STALLHOLDER_MUTATION = import_client14.gql`
+  mutation updateStallholder($_id: ID!, $input: StallholderInputType!) {
+    updateStallholder(_id: $_id, input: $input) {
+      ...StallholderFields
+    }
+  }
+  ${STALLHOLDER}
+`;
+var DELETE_STALLHOLDER_MUTATION = import_client14.gql`
+  mutation deleteStallholder($_id: ID!) {
+    deleteStallholder(_id: $_id)
+  }
+`;
+var CREATE_STALLHOLDER_APPLY_FORM_MUTATION = import_client14.gql`
+  mutation createStallholderApplyForm($input: StallholderApplyFormInputType!) {
+    createStallholderApplyForm(input: $input) {
+      ...StallholderApplyFormFields
+    }
+  }
+  ${STALLHOLDER_APPLY_FORM}
+`;
+var UPDATE_STALLHOLDER_APPLY_FORM_MUTATION = import_client14.gql`
+  mutation updateStallholderApplyForm(
+    $_id: ID!
+    $input: StallholderApplyFormInputType!
+  ) {
+    updateStallholderApplyForm(_id: $_id, input: $input) {
+      ...StallholderApplyFormFields
+    }
+  }
+  ${STALLHOLDER_APPLY_FORM}
+`;
+
+// src/graphql/hooks/stallholder/hooksMutation.ts
+var useCreateStallholder = () => {
+  const [createStallholder, { loading, error }] = (0, import_client15.useMutation)(
+    CREATE_STALLHOLDER_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_STALLHOLDERS }]
+    }
+  );
+  return { createStallholder, error, loading };
+};
+var useUpdateStallholder = () => {
+  const [updateStallholder, { loading, error }] = (0, import_client15.useMutation)(
+    UPDATE_STALLHOLDER_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_STALLHOLDERS }]
+    }
+  );
+  return { error, loading, updateStallholder };
+};
+var useDeleteStallholder = () => {
+  const [deleteStallholder, { loading, error }] = (0, import_client15.useMutation)(
+    DELETE_STALLHOLDER_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_STALLHOLDERS }]
+    }
+  );
+  return { deleteStallholder, error, loading };
+};
+var useCreateStallholderApplyForm = () => {
+  const [createStallholderApplyForm, { loading, error }] = (0, import_client15.useMutation)(
+    CREATE_STALLHOLDER_APPLY_FORM_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: (mutationResult) => {
+        const stallholderId = mutationResult?.data?.createStallholderApplyForm?.stallholderId;
+        if (!stallholderId) return [];
+        return [
+          {
+            query: GET_STALLHOLDER_APPLY_FORM,
+            variables: { stallholderId }
+            // Pass the stallholderId for refetching
+          }
+        ];
+      }
+    }
+  );
+  return { createStallholderApplyForm, error, loading };
+};
+var useUpdateStallholderApplyForm = () => {
+  const [updateStallholderApplyForm, { loading, error }] = (0, import_client15.useMutation)(
+    UPDATE_STALLHOLDER_APPLY_FORM_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: (mutationResult) => {
+        const stallholderId = mutationResult?.data?.createStallholderApplyForm?.stallholderId;
+        if (!stallholderId) return [];
+        return [
+          {
+            query: GET_STALLHOLDER_APPLY_FORM,
+            variables: { stallholderId }
+            // Pass the stallholderId for refetching
+          }
+        ];
+      }
+    }
+  );
+  return { error, loading, updateStallholderApplyForm };
+};
+
+// src/graphql/hooks/stallholder/hooksQuery.ts
+var import_client16 = require("@apollo/client");
+var useGetStallholders = () => {
+  const { loading, error, data, refetch } = (0, import_client16.useQuery)(GET_STALLHOLDERS, {
+    fetchPolicy: "network-only"
+  });
+  const stallholders = data?.stallholders;
+  return {
+    error,
+    loading,
+    refetch,
+    stallholders
+  };
+};
+var useGetStallholder = (_id) => {
+  const { loading, error, data, refetch } = (0, import_client16.useQuery)(GET_STALLHOLDER, {
+    fetchPolicy: "network-only",
+    skip: !_id,
+    variables: { _id }
+  });
+  const stallholder = data?.stallholder;
+  return { error, loading, refetch, stallholder };
+};
+var useGetStallholdersByRegion = (region) => {
+  const { loading, error, data, refetch } = (0, import_client16.useQuery)(
+    GET_STALLHOLDERS_BY_REGION,
+    {
+      fetchPolicy: "network-only",
+      skip: !region,
+      variables: { region }
+    }
+  );
+  const stallholders = data?.stallholdersByRegion;
+  return { error, loading, refetch, stallholders };
+};
+var useSearchStallholders = (search, region) => {
+  const { loading, error, data, refetch } = (0, import_client16.useQuery)(SEARCH_STALLHOLDERS, {
+    fetchPolicy: "network-only",
+    skip: search.length < 3,
+    variables: { region, search }
+  });
+  const stallholders = data?.stallholderSearch;
+  return { error, loading, refetch, stallholders };
+};
+var useGetStallholderApplyForm = (stallholderId) => {
+  const { loading, error, data, refetch } = (0, import_client16.useQuery)(
+    GET_STALLHOLDER_APPLY_FORM,
+    {
+      variables: { stallholderId }
+    }
+  );
+  const applyForm = data?.stallholderApplyForm;
+  return {
+    applyForm,
+    error,
+    loading,
+    refetch
+  };
+};
+
+// src/graphql/hooks/subscriptions.ts
+var import_client18 = require("@apollo/client");
+
+// src/graphql/subscriptions/notification.ts
+var import_client17 = require("@apollo/client");
+var NOTIFICATION_FIELDS_FRAGMENT = import_client17.gql`
+  fragment NotificationFields on NotificationType {
+    createdBy
+    important
+    message
+    notifyUser
+    resourceId
+    resourceType
+  }
+`;
+var GET_GLOBAL_NOTIFICATION = import_client17.gql`
+  subscription {
+    getGlobalNotification {
+      ...NotificationFields
+    }
+  }
+  ${NOTIFICATION_FIELDS_FRAGMENT}
+`;
+var GET_RELATION_NOTIFICATION = import_client17.gql`
+  subscription {
+    getRelationNotification {
+      ...NotificationFields
+    }
+  }
+  ${NOTIFICATION_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/subscriptions.ts
+var useGetNotification = () => {
+  const {
+    data: global,
+    loading: loadingGlobal,
+    error: errorGlobal
+  } = (0, import_client18.useSubscription)(GET_GLOBAL_NOTIFICATION);
+  const {
+    data: relation,
+    loading: loadingImportant,
+    error: errorImportant
+  } = (0, import_client18.useSubscription)(GET_RELATION_NOTIFICATION);
+  const error = errorGlobal || errorImportant;
+  const loading = loadingGlobal || loadingImportant;
+  const notification = relation?.getRelationNotification || global?.getGlobalNotification;
+  return { error, loading, notification };
+};
+
+// src/graphql/hooks/user/hooksMutation.ts
+var import_client20 = require("@apollo/client");
+
+// src/graphql/mutations/user.ts
+var import_client19 = require("@apollo/client");
+var CREATE_USER_MUTATION = import_client19.gql`
+  mutation createUser($input: UserInputType!) {
+    createUser(input: $input) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var UPDATE_USER_MUTATION = import_client19.gql`
+  mutation updateUser($_id: ID!, $input: UserInputType!) {
+    updateUser(_id: $_id, input: $input) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var ADD_USER_FAVOURITE_RESOURCE_MUTATION = import_client19.gql`
+  mutation addUserFavouriteResource(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+    $userId: ID!
+  ) {
+    addUserFavouriteResource(
+      resourceId: $resourceId
+      resourceType: $resourceType
+      userId: $userId
+    ) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+var REMOVE_USER_FAVOURITE_RESOURCE_MUTATION = import_client19.gql`
+  mutation removeUserFavouriteResource(
+    $resourceId: ID!
+    $resourceType: ResourceTypeEnum!
+    $userId: ID!
+  ) {
+    removeUserFavouriteResource(
+      resourceId: $resourceId
+      resourceType: $resourceType
+      userId: $userId
+    ) {
+      ...UserFields
+    }
+  }
+  ${USER_FIELDS_FRAGMENT}
+`;
+
+// src/graphql/hooks/user/hooksMutation.ts
+var useCreateUser = () => {
+  const [createUser, { loading, error }] = (0, import_client20.useMutation)(CREATE_USER_MUTATION, {
+    awaitRefetchQueries: true
+  });
+  return { createUser, error, loading };
+};
+var useUpdateUser = () => {
+  const [updateUser, { loading, error }] = (0, import_client20.useMutation)(UPDATE_USER_MUTATION, {
+    awaitRefetchQueries: true
+  });
+  return { error, loading, updateUser };
+};
+var useAddUserFavouriteResource = () => {
+  const [addUserFavouriteResource, { loading, error }] = (0, import_client20.useMutation)(
+    ADD_USER_FAVOURITE_RESOURCE_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_USER_FAVOURITES }]
+    }
+  );
+  return { addUserFavouriteResource, error, loading };
+};
+var useRemoveUserFavouriteResource = () => {
+  const [removeUserFavouriteResource, { loading, error }] = (0, import_client20.useMutation)(
+    REMOVE_USER_FAVOURITE_RESOURCE_MUTATION,
+    {
+      awaitRefetchQueries: true,
+      refetchQueries: [{ query: GET_USER_FAVOURITES }]
+    }
+  );
+  return { error, loading, removeUserFavouriteResource };
+};
+
+// src/graphql/hooks/user/hooksQuery.ts
+var import_client21 = require("@apollo/client");
+var useGetUsers = () => {
+  const { loading, error, data, refetch } = (0, import_client21.useQuery)(GET_USERS, {
+    fetchPolicy: "network-only"
+  });
+  const users = data?.users;
+  return { error, loading, refetch, users };
+};
+var useGetUser = (id) => {
+  const { loading, error, data, refetch } = (0, import_client21.useQuery)(GET_USER, {
+    variables: { id }
+  });
+  const user = data?.user;
+  return { error, loading, refetch, user };
+};
+var useGetUserMarkets = () => {
+  const { loading, error, data, refetch } = (0, import_client21.useQuery)(GET_USER_MARKETS, {
+    fetchPolicy: "network-only"
+  });
+  const userMarkets = data?.userMarkets;
+  return { error, loading, refetch, userMarkets };
+};
+var useGetUserFavourites = () => {
+  const { loading, error, data, refetch } = (0, import_client21.useQuery)(GET_USER_FAVOURITES, {
+    fetchPolicy: "network-only"
+  });
+  const markets = data?.userFavourites.markets;
+  const stallholders = data?.userFavourites.stallholders;
+  const userFavourites = {
+    markets,
+    stallholders
+  };
+  return { error, loading, refetch, userFavourites };
+};
+var useGetUserNotifications = () => {
+  const { loading, error, data, refetch } = (0, import_client21.useQuery)(GET_USER_NOTIFICATIONS, {
+    fetchPolicy: "network-only"
+  });
+  const userNotifications = data?.userNotifications;
+  return { error, loading, refetch, userNotifications };
+};
+
+// src/formFields/stallholder/createEditStallholder.ts
+var stallholderBasicInfoFields = [
+  {
+    helperText: "Business Name of the Stallholder *",
+    name: "name",
+    placeholder: "Business Name"
+  },
+  {
+    helperText: "Description of the Stallholder *",
+    isTextArea: true,
+    name: "description",
+    placeholder: "Description"
+  },
+  {
+    helperText: "Enter Promo code if you have one.",
+    name: "promoCode",
+    placeholder: "Promo code"
+  }
+];
+var stallholderMultiLocation = {
+  helperText: "Usefull when you are not only selling products on Markets but also providing services at other locations.",
+  name: "multiLocation",
+  placeholder: "Enable multi location"
+};
+var stallholderFullAddress = {
+  helperText: "Enter address",
+  name: "fullAddress",
+  placeholder: "Start typing to find address"
+};
+var stallholderStartDateFields = [
+  {
+    dateMode: "date",
+    helperText: "Start Date",
+    name: "startDate",
+    placeholder: "Start Date"
+  },
+  {
+    dateMode: "time",
+    helperText: "Start Time",
+    name: "startTime",
+    placeholder: "Start Time"
+  }
+];
+var stallholderEndDateFields = [
+  {
+    dateMode: "date",
+    helperText: "End Date",
+    name: "endDate",
+    placeholder: "End Date"
+  },
+  {
+    dateMode: "time",
+    helperText: "End Time",
+    name: "endTime",
+    placeholder: "End Time"
+  }
+];
+var stallholderLocationDescription = {
+  helperText: "Description",
+  isTextArea: true,
+  name: "description",
+  placeholder: "Description"
+};
+var availableCityTypes = [
+  "Auckland",
+  "Christchurch",
+  "Hamilton",
+  "Wellington"
+];
+var availableRegionTypes = Object.values(EnumRegions);
+var availableCityOptions = mapArrayToOptions(availableCityTypes);
+var availableRegionOptions = mapArrayToOptions(availableRegionTypes);
+
+// src/formFields/stallholder/stallholderApplyForm.ts
+var stallholderElectricity = {
+  details: {
+    helperText: "Please describe details e.g. amps, voltage, etc.",
+    isTextArea: true,
+    name: "electricity.details",
+    placeholder: "Electricity requirements"
+  },
+  isRequired: {
+    name: "electricity.isRequired",
+    placeholder: "Do you require electricity?"
+  }
+};
+var stallholderGazebo = {
+  details: {
+    helperText: "Please describe details e.g. size, etc.",
+    isTextArea: true,
+    name: "gazebo.details",
+    placeholder: "Gazebo requirements"
+  },
+  isRequired: {
+    name: "gazebo.isRequired",
+    placeholder: "Do you require Gazebo?"
+  }
+};
+var stallholderTable = {
+  details: {
+    helperText: "Please describe details e.g. size, etc.",
+    isTextArea: true,
+    name: "table.details",
+    placeholder: "Table requirements"
+  },
+  isRequired: {
+    name: "table.isRequired",
+    placeholder: "Do you require Table?"
+  }
+};
+var stallholderPriceRange = {
+  max: {
+    helperText: "Product maximum price",
+    name: "priceRange.max",
+    placeholder: "Maximum price: "
+  },
+  min: {
+    helperText: "Product minimum price",
+    name: "priceRange.min",
+    placeholder: "Minimum price: "
+  }
+};
+var stallholderStallSize = {
+  depth: {
+    helperText: "Stall size in depth",
+    name: "stallSize.depth",
+    placeholder: "Stall Depth: "
+  },
+  width: {
+    helperText: "Stall size in width",
+    name: "stallSize.width",
+    placeholder: "Stall Width: "
+  }
+};
+var stallholderPackaging = {
+  helperText: "Select packaging type, you can select more than one",
+  name: "packaging",
+  placeholder: "Packaging type"
+};
+var stallholderPaymentMethod = {
+  helperText: "Select payment method",
+  name: "paymentMethod",
+  placeholder: "Payment Method type"
+};
+var stallholderProducedIn = {
+  helperText: "Select where the product is produced, you can select more than one",
+  name: "producedIn",
+  placeholder: "Produced type"
+};
+var packagingTypes = [
+  "Biodegradable",
+  "Compostable",
+  "Recyclable",
+  "Reusable",
+  "Single-use",
+  "Glass",
+  "Paper",
+  "Plastic",
+  "Wood",
+  "Other"
+];
+var producedIngTypes = [
+  "Commercial Kitchen",
+  "Home Premises",
+  "Factory",
+  "Farm",
+  "Other"
+];
+var paymentMethodTyes = ["Cash", "Eftpos", "Transfer"];
+var packagingOptions = mapArrayToOptions(packagingTypes);
+var producedIngOptions = mapArrayToOptions(producedIngTypes);
+var paymentMethodOptions = mapArrayToOptions(paymentMethodTyes);
+
+// src/formFields/market.ts
+var marketBasicInfoFields = [
+  {
+    helperText: "Name of the Market *",
+    name: "name",
+    placeholder: "Name"
+  },
+  {
+    helperText: "Name of the Provider *",
+    name: "provider",
+    placeholder: "Provider"
+  },
+  {
+    helperText: "Description of the Market *",
+    isTextArea: true,
+    name: "description",
+    placeholder: "Description"
+  },
+  {
+    helperText: "Enter Promo code if you have one.",
+    name: "promoCode",
+    placeholder: "Promo code"
+  }
+];
+var stallApplicationInfo = [
+  {
+    helperText: "Application Deadline of the Market *",
+    keyboardType: "number-pad",
+    name: "stallApplicationInfo.applicationDeadlineHours",
+    placeholder: "Application Deadline Hours"
+  },
+  {
+    helperText: "Stall Capacity of the Market *",
+    keyboardType: "number-pad",
+    name: "stallApplicationInfo.stallCapacity",
+    placeholder: "Stall Capacity"
+  }
+];
+var marketStartDateFields = [
+  {
+    dateMode: "date",
+    helperText: "Start Date of the Market *",
+    name: "startDate",
+    placeholder: "Start Date"
+  },
+  {
+    dateMode: "time",
+    helperText: "Start Time of the Market *",
+    name: "startTime",
+    placeholder: "Start Time"
+  }
+];
+var marketEndDateFields = [
+  {
+    dateMode: "date",
+    helperText: "End Date of the Market *",
+    name: "endDate",
+    placeholder: "End Date"
+  },
+  {
+    dateMode: "time",
+    helperText: "End Time of the Market *",
+    name: "endTime",
+    placeholder: "End Time"
+  }
+];
+var availableTagTypes = [
+  "All Ages",
+  "Day Market",
+  "Family Friendly",
+  "Free Entry",
+  "Indoor Market",
+  "Live Music",
+  "Night Market",
+  "Outdoor Market",
+  "Pet Friendly",
+  "Near Bustop",
+  "Near Train Station",
+  "Parking Available",
+  "Toilet Available",
+  "Wheelchair Accessible",
+  "Near Playground"
+];
+var tagOptions = mapArrayToOptions(availableTagTypes);
+var rejectionPolicyOptions = mapArrayToOptions(
+  Object.values(EnumRejectionPolicy)
+);
+
+// src/formFields/auth.ts
+var loginFields = [
+  {
+    helperText: "Enter your email address",
+    keyboardType: "email-address",
+    name: "email",
+    placeholder: "Email"
+  },
+  {
+    helperText: "Enter your password",
+    keyboardType: "default",
+    name: "password",
+    placeholder: "Password",
+    secureTextEntry: true
+  }
+];
+var registerFields = [
+  {
+    helperText: "Enter your first name",
+    keyboardType: "default",
+    name: "firstName",
+    placeholder: "First Name"
+  },
+  {
+    helperText: "Enter your last name",
+    keyboardType: "default",
+    name: "lastName",
+    placeholder: "Last Name"
+  },
+  {
+    helperText: "Enter your email address",
+    keyboardType: "email-address",
+    name: "email",
+    placeholder: "Email"
+  },
+  {
+    helperText: "Enter your password",
+    keyboardType: "default",
+    name: "password",
+    placeholder: "Password",
+    secureTextEntry: true
+  }
+];
+var forgotPasswordFields = [
+  {
+    helperText: "Enter your email address",
+    keyboardType: "email-address",
+    name: "email",
+    placeholder: "Email"
+  }
+];
+var resetPasswordFields = [
+  {
+    helperText: "Enter your new password",
+    keyboardType: "default",
+    name: "password",
+    placeholder: "Password",
+    secureTextEntry: true
+  },
+  {
+    helperText: "Confirm your new password",
+    keyboardType: "default",
+    name: "confirmPassword",
+    placeholder: "Confirm Password",
+    secureTextEntry: true
+  }
+];
+
+// src/formFields/user.ts
+var profileFields = [
+  {
+    disabled: true,
+    helperText: "Email cannot be changed",
+    keyboardType: "email-address",
+    name: "email",
+    placeholder: "Email"
+  },
+  {
+    helperText: "Enter your first name",
+    keyboardType: "default",
+    name: "firstName",
+    placeholder: "First Name"
+  },
+  {
+    helperText: "Enter your last name",
+    keyboardType: "default",
+    name: "lastName",
+    placeholder: "Last Name"
+  },
+  {
+    helperText: "Enter your new password",
+    keyboardType: "default",
+    name: "password",
+    placeholder: "Password",
+    secureTextEntry: true
+  },
+  {
+    helperText: "Confirm your new password",
+    keyboardType: "default",
+    name: "confirmPassword",
+    placeholder: "Confirm Password",
+    secureTextEntry: true
+  }
+];
+
+// src/formFields/categories.ts
+var availableCategories = [
+  {
+    id: "food-drinks",
+    name: "Food & Drinks",
+    subcategories: [
+      {
+        id: "fresh-food-groceries",
+        items: [
+          "Fruits & Vegetables",
+          "Meat & Seafood",
+          "Dairy & Eggs",
+          "Bakery & Desserts",
+          "Spices & Condiments",
+          "Packaged & Specialty Foods",
+          "Other"
+        ],
+        name: "Fresh Food & Groceries"
+      },
+      {
+        id: "beverages-specialty-drinks",
+        items: [
+          "Fresh Juices & Smoothies",
+          "Coffee & Teas",
+          "Dairy & Plant-Based Drinks",
+          "Alcoholic Beverages",
+          "Other"
+        ],
+        name: "Beverages & Specialty Drinks"
+      },
+      {
+        id: "prepared-street-foods",
+        items: [
+          "Local & International Specialties",
+          "Vegan & Vegetarian Options",
+          "Candies & Sweets",
+          "BBQ & Grilled Foods",
+          "Other"
+        ],
+        name: "Prepared & Street Foods"
+      }
+    ]
+  },
+  {
+    id: "handmade-local-products",
+    name: "Handmade & Local Products",
+    subcategories: [
+      {
+        id: "home-lifestyle",
+        items: [
+          "Textiles & Home Decor",
+          "Pottery & Ceramics",
+          "Woodwork & Carving",
+          "Handwoven Baskets & Bags",
+          "Other"
+        ],
+        name: "Home & Lifestyle"
+      },
+      {
+        id: "fashion-accessories",
+        items: [
+          "Leather & Hand-Stitched Items",
+          "Handcrafted Jewelry & Accessories",
+          "Traditional & Cultural Clothing",
+          "Other"
+        ],
+        name: "Fashion & Accessories"
+      },
+      {
+        id: "eco-friendly-products",
+        items: [
+          "Recycled Goods",
+          "Eco-Packaging",
+          "Sustainable Fashion & Accessories",
+          "Other"
+        ],
+        name: "Eco-Friendly & Sustainable Products"
+      },
+      {
+        id: "arts-crafts",
+        items: ["Art & Crafts", "Traditional & Cultural Items", "Other"],
+        name: "Arts & Crafts"
+      }
+    ]
+  },
+  {
+    id: "clothing-fashion",
+    name: "Clothing & Fashion",
+    subcategories: [
+      {
+        id: "casual-modern-wear",
+        items: [
+          "Modern & Casual Clothes",
+          "Jackets & Outerwear",
+          "Baby & Kids Clothing",
+          "Scarves & Shawls",
+          "Second-Hand Designer Clothes",
+          "Underwear",
+          "Other"
+        ],
+        name: "Casual & Modern Wear"
+      },
+      {
+        id: "footwear",
+        items: [
+          "Everyday Shoes",
+          "Formal Shoes",
+          "Handmade & Leather Shoes",
+          "Other"
+        ],
+        name: "Footwear"
+      },
+      {
+        id: "bags-accessories",
+        items: [
+          "Bags, Belts, Hats, Sunglasses, Watches",
+          "Retro and Vintage Accessories",
+          "Other"
+        ],
+        name: "Bags & Accessories"
+      },
+      {
+        id: "luxury-designer-brands",
+        items: [
+          "Luxury Clothing",
+          "Designer Shoes",
+          "Exclusive Accessories",
+          "Other"
+        ],
+        name: "Luxury & Designer Brands"
+      }
+    ]
+  },
+  {
+    id: "home-garden-household",
+    name: "Home, Garden & Household Goods",
+    subcategories: [
+      {
+        id: "home-essentials-kitchenware",
+        items: [
+          "Kitchenware & Dining",
+          "Sustainable & Eco-Friendly Items",
+          "Handmade & Artisan Home Goods",
+          "Other"
+        ],
+        name: "Home Essentials & Kitchenware"
+      },
+      {
+        id: "furniture-decor-organization",
+        items: [
+          "Furniture & Home Decor",
+          "Textiles & Bedding",
+          "Storage & Organization",
+          "Other"
+        ],
+        name: "Furniture, Decor & Organization"
+      },
+      {
+        id: "outdoor-cleaning-essentials",
+        items: [
+          "Garden, Plants & Decorations",
+          "DIY & Home Improvement",
+          "Cleaning Supplies & Household Essentials",
+          "Other"
+        ],
+        name: "Outdoor & Cleaning Essentials"
+      }
+    ]
+  },
+  {
+    id: "toys-pets",
+    name: "Toys & Pets",
+    subcategories: [
+      {
+        id: "handmade-eco-friendly-kids",
+        items: ["Handmade & Local Toys", "Eco-Friendly Kids Products", "Other"],
+        name: "Handmade & Eco-Friendly Kids Products"
+      },
+      {
+        id: "toys-all-ages",
+        items: [
+          "Classic & Interactive Toys",
+          "Building Blocks & Board Games",
+          "Balloons & Party Accessories",
+          "Other"
+        ],
+        name: "Toys for All Ages"
+      },
+      {
+        id: "pet-products-animal-goods",
+        items: [
+          "Natural Pet Foods",
+          "Handmade Pet Accessories",
+          "Livestock & Farm Supplies",
+          "Other"
+        ],
+        name: "Pet Products & Animal Goods"
+      }
+    ]
+  },
+  {
+    id: "health-wellness-selfcare",
+    name: "Health, Wellness & Self-Care",
+    subcategories: [
+      {
+        id: "natural-remedies-supplements",
+        items: [
+          "Vitamins, Minerals & Herbal Remedies",
+          "Superfoods, Probiotics & Detox Teas",
+          "Other"
+        ],
+        name: "Natural Remedies & Supplements"
+      },
+      {
+        id: "organic-natural-products",
+        items: [
+          "Organic Produce, Honey, Nuts & Seeds",
+          "Gluten-Free & Specialty Items",
+          "Other"
+        ],
+        name: "Organic & Natural Products"
+      },
+      {
+        id: "fitness-sports-nutrition",
+        items: ["Protein Powders & Bars", "Sports & Energy Drinks", "Other"],
+        name: "Fitness & Sports Nutrition"
+      },
+      {
+        id: "mental-wellbeing-relaxation",
+        items: [
+          "Yoga, Meditation & Stress-Relief Tools",
+          "Massage & Muscle Relaxers",
+          "Motivational Books & Tools",
+          "Other"
+        ],
+        name: "Mental Wellbeing & Relaxation"
+      }
+    ]
+  },
+  {
+    id: "electronics-technology",
+    name: "Electronics & Technology",
+    subcategories: [
+      {
+        id: "electronic-devices-accessories",
+        items: [
+          "Refurbished & Used Electronics",
+          "Smartphones & Gadgets",
+          "Computers & Gaming Gear",
+          "Photography & Audio Equipment",
+          "Other"
+        ],
+        name: "Electronic Devices & Accessories"
+      }
+    ]
+  },
+  {
+    id: "antiques-collectibles",
+    name: "Antiques & Collectibles",
+    subcategories: [
+      {
+        id: "antiques-vintage-furniture",
+        items: [
+          "Old Clocks, Paintings & Sculptures",
+          "Coins, Stamps & Rare Books",
+          "Antique & Vintage Furniture & Home Decor",
+          "Other"
+        ],
+        name: "Antiques & Vintage Furniture"
+      },
+      {
+        id: "historical-rare-items",
+        items: [
+          "War Relics & Military Medals",
+          "Limited Edition Artworks & Memorabilia",
+          "Other"
+        ],
+        name: "Historical & Rare Items"
+      },
+      {
+        id: "collectible-toys-games",
+        items: [
+          "Limited Edition Figures & Retro Board Games",
+          "Pop Culture & Sports Memorabilia",
+          "Other"
+        ],
+        name: "Collectible Toys & Games"
+      }
+    ]
+  }
+];
+var categoryColors = {
+  "antiques-collectibles": "#DE630A",
+  "clothing-fashion": "#6A08C5",
+  "electronics-technology": "#0303BE",
+  "food-drinks": "#FF004D",
+  "handmade-local-products": "#8E4827",
+  "health-wellness-selfcare": "#7DFB03",
+  "home-garden-household": "#006400",
+  "toys-pets": "#3357FF"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnumInviteStatus,
+  EnumRegions,
+  EnumRejectionPolicy,
+  EnumRelationResource,
+  EnumResourceType,
+  EnumResourceTypeIcon,
+  EnumUserLicence,
+  EnumUserRole,
+  GOOGLE_API_KEY,
+  ImageTypeEnum,
+  availableCategories,
+  availableCityOptions,
+  availableRegionOptions,
+  availableRegionTypes,
+  availableTagTypes,
+  capitalizeFirstLetter,
+  categoryColors,
+  dateFormat,
+  dateTimeSchema,
+  defaultMarketFormValues,
+  defaultRegion,
+  defaultStallholderApplyFormValues,
+  defaultStallholderFormValues,
+  emailSchema,
+  endDateAfterStartDateTest,
+  endDateNotInPastTest,
+  endTimeMustBeAfterStartTimeTest,
+  forgotPasswordFields,
+  forgotPasswordSchema,
+  formatDate,
+  formatTimestamp,
+  getCurrentAndFutureDates,
+  getFutureDatesAfterThreshold,
+  globalDefaultValues,
+  globalResourceSchema,
+  locationSchema,
+  loginFields,
+  loginSchema,
+  mapArrayToOptions,
+  marketBasicInfoFields,
+  marketEndDateFields,
+  marketSchema,
+  marketStartDateFields,
+  packagingOptions,
+  passwordSchema,
+  paymentMethodOptions,
+  producedIngOptions,
+  profileFields,
+  registerFields,
+  registerSchema,
+  rejectionPolicyOptions,
+  removeTypename,
+  resetPasswordFields,
+  resetPasswordSchema,
+  sortDatesByProximity,
+  stallApplicationInfo,
+  stallHolderSchema,
+  stallholderApplyFormSchema,
+  stallholderBasicInfoFields,
+  stallholderElectricity,
+  stallholderEndDateFields,
+  stallholderFullAddress,
+  stallholderGazebo,
+  stallholderLocationDescription,
+  stallholderMultiLocation,
+  stallholderPackaging,
+  stallholderPaymentMethod,
+  stallholderPriceRange,
+  stallholderProducedIn,
+  stallholderStallSize,
+  stallholderStartDateFields,
+  stallholderTable,
+  startDateNotInPastTest,
+  startTimeCannotBeInPastTest,
+  statusOptions,
+  tagOptions,
+  timeFormat,
+  truncateText,
+  useAddUserFavouriteResource,
+  useCreateMarket,
+  useCreateRelation,
+  useCreateStallholder,
+  useCreateStallholderApplyForm,
+  useCreateUser,
+  useDeleteMarket,
+  useDeleteRelation,
+  useDeleteStallholder,
+  useForgotPassword,
+  useGetMarket,
+  useGetMarketRelations,
+  useGetMarkets,
+  useGetMarketsByRegion,
+  useGetMarketsNearMe,
+  useGetNotification,
+  useGetRelation,
+  useGetRelationByMarketAndStallholder,
+  useGetResourceConnections,
+  useGetStallholder,
+  useGetStallholderApplyForm,
+  useGetStallholderRelations,
+  useGetStallholders,
+  useGetStallholdersByRegion,
+  useGetUser,
+  useGetUserFavourites,
+  useGetUserMarkets,
+  useGetUserNotifications,
+  useGetUsers,
+  useLocationSearch,
+  useLogin,
+  useLoginForm,
+  useMarketForm,
+  useRegister,
+  useRegisterForm,
+  useRemoveUserFavouriteResource,
+  useSearchMarkets,
+  useSearchStallholders,
+  useStallholderApplyForm,
+  useStallholderForm,
+  useUpdateMarket,
+  useUpdateRelation,
+  useUpdateStallholder,
+  useUpdateStallholderApplyForm,
+  useUpdateUser,
+  useUserForm,
+  useVerifyEmail,
+  userSchema,
+  validateEmailSchema
+});
+//# sourceMappingURL=index.js.map