@timardex/cluemart-shared 1.2.34 → 1.2.36

package/dist/index.mjs

@@ -4691,7 +4691,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({
@@ -4764,21 +4764,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({
@@ -4958,7 +4958,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) {
@@ -5928,1067 +5928,6 @@ function useAdForm(data) {
   };
 }
 
-// src/mongoose/Ad.ts
-import mongoose5 from "mongoose";
-
-// src/types/global.ts
-import mongoose from "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
-import mongoose4 from "mongoose";
-
-// src/mongoose/Relation.ts
-import mongoose3 from "mongoose";
-
-// src/mongoose/event/EventInfo.ts
-import mongoose2 from "mongoose";
-var MongooseSchema = mongoose2.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: mongoose2.Schema.Types.ObjectId
-    },
-    packInTime: { required: true, type: Number },
-    paymentDueHours: { required: true, type: Number },
-    paymentInfo: [paymentInfoSchema2],
-    requirements: [requirementsSchema]
-  },
-  { timestamps: true }
-);
-var EventInfoModel = mongoose2.models.EventInfo || mongoose2.model("EventInfo", schema);
-
-// src/mongoose/Relation.ts
-var MongooseSchema2 = mongoose3.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: mongoose3.Schema.Types.ObjectId
-    },
-    deletedAt: { default: null, required: false, type: Date },
-    eventId: {
-      ref: "Event",
-      required: true,
-      type: mongoose3.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: mongoose3.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-RelationTypeSchema.index({
-  "relationDates.startDate": 1,
-  "relationDates.startTime": 1,
-  "relationDates.status": 1
-});
-var RelationModel = mongoose3.models.Relation || mongoose3.model("Relation", RelationTypeSchema);
-
-// src/mongoose/global.ts
-var MongooseSchema3 = mongoose4.Schema;
-var OwnerTypeSchema = new MongooseSchema3(
-  {
-    email: { required: true, type: String },
-    userId: {
-      ref: "User",
-      required: true,
-      type: mongoose4.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: mongoose4.Schema.Types.ObjectId
-    }
-  },
-  { _id: false }
-);
-var baseResourceFields = {
-  active: { default: false, required: true, type: Boolean },
-  adIds: {
-    ref: "Ad",
-    required: false,
-    type: [mongoose4.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 = mongoose5.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 = mongoose5.models.Ad || mongoose5.model("Ad", schema2);
-
-// src/mongoose/Chat.ts
-import mongoose6 from "mongoose";
-var MongooseSchema5 = mongoose6.Schema;
-var MessageSchema = new MongooseSchema5(
-  {
-    content: { required: true, type: String },
-    senderAvatar: { required: false, type: String },
-    senderId: {
-      ref: "User",
-      required: true,
-      type: mongoose6.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: mongoose6.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: mongoose6.Schema.Types.ObjectId
-      },
-      vendorId: {
-        ref: "Vendor",
-        required: false,
-        type: mongoose6.Schema.Types.ObjectId
-      }
-    }
-  },
-  {
-    timestamps: true
-  }
-);
-var ChatModel = mongoose6.models.Chat || mongoose6.model("Chat", ChatSchema);
-
-// src/mongoose/Notification.ts
-import mongoose7 from "mongoose";
-var MongooseSchema6 = mongoose7.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: mongoose7.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-schema3.index({ isRead: 1, userId: 1 });
-schema3.index({ createdAt: -1, userId: 1 });
-var NotificationModel = mongoose7.models.Notification || mongoose7.model("Notification", schema3);
-
-// src/mongoose/PushToken.ts
-import mongoose8 from "mongoose";
-var MongooseSchema7 = mongoose8.Schema;
-var schema4 = new MongooseSchema7(
-  {
-    platform: {
-      enum: Object.values(EnumOSPlatform),
-      required: true,
-      type: String
-    },
-    token: { required: true, type: String },
-    userId: { required: true, type: mongoose8.Schema.Types.ObjectId }
-  },
-  { timestamps: true }
-);
-var PushTokenModel = mongoose8.models.PushToken || mongoose8.model("PushToken", schema4);
-
-// src/mongoose/ResourceActivity.ts
-import mongoose9 from "mongoose";
-var MongooseSchema8 = mongoose9.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 = mongoose9.models.ResourceActivity || mongoose9.model("ResourceActivity", schema5);
-
-// src/mongoose/Testers.ts
-import mongoose10 from "mongoose";
-var MongooseSchema9 = mongoose10.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 = mongoose10.models.Tester || mongoose10.model("Tester", TesterSchema);
-
-// src/mongoose/User.ts
-import mongoose11 from "mongoose";
-var MongooseSchema10 = mongoose11.Schema;
-var userActivityEventSchema = new MongooseSchema10(
-  {
-    resourceId: {
-      ref: "Event",
-      required: false,
-      type: mongoose11.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: [mongoose11.Schema.Types.ObjectId]
-    },
-    vendors: {
-      ref: "Vendor",
-      required: false,
-      type: [mongoose11.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: [mongoose11.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: mongoose11.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-schema6.index({ "partners.email": 1 });
-var UserModel = mongoose11.models.User || mongoose11.model("User", schema6);
-
-// src/mongoose/VerificationToken.ts
-import mongoose12 from "mongoose";
-var MongooseSchema11 = mongoose12.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 = mongoose12.models.VerificationToken || mongoose12.model("VerificationToken", schema7);
-
-// src/mongoose/vendor/Vendor.ts
-import mongoose13 from "mongoose";
-var MongooseSchema12 = mongoose13.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: mongoose13.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 = mongoose13.models.Vendor || mongoose13.model("Vendor", schema8);
-
-// src/mongoose/vendor/VendorInfo.ts
-import mongoose14 from "mongoose";
-var MongooseSchema13 = mongoose14.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: mongoose14.Schema.Types.ObjectId
-    }
-  },
-  { timestamps: true }
-);
-var VendorInfoModel = mongoose14.models.VendorInfo || mongoose14.model("VendorInfo", schema9);
-
-// src/mongoose/event/Event.ts
-import mongoose15 from "mongoose";
-var MongooseSchema14 = mongoose15.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: mongoose15.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 = mongoose15.models.Event || mongoose15.model("Event", schema10);
-
-// src/service/database.ts
-import mongoose16 from "mongoose";
-
-// src/service/timezonePlugin.ts
-import dayjs3 from "dayjs";
-import timezone2 from "dayjs/plugin/timezone";
-import utc2 from "dayjs/plugin/utc";
-dayjs3.extend(utc2);
-dayjs3.extend(timezone2);
-function timezonePlugin(schema11) {
-  if (!schema11.get("timestamps")) return;
-  const transform = (_doc, ret) => {
-    if (ret.createdAt)
-      ret.createdAt = dayjs3(ret.createdAt).tz("Pacific/Auckland").format();
-    if (ret.updatedAt)
-      ret.updatedAt = dayjs3(ret.updatedAt).tz("Pacific/Auckland").format();
-    return ret;
-  };
-  schema11.set("toJSON", { transform });
-  schema11.set("toObject", { transform });
-}
-
-// src/service/database.ts
-mongoose16.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 mongoose16.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
-import { Expo } from "expo-server-sdk";
-var expo = new 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 (!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";
@@ -7033,10 +5972,17 @@ 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 || {});
 export {
-  AdModel,
-  CategorySchema,
-  ChatModel,
   EnumActivity,
   EnumAdShowOn,
   EnumAdStatus,
@@ -7050,7 +5996,6 @@ export {
   EnumNotificationType,
   EnumOSPlatform,
   EnumPaymentMethod,
-  EnumPubSubEvents,
   EnumRegions,
   EnumRelationResource,
   EnumResourceType,
@@ -7058,38 +6003,20 @@ export {
   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,
@@ -7115,28 +6042,22 @@ export {
   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,