@timardex/cluemart-shared 1.2.34 → 1.2.36

package/dist/index.cjs

@@ -30,9 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AdModel: () => AdModel,
-  CategorySchema: () => CategorySchema,
-  ChatModel: () => ChatModel,
   EnumActivity: () => EnumActivity,
   EnumAdShowOn: () => EnumAdShowOn,
   EnumAdStatus: () => EnumAdStatus,
@@ -46,7 +43,6 @@ __export(index_exports, {
   EnumNotificationType: () => EnumNotificationType,
   EnumOSPlatform: () => EnumOSPlatform,
   EnumPaymentMethod: () => EnumPaymentMethod,
-  EnumPubSubEvents: () => EnumPubSubEvents,
   EnumRegions: () => EnumRegions,
   EnumRelationResource: () => EnumRelationResource,
   EnumResourceType: () => EnumResourceType,
@@ -54,38 +50,20 @@ __export(index_exports, {
   EnumUserLicence: () => EnumUserLicence,
   EnumUserRole: () => EnumUserRole,
   EnumVendorType: () => EnumVendorType,
-  EventInfoModel: () => EventInfoModel,
-  EventModel: () => EventModel,
   ImageTypeEnum: () => ImageTypeEnum,
-  NotificationModel: () => NotificationModel,
-  ParticipantSchema: () => ParticipantSchema,
-  PushTokenModel: () => PushTokenModel,
-  RelationModel: () => RelationModel,
-  RelationTypeSchema: () => RelationTypeSchema,
-  ResourceActivityModel: () => ResourceActivityModel,
-  ResourceImageTypeSchema: () => ResourceImageTypeSchema,
   SAVED_EMAIL_KEY: () => SAVED_EMAIL_KEY,
   SAVED_PASSWORD_KEY: () => SAVED_PASSWORD_KEY,
   SAVED_REFRESH_TOKEN_KEY: () => SAVED_REFRESH_TOKEN_KEY,
   SAVED_TOKEN_KEY: () => SAVED_TOKEN_KEY,
-  SocialMediaTypeSchema: () => SocialMediaTypeSchema,
-  StallTypeSchema: () => StallTypeSchema,
-  TesterModel: () => TesterModel,
   USER_STORAGE_KEY: () => USER_STORAGE_KEY,
-  UserModel: () => UserModel,
-  VendorInfoModel: () => VendorInfoModel,
-  VendorModel: () => VendorModel,
-  VerificationTokenModel: () => VerificationTokenModel,
   availableCategories: () => availableCategories,
   availableCityOptions: () => availableCityOptions,
   availableRegionOptions: () => availableRegionOptions,
   availableRegionTypes: () => availableRegionTypes,
   availableTagTypes: () => availableTagTypes,
-  baseResourceFields: () => baseResourceFields,
   capitalizeFirstLetter: () => capitalizeFirstLetter,
   categoryColors: () => categoryColors,
   companyContactFields: () => companyContactFields,
-  connectToDatabase: () => connectToDatabase,
   contactUsFields: () => contactUsFields,
   darkColors: () => darkColors,
   dateFormat: () => dateFormat,
@@ -111,28 +89,22 @@ __export(index_exports, {
   loginFields: () => loginFields,
   mapArrayToOptions: () => mapArrayToOptions,
   mapBaseResourceTypeToFormData: () => mapBaseResourceTypeToFormData,
-  mongoose: () => import_mongoose.default,
   normalizeUrl: () => normalizeUrl,
   packagingOptions: () => packagingOptions,
-  partnersSchema: () => partnersSchema,
   paymentMethodOptions: () => paymentMethodOptions,
   producedIngOptions: () => producedIngOptions,
   productLabelGroups: () => productLabelGroups,
   profileFields: () => profileFields,
   registerFields: () => registerFields,
-  relationDatesSchema: () => relationDatesSchema,
   removeTypename: () => removeTypename,
   requestPasswordResetFields: () => requestPasswordResetFields,
   requirementsOptions: () => requirementsOptions,
   resetPasswordFields: () => resetPasswordFields,
-  saveNotificationsInDb: () => saveNotificationsInDb,
-  sendPushNotifications: () => sendPushNotifications,
   socialMediaFields: () => socialMediaFields,
   sortDatesChronologically: () => sortDatesChronologically,
   stallTypeOptions: () => stallTypeOptions,
   statusOptions: () => statusOptions,
   tagOptions: () => tagOptions,
-  termsAgreementSchema: () => termsAgreementSchema,
   testersFields: () => testersFields,
   timeFormat: () => timeFormat,
   truncateText: () => truncateText,
@@ -4950,7 +4922,7 @@ var socialMediaSchema = yup.object({
     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: (schema11) => schema11.notRequired()
+    otherwise: (schema) => schema.notRequired()
   })
 });
 var globalResourceSchema = yup.object().shape({
@@ -5023,21 +4995,21 @@ var paymentInfoSchema = yup2.object({
   paymentMethod: yup2.mixed().oneOf(Object.values(EnumPaymentMethod)).required("Please select a Payment method"),
   accountHolderName: yup2.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
-    then: (schema11) => schema11.required("Account holder name is required for bank transfer").trim(),
-    otherwise: (schema11) => schema11.notRequired()
+    then: (schema) => schema.required("Account holder name is required for bank transfer").trim(),
+    otherwise: (schema) => schema.notRequired()
   }),
   accountNumber: yup2.string().when("paymentMethod", {
     is: "bank_transfer" /* BANK_TRANSFER */,
-    then: (schema11) => schema11.required("Account number is required for bank transfer").matches(
+    then: (schema) => schema.required("Account number is required for bank transfer").matches(
       nzBankAccountRegex,
       "Account number must be in format: XX-XXXX-XXXXXXX-XX"
     ).trim(),
-    otherwise: (schema11) => schema11.notRequired()
+    otherwise: (schema) => schema.notRequired()
   }),
   link: yup2.string().when("paymentMethod", {
     is: (val) => val !== "bank_transfer" /* BANK_TRANSFER */,
     then: () => normalizedUrlTransform().url("Link must be a valid URL").required("Link is required for PayPal/Stripe"),
-    otherwise: (schema11) => schema11.notRequired()
+    otherwise: (schema) => schema.notRequired()
   })
 });
 var eventInfoSchema = yup2.object().shape({
@@ -5217,7 +5189,7 @@ var adSchema = yup7.object().shape({
     return endDate > now;
   }).when("start", {
     is: (val) => val && val.length > 0,
-    then: (schema11) => schema11.test(
+    then: (schema) => schema.test(
       "is-after-start",
       "End date must be after start date",
       function(value) {
@@ -6187,1067 +6159,6 @@ function useAdForm(data) {
   };
 }
 
-// src/mongoose/Ad.ts
-var import_mongoose5 = __toESM(require("mongoose"));
-
-// src/types/global.ts
-var import_mongoose = __toESM(require("mongoose"));
-var EnumPubSubEvents = /* @__PURE__ */ ((EnumPubSubEvents2) => {
-  EnumPubSubEvents2["GET_CHAT_MESSAGE"] = "GET_CHAT_MESSAGE";
-  EnumPubSubEvents2["GET_NOTIFICATIONS"] = "GET_NOTIFICATIONS";
-  EnumPubSubEvents2["GET_NOTIFICATIONS_COUNT"] = "GET_NOTIFICATIONS_COUNT";
-  EnumPubSubEvents2["USER_TYPING"] = "USER_TYPING";
-  return EnumPubSubEvents2;
-})(EnumPubSubEvents || {});
-
-// src/types/resourceActivities.ts
-var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
-  EnumActivity2["FAVORITE"] = "FAVORITE";
-  EnumActivity2["GOING"] = "GOING";
-  EnumActivity2["INTERESTED"] = "INTERESTED";
-  EnumActivity2["PRESENT"] = "PRESENT";
-  EnumActivity2["VIEW"] = "VIEW";
-  return EnumActivity2;
-})(EnumActivity || {});
-
-// src/mongoose/global.ts
-var import_mongoose4 = __toESM(require("mongoose"));
-
-// src/mongoose/Relation.ts
-var import_mongoose3 = __toESM(require("mongoose"));
-
-// src/mongoose/event/EventInfo.ts
-var import_mongoose2 = __toESM(require("mongoose"));
-var MongooseSchema = import_mongoose2.default.Schema;
-var StallTypeSchema = new MongooseSchema(
-  {
-    electricity: {
-      price: { required: false, type: Number },
-      selected: { required: false, type: Boolean }
-    },
-    label: { required: false, type: String },
-    price: { required: false, type: Number },
-    stallCapacity: { required: false, type: Number }
-  },
-  {
-    _id: false
-    // Prevents Mongoose from creating an additional _id field for subdocuments
-  }
-);
-var dateTimeSchema2 = new MongooseSchema(
-  {
-    endDate: { required: true, type: String },
-    endTime: { required: true, type: String },
-    stallTypes: [StallTypeSchema],
-    startDate: { required: true, type: String },
-    startTime: { required: true, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var paymentInfoSchema2 = new MongooseSchema(
-  {
-    accountHolderName: { required: false, type: String },
-    accountNumber: { required: false, type: String },
-    link: { required: false, type: String },
-    paymentMethod: {
-      enum: Object.values(EnumPaymentMethod),
-      required: true,
-      type: String
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field
-);
-var requirementsSchema = new MongooseSchema(
-  {
-    category: { required: true, type: String },
-    label: { required: true, type: String },
-    value: { required: true, type: Boolean }
-  },
-  {
-    _id: false
-    // Prevents Mongoose from creating an additional _id field for
-  }
-);
-var schema = new MongooseSchema(
-  {
-    applicationDeadlineHours: { required: true, type: Number },
-    dateTime: [dateTimeSchema2],
-    eventId: {
-      ref: "Event",
-      required: false,
-      type: import_mongoose2.default.Schema.Types.ObjectId
-    },
-    packInTime: { required: true, type: Number },
-    paymentDueHours: { required: true, type: Number },
-    paymentInfo: [paymentInfoSchema2],
-    requirements: [requirementsSchema]
-  },
-  { timestamps: true }
-);
-var EventInfoModel = import_mongoose2.default.models.EventInfo || import_mongoose2.default.model("EventInfo", schema);
-
-// src/mongoose/Relation.ts
-var MongooseSchema2 = import_mongoose3.default.Schema;
-var relationDatesSchema = new MongooseSchema2(
-  {
-    lastUpdateBy: {
-      resourceId: { required: false, type: String },
-      userEmail: { required: false, type: String }
-    },
-    paymentReference: { required: false, type: String },
-    stallType: StallTypeSchema,
-    startDate: { required: false, type: String },
-    startTime: { required: false, type: String },
-    status: {
-      enum: Object.values(EnumInviteStatus),
-      required: false,
-      type: String
-    }
-  },
-  { _id: false }
-);
-var RelationTypeSchema = new MongooseSchema2(
-  {
-    active: { default: true, required: true, type: Boolean },
-    chatId: {
-      ref: "Chat",
-      required: true,
-      type: import_mongoose3.default.Schema.Types.ObjectId
-    },
-    deletedAt: { default: null, required: false, type: Date },
-    eventId: {
-      ref: "Event",
-      required: true,
-      type: import_mongoose3.default.Schema.Types.ObjectId
-    },
-    lastUpdateBy: {
-      enum: Object.values(EnumResourceType),
-      required: true,
-      type: String
-    },
-    relationDates: [relationDatesSchema],
-    relationType: {
-      enum: Object.values(EnumRelationResource),
-      required: true,
-      type: String
-    },
-    vendorId: {
-      ref: "Vendor",
-      required: true,
-      type: import_mongoose3.default.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-RelationTypeSchema.index({
-  "relationDates.startDate": 1,
-  "relationDates.startTime": 1,
-  "relationDates.status": 1
-});
-var RelationModel = import_mongoose3.default.models.Relation || import_mongoose3.default.model("Relation", RelationTypeSchema);
-
-// src/mongoose/global.ts
-var MongooseSchema3 = import_mongoose4.default.Schema;
-var OwnerTypeSchema = new MongooseSchema3(
-  {
-    email: { required: true, type: String },
-    userId: {
-      ref: "User",
-      required: true,
-      type: import_mongoose4.default.Schema.Types.ObjectId
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var SocialMediaTypeSchema = new MongooseSchema3(
-  {
-    link: { required: true, type: String },
-    name: { required: true, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field
-);
-var ResourceImageTypeSchema = new MongooseSchema3(
-  {
-    source: { required: false, type: String },
-    title: { required: false, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var SubCategorySchema = new MongooseSchema3(
-  {
-    id: { required: false, type: String },
-    items: [
-      {
-        id: { required: false, type: String },
-        name: { required: false, type: String }
-      }
-    ],
-    name: { required: false, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var CategorySchema = new MongooseSchema3(
-  {
-    id: { required: true, type: String },
-    name: { required: true, type: String },
-    subcategories: [SubCategorySchema]
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var PosterUsageTypeSchema = new MongooseSchema3(
-  {
-    count: { default: 0, required: false, type: Number },
-    month: { required: false, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var partnersSchema = new MongooseSchema3(
-  {
-    email: { required: false, type: String },
-    licence: {
-      enum: Object.values(EnumUserLicence),
-      required: false,
-      type: String
-    },
-    resourceId: {
-      required: false,
-      type: String
-    },
-    resourceType: {
-      enum: Object.values(EnumResourceType),
-      required: false,
-      type: String
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var ContactDetailsSchema = new MongooseSchema3(
-  {
-    email: { required: false, type: String },
-    landlinePhone: { required: false, type: String },
-    mobilePhone: { required: false, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var termsAgreementSchema = new MongooseSchema3(
-  {
-    appBuildNumber: { required: true, type: String },
-    appId: { required: true, type: String },
-    appVersion: { required: true, type: String },
-    brand: { required: true, type: String },
-    deviceName: { required: true, type: String },
-    installationId: { required: true, type: String },
-    manufacturer: { required: true, type: String },
-    modelName: { required: true, type: String },
-    osName: { required: true, type: String },
-    osVersion: { required: true, type: String },
-    termVersion: { required: true, type: String },
-    timestamp: { required: true, type: String }
-  },
-  { _id: false }
-);
-var resourceRelationsSchema = new MongooseSchema3(
-  {
-    relationDates: {
-      default: [],
-      required: false,
-      type: [relationDatesSchema]
-    },
-    relationId: {
-      ref: "Relation",
-      required: false,
-      type: import_mongoose4.default.Schema.Types.ObjectId
-    }
-  },
-  { _id: false }
-);
-var baseResourceFields = {
-  active: { default: false, required: true, type: Boolean },
-  adIds: {
-    ref: "Ad",
-    required: false,
-    type: [import_mongoose4.default.Schema.Types.ObjectId]
-  },
-  contactDetails: ContactDetailsSchema,
-  cover: ResourceImageTypeSchema,
-  deletedAt: { default: null, required: false, type: Date },
-  description: { required: true, type: String },
-  images: [ResourceImageTypeSchema],
-  logo: ResourceImageTypeSchema,
-  name: { required: true, type: String },
-  owner: OwnerTypeSchema,
-  partners: {
-    required: false,
-    type: [partnersSchema]
-  },
-  posterUsage: PosterUsageTypeSchema,
-  promoCodes: { required: false, type: [String] },
-  region: { required: true, type: String },
-  relations: {
-    default: [],
-    required: false,
-    type: [resourceRelationsSchema]
-  },
-  socialMedia: [SocialMediaTypeSchema],
-  termsAgreement: termsAgreementSchema
-};
-
-// src/mongoose/Ad.ts
-var MongooseSchema4 = import_mongoose5.default.Schema;
-var schema2 = new MongooseSchema4(
-  {
-    active: { default: true, type: Boolean },
-    adStyle: {
-      default: "Bloom" /* BLOOM */,
-      enum: Object.values(EnumAdStyle),
-      required: true,
-      type: String
-    },
-    adType: {
-      default: "Sponsored" /* SPONSORED */,
-      enum: Object.values(EnumAdType),
-      required: true,
-      type: String
-    },
-    // TODO: similar to  ViewSchema
-    clicks: { default: 0, required: true, type: Number },
-    clui: { required: false, type: String },
-    end: { required: true, type: Date },
-    // TODO: similar to  ViewSchema
-    impressions: { default: 0, required: true, type: Number },
-    resourceCover: { required: true, type: String },
-    resourceDescription: { required: true, type: String },
-    resourceId: { required: true, type: String },
-    resourceLogo: { required: false, type: String },
-    resourceName: { required: true, type: String },
-    resourceRegion: { required: true, type: String },
-    resourceType: {
-      enum: Object.values(EnumResourceType),
-      required: true,
-      type: String
-    },
-    showOn: {
-      default: "Front_page" /* FRONT_PAGE */,
-      enum: Object.values(EnumAdShowOn),
-      required: true,
-      type: String
-    },
-    socialMedia: [SocialMediaTypeSchema],
-    start: { required: true, type: Date },
-    status: {
-      default: "Active" /* ACTIVE */,
-      enum: Object.values(EnumAdStatus),
-      required: true,
-      type: String
-    },
-    targetRegion: { required: false, type: String }
-  },
-  {
-    timestamps: true
-  }
-);
-schema2.index({
-  end: 1,
-  start: 1,
-  status: 1
-});
-var AdModel = import_mongoose5.default.models.Ad || import_mongoose5.default.model("Ad", schema2);
-
-// src/mongoose/Chat.ts
-var import_mongoose6 = __toESM(require("mongoose"));
-var MongooseSchema5 = import_mongoose6.default.Schema;
-var MessageSchema = new MongooseSchema5(
-  {
-    content: { required: true, type: String },
-    senderAvatar: { required: false, type: String },
-    senderId: {
-      ref: "User",
-      required: true,
-      type: import_mongoose6.default.Schema.Types.ObjectId
-    },
-    senderName: { required: true, type: String }
-  },
-  { timestamps: true }
-);
-var ParticipantSchema = new MongooseSchema5(
-  {
-    active: { default: true, required: true, type: Boolean },
-    email: { required: true, type: String },
-    userId: {
-      ref: "User",
-      required: true,
-      type: import_mongoose6.default.Schema.Types.ObjectId
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var ChatSchema = new MongooseSchema5(
-  {
-    active: { default: true, required: true, type: Boolean },
-    chatName: { required: true, type: String },
-    chatType: {
-      enum: Object.values(EnumChatType),
-      required: true,
-      type: String
-    },
-    deletedAt: { default: null, required: false, type: Date },
-    messages: [MessageSchema],
-    participants: [ParticipantSchema],
-    resourceInfo: {
-      eventId: {
-        ref: "Event",
-        required: false,
-        type: import_mongoose6.default.Schema.Types.ObjectId
-      },
-      vendorId: {
-        ref: "Vendor",
-        required: false,
-        type: import_mongoose6.default.Schema.Types.ObjectId
-      }
-    }
-  },
-  {
-    timestamps: true
-  }
-);
-var ChatModel = import_mongoose6.default.models.Chat || import_mongoose6.default.model("Chat", ChatSchema);
-
-// src/mongoose/Notification.ts
-var import_mongoose7 = __toESM(require("mongoose"));
-var MongooseSchema6 = import_mongoose7.default.Schema;
-var schema3 = new MongooseSchema6(
-  {
-    data: {
-      resourceId: { required: true, type: String },
-      resourceName: { required: true, type: String },
-      resourceType: {
-        enum: Object.values(EnumNotificationResourceType),
-        required: true,
-        type: String
-      }
-    },
-    isRead: { default: false, index: true, required: true, type: Boolean },
-    message: { required: true, type: String },
-    title: { required: true, type: String },
-    type: {
-      default: "system" /* SYSTEM */,
-      enum: Object.values(EnumNotificationType),
-      required: true,
-      type: String
-    },
-    userId: {
-      ref: "User",
-      required: true,
-      type: import_mongoose7.default.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-schema3.index({ isRead: 1, userId: 1 });
-schema3.index({ createdAt: -1, userId: 1 });
-var NotificationModel = import_mongoose7.default.models.Notification || import_mongoose7.default.model("Notification", schema3);
-
-// src/mongoose/PushToken.ts
-var import_mongoose8 = __toESM(require("mongoose"));
-var MongooseSchema7 = import_mongoose8.default.Schema;
-var schema4 = new MongooseSchema7(
-  {
-    platform: {
-      enum: Object.values(EnumOSPlatform),
-      required: true,
-      type: String
-    },
-    token: { required: true, type: String },
-    userId: { required: true, type: import_mongoose8.default.Schema.Types.ObjectId }
-  },
-  { timestamps: true }
-);
-var PushTokenModel = import_mongoose8.default.models.PushToken || import_mongoose8.default.model("PushToken", schema4);
-
-// src/mongoose/ResourceActivity.ts
-var import_mongoose9 = __toESM(require("mongoose"));
-var MongooseSchema8 = import_mongoose9.default.Schema;
-var ActivitySchema = new MongooseSchema8(
-  {
-    activityType: {
-      enum: Object.values(EnumActivity),
-      required: true,
-      type: String
-    },
-    location: {
-      coordinates: {
-        required: false,
-        type: [Number]
-      },
-      type: {
-        default: "Point",
-        enum: ["Point"],
-        required: false,
-        type: String
-      }
-    },
-    startDate: { required: false, type: String },
-    startTime: { required: false, type: String },
-    timestamp: { default: Date.now, type: Date },
-    userAgent: {
-      enum: Object.values(EnumOSPlatform),
-      required: true,
-      type: String
-    },
-    userId: { required: false, type: String }
-  },
-  { _id: false }
-);
-var schema5 = new MongooseSchema8(
-  {
-    activity: { default: [], type: [ActivitySchema] },
-    resourceId: { required: true, type: String },
-    resourceType: {
-      enum: Object.values(EnumResourceType),
-      required: true,
-      type: String
-    }
-  },
-  { timestamps: true }
-);
-schema5.index({ resourceId: 1, resourceType: 1 }, { unique: true });
-schema5.index({ "views.location": "2dsphere" });
-var ResourceActivityModel = import_mongoose9.default.models.ResourceActivity || import_mongoose9.default.model("ResourceActivity", schema5);
-
-// src/mongoose/Testers.ts
-var import_mongoose10 = __toESM(require("mongoose"));
-var MongooseSchema9 = import_mongoose10.default.Schema;
-var TesterSchema = new MongooseSchema9(
-  {
-    active: { default: false, required: true, type: Boolean },
-    categories: [CategorySchema],
-    companyName: { required: true, type: String },
-    email: { required: true, type: String },
-    firstName: { required: true, type: String },
-    lastName: { required: true, type: String },
-    osType: {
-      enum: Object.values(EnumOSPlatform),
-      required: true,
-      type: String
-    },
-    region: { required: true, type: String },
-    resourceType: {
-      enum: Object.values(EnumResourceType),
-      required: true,
-      type: String
-    }
-  },
-  {
-    timestamps: true
-  }
-);
-var TesterModel = import_mongoose10.default.models.Tester || import_mongoose10.default.model("Tester", TesterSchema);
-
-// src/mongoose/User.ts
-var import_mongoose11 = __toESM(require("mongoose"));
-var MongooseSchema10 = import_mongoose11.default.Schema;
-var userActivityEventSchema = new MongooseSchema10(
-  {
-    resourceId: {
-      ref: "Event",
-      required: false,
-      type: import_mongoose11.default.Schema.Types.ObjectId
-    },
-    startDate: { required: false, type: String },
-    startTime: { required: false, type: String }
-  },
-  { _id: false }
-);
-var userActivityFavouritesSchema = new MongooseSchema10(
-  {
-    events: {
-      ref: "Event",
-      required: false,
-      type: [import_mongoose11.default.Schema.Types.ObjectId]
-    },
-    vendors: {
-      ref: "Vendor",
-      required: false,
-      type: [import_mongoose11.default.Schema.Types.ObjectId]
-    }
-  },
-  { _id: false }
-);
-var schema6 = new MongooseSchema10(
-  {
-    active: { default: false, required: true, type: Boolean },
-    avatar: ResourceImageTypeSchema,
-    deletedAt: { default: null, required: false, type: Date },
-    email: { required: true, type: String },
-    events: {
-      ref: "Event",
-      required: false,
-      type: [import_mongoose11.default.Schema.Types.ObjectId]
-    },
-    firstName: { required: true, type: String },
-    isTester: { default: false, required: false, type: Boolean },
-    lastName: { required: true, type: String },
-    licences: {
-      enum: Object.values(EnumUserLicence),
-      required: false,
-      type: [String]
-    },
-    partners: {
-      required: false,
-      type: [partnersSchema]
-    },
-    password: { required: true, type: String },
-    platform: {
-      enum: Object.values(EnumOSPlatform),
-      required: false,
-      type: String
-    },
-    preferredRegion: {
-      required: true,
-      type: String
-    },
-    refreshToken: {
-      required: false,
-      type: String
-    },
-    role: {
-      default: "customer" /* CUSTOMER */,
-      enum: Object.values(EnumUserRole),
-      required: true,
-      type: String
-    },
-    termsAgreement: termsAgreementSchema,
-    userActivity: {
-      favourites: {
-        default: () => ({ events: [], vendors: [] }),
-        type: userActivityFavouritesSchema
-      },
-      going: {
-        events: [userActivityEventSchema]
-      },
-      interested: {
-        events: [userActivityEventSchema]
-      },
-      present: {
-        events: [userActivityEventSchema]
-      }
-    },
-    vendor: {
-      ref: "Vendor",
-      required: false,
-      type: import_mongoose11.default.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-schema6.index({ "partners.email": 1 });
-var UserModel = import_mongoose11.default.models.User || import_mongoose11.default.model("User", schema6);
-
-// src/mongoose/VerificationToken.ts
-var import_mongoose12 = __toESM(require("mongoose"));
-var MongooseSchema11 = import_mongoose12.default.Schema;
-var schema7 = new MongooseSchema11(
-  {
-    createdAt: {
-      default: Date.now,
-      expires: 24 * 60 * 60,
-      // 24 hours in seconds (MongoDB TTL expects seconds)
-      required: true,
-      type: Date
-    },
-    // Token expires after 1 day
-    email: { required: true, type: String },
-    verificationToken: { required: true, type: String }
-  },
-  { timestamps: true }
-);
-var VerificationTokenModel = import_mongoose12.default.models.VerificationToken || import_mongoose12.default.model("VerificationToken", schema7);
-
-// src/mongoose/vendor/Vendor.ts
-var import_mongoose13 = __toESM(require("mongoose"));
-var MongooseSchema12 = import_mongoose13.default.Schema;
-var MenuTypeSchema = new MongooseSchema12(
-  {
-    description: { required: false, type: String },
-    name: { required: false, type: String },
-    price: { required: false, type: Number },
-    productGroups: { required: false, type: [String] }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var LocationsSchema = new MongooseSchema12(
-  {
-    dateTime: {
-      endDate: { required: false, type: String },
-      endTime: { required: false, type: String },
-      startDate: { required: false, type: String },
-      startTime: { required: false, type: String }
-    },
-    description: { required: false, type: String },
-    location: {
-      city: { required: false, type: String },
-      coordinates: {
-        required: false,
-        type: [Number]
-        // [longitude, latitude]
-      },
-      country: { required: false, type: String },
-      fullAddress: { required: false, type: String },
-      latitude: { required: false, type: Number },
-      longitude: { required: false, type: Number },
-      region: { required: false, type: String },
-      type: { required: false, type: String }
-      // Mongoose GeoJSON type
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var schema8 = new MongooseSchema12(
-  {
-    ...baseResourceFields,
-    // Importing base resource fields from global.ts
-    availability: {
-      corporate: { default: false, required: false, type: Boolean },
-      private: { default: false, required: false, type: Boolean },
-      school: { default: false, required: false, type: Boolean }
-    },
-    categories: [CategorySchema],
-    locations: [LocationsSchema],
-    multiLocation: { required: true, type: Boolean },
-    products: [MenuTypeSchema],
-    vendorInfoId: {
-      ref: "VendorInfo",
-      required: false,
-      type: import_mongoose13.default.Schema.Types.ObjectId
-    },
-    vendorType: {
-      enum: Object.values(EnumVendorType),
-      required: true,
-      type: String
-    }
-  },
-  { timestamps: true }
-);
-schema8.index({ name: 1 });
-schema8.index({ description: 1 });
-schema8.index({ region: 1 });
-schema8.index({ "categories.name": 1 });
-schema8.index({ "partners.email": 1 });
-var VendorModel = import_mongoose13.default.models.Vendor || import_mongoose13.default.model("Vendor", schema8);
-
-// src/mongoose/vendor/VendorInfo.ts
-var import_mongoose14 = __toESM(require("mongoose"));
-var MongooseSchema13 = import_mongoose14.default.Schema;
-var AttributesSchema = new MongooseSchema13(
-  {
-    details: { required: false, type: String },
-    isRequired: { default: false, required: true, type: Boolean }
-  },
-  { _id: false }
-);
-var schema9 = new MongooseSchema13(
-  {
-    compliance: {
-      foodBeverageLicense: { default: false, required: false, type: Boolean },
-      liabilityInsurance: { default: false, required: false, type: Boolean }
-    },
-    documents: [ResourceImageTypeSchema],
-    product: {
-      foodFlavors: {
-        enum: Object.values(EnumFoodFlavor),
-        required: true,
-        type: [String]
-      },
-      packaging: { required: true, type: [String] },
-      priceRange: {
-        max: { required: true, type: Number },
-        min: { required: true, type: Number }
-      },
-      producedIn: { required: true, type: [String] }
-    },
-    requirements: {
-      electricity: AttributesSchema,
-      gazebo: AttributesSchema,
-      table: AttributesSchema
-    },
-    stallInfo: {
-      size: {
-        depth: { required: true, type: Number },
-        width: { required: true, type: Number }
-      }
-    },
-    vendorId: {
-      ref: "Vendor",
-      required: true,
-      type: import_mongoose14.default.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-var VendorInfoModel = import_mongoose14.default.models.VendorInfo || import_mongoose14.default.model("VendorInfo", schema9);
-
-// src/mongoose/event/Event.ts
-var import_mongoose15 = __toESM(require("mongoose"));
-var MongooseSchema14 = import_mongoose15.default.Schema;
-var locationsSchema = new MongooseSchema14(
-  {
-    city: { required: true, type: String },
-    coordinates: {
-      required: true,
-      type: [Number]
-      // [longitude, latitude]
-    },
-    country: { required: true, type: String },
-    fullAddress: { required: true, type: String },
-    latitude: { required: true, type: Number },
-    longitude: { required: true, type: Number },
-    region: { required: true, type: String },
-    type: {
-      default: "Point",
-      enum: ["Point"],
-      required: true,
-      type: String
-    }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var dateTimeSchema3 = new MongooseSchema14(
-  {
-    endDate: { required: true, type: String },
-    endTime: { required: true, type: String },
-    startDate: { required: true, type: String },
-    startTime: { required: true, type: String }
-  },
-  { _id: false }
-  // Prevents Mongoose from creating an additional _id field for subdocuments
-);
-var schema10 = new MongooseSchema14(
-  {
-    ...baseResourceFields,
-    // Importing base resource fields from global.ts
-    dateTime: [dateTimeSchema3],
-    eventInfoId: {
-      ref: "EventInfo",
-      required: false,
-      type: import_mongoose15.default.Schema.Types.ObjectId
-    },
-    eventType: {
-      enum: Object.values(EnumEventType),
-      required: true,
-      type: String
-    },
-    location: {
-      required: true,
-      type: locationsSchema
-    },
-    nzbn: { required: true, type: String },
-    provider: { required: false, type: String },
-    rainOrShine: { required: true, type: Boolean },
-    tags: { required: true, type: [String] }
-  },
-  { timestamps: true }
-);
-schema10.index({ name: 1 });
-schema10.index({ description: 1 });
-schema10.index({ region: 1 });
-schema10.index({ location: "2dsphere" });
-schema10.index({ tags: 1 });
-schema10.index({ "partners.email": 1 });
-var EventModel = import_mongoose15.default.models.Event || import_mongoose15.default.model("Event", schema10);
-
-// src/service/database.ts
-var import_mongoose16 = __toESM(require("mongoose"));
-
-// src/service/timezonePlugin.ts
-var import_dayjs3 = __toESM(require("dayjs"));
-var import_timezone2 = __toESM(require("dayjs/plugin/timezone"));
-var import_utc2 = __toESM(require("dayjs/plugin/utc"));
-import_dayjs3.default.extend(import_utc2.default);
-import_dayjs3.default.extend(import_timezone2.default);
-function timezonePlugin(schema11) {
-  if (!schema11.get("timestamps")) return;
-  const transform = (_doc, ret) => {
-    if (ret.createdAt)
-      ret.createdAt = (0, import_dayjs3.default)(ret.createdAt).tz("Pacific/Auckland").format();
-    if (ret.updatedAt)
-      ret.updatedAt = (0, import_dayjs3.default)(ret.updatedAt).tz("Pacific/Auckland").format();
-    return ret;
-  };
-  schema11.set("toJSON", { transform });
-  schema11.set("toObject", { transform });
-}
-
-// src/service/database.ts
-import_mongoose16.default.plugin(timezonePlugin);
-var connectToDatabase = async ({
-  appName,
-  dbName,
-  dbPassword,
-  dbUser,
-  mongodbUri
-}) => {
-  try {
-    const mongoUri = mongodbUri ? mongodbUri : (
-      // Fallback to MongoDB Atlas connection string
-      `mongodb+srv://${dbUser}:${dbPassword}@${dbName}.mongodb.net/?retryWrites=true&w=majority&appName=${appName}`
-    );
-    await import_mongoose16.default.connect(mongoUri);
-    const connectionType = mongodbUri ? "Local MongoDB" : "MongoDB Atlas";
-    console.log(
-      `${connectionType} connected from server/src/service/database.ts`
-    );
-  } catch (err) {
-    console.error("Error connecting to MongoDB:", err);
-    throw err;
-  }
-};
-
-// src/service/saveNotificationsInDb.ts
-async function saveNotificationsInDb(payload) {
-  const { data, message, title, type, userIds } = payload;
-  try {
-    const notifications = userIds.map((userId) => ({
-      data,
-      isRead: false,
-      message,
-      title,
-      type,
-      userId
-    }));
-    await NotificationModel.insertMany(notifications);
-    console.log(
-      `Created ${notifications.length} notifications for ${userIds.length} users`
-    );
-    return [...new Set(userIds)];
-  } catch (error) {
-    console.error("Failed to create notifications:", error);
-    return [];
-  }
-}
-
-// src/service/sendPushNotifications.ts
-var import_expo_server_sdk = require("expo-server-sdk");
-var expo = new import_expo_server_sdk.Expo();
-function extractTokensFromMessage(message) {
-  return Array.isArray(message.to) ? message.to : [message.to];
-}
-function createPushMessages({
-  tokens,
-  message,
-  title,
-  data
-}) {
-  const messages = [];
-  const invalidTokens = [];
-  for (const token of tokens) {
-    if (!import_expo_server_sdk.Expo.isExpoPushToken(token)) {
-      invalidTokens.push(token);
-      continue;
-    }
-    messages.push({
-      body: message,
-      data: { ...data },
-      sound: "default",
-      title,
-      to: token
-    });
-  }
-  return { invalidTokens, messages };
-}
-function processChunkResults(tickets, chunk) {
-  let successCount = 0;
-  const failedTokens = [];
-  for (const [ticketIndex, ticket] of tickets.entries()) {
-    if (ticket.status === "error") {
-      const message = chunk[ticketIndex];
-      if (message) {
-        const tokens = extractTokensFromMessage(message);
-        if (ticket.details?.error === "DeviceNotRegistered") {
-          failedTokens.push(...tokens);
-        }
-        console.log("Push notification error", {
-          error: ticket.details?.error,
-          tokens
-        });
-      }
-    } else {
-      successCount++;
-    }
-  }
-  return { failedTokens, successCount };
-}
-async function sendChunk(chunk, chunkIndex) {
-  try {
-    const tickets = await expo.sendPushNotificationsAsync(chunk);
-    const { successCount, failedTokens } = processChunkResults(tickets, chunk);
-    console.log(
-      `Chunk ${chunkIndex + 1}: Sent ${successCount}/${chunk.length} notifications successfully`
-    );
-    return { failedTokens, successCount };
-  } catch (error) {
-    console.log("Error sending Expo push notification chunk", {
-      chunkIndex,
-      chunkSize: chunk.length,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return { failedTokens: [], successCount: 0 };
-  }
-}
-async function sendPushNotifications({
-  data,
-  message,
-  title,
-  userIds
-}) {
-  const pushTokens = await PushTokenModel.find({ userId: { $in: userIds } });
-  const expoTokens = pushTokens.map((token) => token.token);
-  if (!data) return;
-  const { messages, invalidTokens } = createPushMessages({
-    data,
-    message,
-    title,
-    tokens: expoTokens
-  });
-  if (invalidTokens.length > 0) {
-    console.log(`Found ${invalidTokens.length} invalid push tokens`);
-  }
-  if (messages.length === 0) {
-    console.log("No valid messages to send after filtering tokens");
-    return;
-  }
-  const chunks = expo.chunkPushNotifications(messages);
-  let totalSuccessCount = 0;
-  const allFailedTokens = [];
-  for (const [chunkIndex, chunk] of chunks.entries()) {
-    const { successCount, failedTokens } = await sendChunk(
-      chunk,
-      chunkIndex + 1
-    );
-    totalSuccessCount += successCount;
-    allFailedTokens.push(...failedTokens);
-  }
-  console.log(
-    `Sent push notification to ${totalSuccessCount}/${messages.length} tokens across ${chunks.length} chunks`
-  );
-  if (allFailedTokens.length > 0) {
-    console.log(`Found ${allFailedTokens.length} failed push tokens`);
-  }
-}
-
 // src/storage/index.ts
 var SAVED_PASSWORD_KEY = "savedPassword";
 var SAVED_EMAIL_KEY = "savedEmail";
@@ -7292,11 +6203,18 @@ var fonts = {
     fontWeight: "400"
   }
 };
+
+// src/types/resourceActivities.ts
+var EnumActivity = /* @__PURE__ */ ((EnumActivity2) => {
+  EnumActivity2["FAVORITE"] = "FAVORITE";
+  EnumActivity2["GOING"] = "GOING";
+  EnumActivity2["INTERESTED"] = "INTERESTED";
+  EnumActivity2["PRESENT"] = "PRESENT";
+  EnumActivity2["VIEW"] = "VIEW";
+  return EnumActivity2;
+})(EnumActivity || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AdModel,
-  CategorySchema,
-  ChatModel,
   EnumActivity,
   EnumAdShowOn,
   EnumAdStatus,
@@ -7310,7 +6228,6 @@ var fonts = {
   EnumNotificationType,
   EnumOSPlatform,
   EnumPaymentMethod,
-  EnumPubSubEvents,
   EnumRegions,
   EnumRelationResource,
   EnumResourceType,
@@ -7318,38 +6235,20 @@ var fonts = {
   EnumUserLicence,
   EnumUserRole,
   EnumVendorType,
-  EventInfoModel,
-  EventModel,
   ImageTypeEnum,
-  NotificationModel,
-  ParticipantSchema,
-  PushTokenModel,
-  RelationModel,
-  RelationTypeSchema,
-  ResourceActivityModel,
-  ResourceImageTypeSchema,
   SAVED_EMAIL_KEY,
   SAVED_PASSWORD_KEY,
   SAVED_REFRESH_TOKEN_KEY,
   SAVED_TOKEN_KEY,
-  SocialMediaTypeSchema,
-  StallTypeSchema,
-  TesterModel,
   USER_STORAGE_KEY,
-  UserModel,
-  VendorInfoModel,
-  VendorModel,
-  VerificationTokenModel,
   availableCategories,
   availableCityOptions,
   availableRegionOptions,
   availableRegionTypes,
   availableTagTypes,
-  baseResourceFields,
   capitalizeFirstLetter,
   categoryColors,
   companyContactFields,
-  connectToDatabase,
   contactUsFields,
   darkColors,
   dateFormat,
@@ -7375,28 +6274,22 @@ var fonts = {
   loginFields,
   mapArrayToOptions,
   mapBaseResourceTypeToFormData,
-  mongoose,
   normalizeUrl,
   packagingOptions,
-  partnersSchema,
   paymentMethodOptions,
   producedIngOptions,
   productLabelGroups,
   profileFields,
   registerFields,
-  relationDatesSchema,
   removeTypename,
   requestPasswordResetFields,
   requirementsOptions,
   resetPasswordFields,
-  saveNotificationsInDb,
-  sendPushNotifications,
   socialMediaFields,
   sortDatesChronologically,
   stallTypeOptions,
   statusOptions,
   tagOptions,
-  termsAgreementSchema,
   testersFields,
   timeFormat,
   truncateText,