@mac777/project-pinecone-models 1.0.0

package/dist/Event.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const mediaSchema = new mongoose_1.default.Schema({
+    coverImage: {
+        url: String,
+        thumbnailUrl: String,
+        alt: String,
+    },
+    gallery: [{
+            url: String,
+            caption: String,
+            order: Number,
+        }],
+}, { _id: false });
+const addressSchema = new mongoose_1.default.Schema({
+    street: String,
+    city: { type: String, required: true },
+    state: String,
+    postalCode: String,
+    country: { type: String, required: true },
+}, { _id: false });
+const venueSchema = new mongoose_1.default.Schema({
+    name: { type: String, required: true },
+    address: addressSchema,
+    coordinates: {
+        type: {
+            type: String,
+            enum: ['Point'],
+            default: 'Point'
+        },
+        coordinates: [Number] // [lng, lat]
+    },
+    capacity: { type: Number, required: true, min: 10, max: 100000 },
+    type: { type: String, enum: ['indoor', 'outdoor', 'hybrid'] },
+    parking: Boolean,
+    publicTransit: String,
+}, { _id: false });
+const contactPersonSchema = new mongoose_1.default.Schema({
+    name: { type: String, required: true },
+    phone: { type: String, required: true },
+    email: { type: String, required: true },
+    designation: String,
+}, { _id: false });
+const organizerSchema = new mongoose_1.default.Schema({
+    role: { type: String, enum: ['event_organizer', 'venue_owner', 'authorized_rep', 'artist'] },
+    companyName: String,
+    contactPerson: contactPersonSchema,
+}, { _id: false });
+const documentSchema = new mongoose_1.default.Schema({
+    type: { type: String, enum: ['venue_booking', 'permit', 'insurance', 'license', 'portfolio', 'other'] },
+    url: String,
+    filename: String,
+    objectKey: String,
+    uploadedAt: Date,
+    status: { type: String, enum: ['pending', 'approved', 'rejected'] },
+    rejectionReason: String,
+}, { _id: false });
+const verificationSchema = new mongoose_1.default.Schema({
+    status: { type: String, enum: ['unverified', 'pending', 'verified', 'rejected', 'needs_info'], default: 'unverified' },
+    documents: [documentSchema],
+    additionalInfo: String,
+    adminNotes: String,
+    reviewedBy: mongoose_1.default.Schema.Types.ObjectId,
+    reviewedAt: Date,
+    rejectionReason: String,
+    requestedInfo: String,
+}, { _id: false });
+const priceSchema = new mongoose_1.default.Schema({
+    amount: { type: Number, required: true },
+    currency: { type: String, default: 'USD' },
+}, { _id: false });
+const salesWindowSchema = new mongoose_1.default.Schema({
+    startDate: Date,
+    endDate: Date,
+}, { _id: false });
+const limitsSchema = new mongoose_1.default.Schema({
+    minPerOrder: { type: Number, default: 1 },
+    maxPerOrder: { type: Number, default: 10 },
+}, { _id: false });
+const ticketSchema = new mongoose_1.default.Schema({
+    name: { type: String, required: true },
+    description: String,
+    price: priceSchema,
+    quantity: { type: Number, required: true },
+    sold: { type: Number, default: 0 },
+    remaining: { type: Number, default: function () { return this.quantity - this.sold; } },
+    salesWindow: salesWindowSchema,
+    limits: limitsSchema,
+    visibility: { type: String, enum: ['public', 'hidden', 'invite_only'], default: 'public' },
+    reserved: { type: Number, default: 0 },
+    status: { type: String, enum: ['active', 'sold_out', 'inactive'], default: 'active' },
+    benefits: [String],
+    tier: { type: String, enum: ['early_bird', 'regular', 'vip'] },
+});
+const scheduleSchema = new mongoose_1.default.Schema({
+    startDate: { type: Date, required: true },
+    endDate: { type: Date, required: true },
+    timezone: String,
+    isMultiDay: Boolean,
+    doors: String,
+}, { _id: false });
+const metricsSchema = new mongoose_1.default.Schema({
+    views: { type: Number, default: 0 },
+    ticketsSold: { type: Number, default: 0 },
+    revenue: { type: Number, default: 0 },
+    checkIns: { type: Number, default: 0 },
+    averageRating: Number,
+    reviewCount: { type: Number, default: 0 },
+}, { _id: false });
+const pricingSchema = new mongoose_1.default.Schema({
+    platformFee: { type: Number, default: 5 },
+    paymentProcessingFee: Number,
+    currency: String,
+}, { _id: false });
+const payoutSchema = new mongoose_1.default.Schema({
+    status: { type: String, enum: ['pending', 'scheduled', 'completed'] },
+    amount: Number,
+    scheduledDate: Date,
+    paidAt: Date,
+    stripePayoutId: String,
+}, { _id: false });
+const cancellationSchema = new mongoose_1.default.Schema({
+    allowed: { type: Boolean, default: true },
+    refundPercentage: { type: Number, default: 100 },
+    deadlineHours: Number,
+}, { _id: false });
+const policiesSchema = new mongoose_1.default.Schema({
+    cancellation: cancellationSchema,
+    transferable: { type: Boolean, default: false },
+}, { _id: false });
+const flagSchema = new mongoose_1.default.Schema({
+    reportedBy: mongoose_1.default.Schema.Types.ObjectId,
+    reason: String,
+    description: String,
+    createdAt: { type: Date, default: Date.now },
+    status: { type: String, enum: ['pending', 'resolved', 'dismissed'], default: 'pending' },
+}, { _id: false });
+const moderationSchema = new mongoose_1.default.Schema({
+    isFlagged: { type: Boolean, default: false },
+    flags: [flagSchema],
+    suspendedUntil: Date,
+    banReason: String,
+}, { _id: false });
+const seoSchema = new mongoose_1.default.Schema({
+    metaTitle: String,
+    metaDescription: String,
+    keywords: [String],
+    ogImage: String,
+}, { _id: false });
+const featuresSchema = new mongoose_1.default.Schema({
+    isFeatured: { type: Boolean, default: false },
+    isPremium: { type: Boolean, default: false },
+    badges: [String],
+}, { _id: false });
+const historySchema = new mongoose_1.default.Schema({
+    action: String,
+    performedBy: mongoose_1.default.Schema.Types.ObjectId,
+    timestamp: { type: Date, default: Date.now },
+    changes: mongoose_1.default.Schema.Types.Mixed,
+}, { _id: false });
+const eventSchema = new mongoose_1.default.Schema({
+    hostId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true },
+    slug: String,
+    // STEP 1: BASICS
+    title: { type: String, required: true, minlength: 10, maxlength: 100 },
+    type: { type: String, enum: ['concert', 'sports', 'conference', 'festival', 'theater', 'comedy', 'networking', 'workshop', 'other'], required: true },
+    categories: [{ type: String }],
+    tagline: { type: String, maxlength: 150 },
+    // STEP 2: DETAILS
+    description: { type: String, minlength: 50, maxlength: 5000 },
+    highlights: [{ type: String }],
+    languages: [String],
+    ageRestriction: { type: String, enum: ['all_ages', '18+', '21+'] },
+    dressCode: String,
+    media: mediaSchema,
+    // STEP 3: DATE, TIME & LOCATION
+    schedule: scheduleSchema,
+    venue: venueSchema,
+    // STEP 4: VERIFICATION
+    organizer: organizerSchema,
+    verification: verificationSchema,
+    // STEP 5: TICKETS
+    tickets: [ticketSchema],
+    termsAccepted: { type: Boolean, default: false },
+    legalPermissionAccepted: { type: Boolean, default: false },
+    platformTermsAccepted: { type: Boolean, default: false },
+    // STATUS & WORKFLOW
+    status: { type: String, enum: ['draft', 'pending_approval', 'approved', 'rejected', 'published', 'live', 'ended', 'cancelled'], default: 'draft' },
+    rejectionReason: String,
+    visibility: { type: String, enum: ['public', 'private', 'unlisted'], default: 'public' },
+    publishedAt: Date,
+    // METRICS
+    metrics: metricsSchema,
+    // BUSINESS
+    pricing: pricingSchema,
+    payout: payoutSchema,
+    // POLICIES
+    policies: policiesSchema,
+    // MODERATION
+    moderation: moderationSchema,
+    // SEO
+    seo: seoSchema,
+    // FEATURES
+    features: featuresSchema,
+    // AUDIT
+    createdAt: { type: Date, default: Date.now },
+    updatedAt: { type: Date, default: Date.now },
+    submittedAt: Date,
+    history: [historySchema],
+    deletedAt: Date,
+});
+// Indexes
+eventSchema.index({ slug: 1 });
+eventSchema.index({ 'venue.coordinates': '2dsphere' });
+eventSchema.index({ status: 1, visibility: 1 });
+eventSchema.index({ hostId: 1 });
+eventSchema.index({ 'schedule.startDate': 1 });
+eventSchema.index({ type: 1 });
+eventSchema.index({ categories: 1 });
+// Validation: sum(tickets.quantity) <= venue.capacity
+eventSchema.pre('save', function (next) {
+    if (this.tickets && this.tickets.length > 0 && this.venue) {
+        const totalCapacity = this.tickets.reduce((sum, ticket) => sum + ticket.quantity, 0);
+        if (totalCapacity > this.venue.capacity) {
+            return next(new Error('Total ticket quantity exceeds venue capacity'));
+        }
+    }
+    next();
+});
+// Update updatedAt on save
+eventSchema.pre('save', function (next) {
+    this.updatedAt = new Date();
+    next();
+});
+exports.default = eventSchema;

package/dist/Media.d.ts

@@ -0,0 +1,58 @@
+import mongoose from 'mongoose';
+declare const mediaSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    type: "event_cover" | "event_gallery" | "verification_doc";
+    filename: string;
+    uploadedAt: NativeDate;
+    status: "temp" | "permanent" | "deleted";
+    userId: mongoose.Types.ObjectId;
+    provider: "imagekit" | "backblaze";
+    mimeType: string;
+    url?: string | null | undefined;
+    thumbnailUrl?: string | null | undefined;
+    objectKey?: string | null | undefined;
+    deletedAt?: NativeDate | null | undefined;
+    fileId?: string | null | undefined;
+    bucketName?: string | null | undefined;
+    movedToPermanentAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+    size?: number | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    type: "event_cover" | "event_gallery" | "verification_doc";
+    filename: string;
+    uploadedAt: NativeDate;
+    status: "temp" | "permanent" | "deleted";
+    userId: mongoose.Types.ObjectId;
+    provider: "imagekit" | "backblaze";
+    mimeType: string;
+    url?: string | null | undefined;
+    thumbnailUrl?: string | null | undefined;
+    objectKey?: string | null | undefined;
+    deletedAt?: NativeDate | null | undefined;
+    fileId?: string | null | undefined;
+    bucketName?: string | null | undefined;
+    movedToPermanentAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+    size?: number | null | undefined;
+}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    type: "event_cover" | "event_gallery" | "verification_doc";
+    filename: string;
+    uploadedAt: NativeDate;
+    status: "temp" | "permanent" | "deleted";
+    userId: mongoose.Types.ObjectId;
+    provider: "imagekit" | "backblaze";
+    mimeType: string;
+    url?: string | null | undefined;
+    thumbnailUrl?: string | null | undefined;
+    objectKey?: string | null | undefined;
+    deletedAt?: NativeDate | null | undefined;
+    fileId?: string | null | undefined;
+    bucketName?: string | null | undefined;
+    movedToPermanentAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+    size?: number | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default mediaSchema;

package/dist/Media.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const mediaSchema = new mongoose_1.default.Schema({
+    userId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true },
+    type: { type: String, enum: ['event_cover', 'event_gallery', 'verification_doc'], required: true },
+    provider: { type: String, enum: ['imagekit', 'backblaze'], required: true },
+    status: { type: String, enum: ['temp', 'permanent', 'deleted'], required: true },
+    // ImageKit specific
+    fileId: String,
+    url: String,
+    thumbnailUrl: String,
+    // Backblaze specific
+    bucketName: String,
+    objectKey: String,
+    // Metadata
+    filename: { type: String, required: true },
+    mimeType: { type: String, required: true },
+    size: { type: Number, required: false },
+    // Lifecycle
+    uploadedAt: { type: Date, default: Date.now },
+    movedToPermanentAt: Date,
+    expiresAt: Date, // For temp files
+    deletedAt: Date,
+});
+// Indexes
+mediaSchema.index({ userId: 1 });
+mediaSchema.index({ status: 1 });
+mediaSchema.index({ expiresAt: 1 });
+mediaSchema.index({ uploadedAt: 1 });
+exports.default = mediaSchema;

package/dist/Order.d.ts

@@ -0,0 +1,172 @@
+import mongoose from 'mongoose';
+declare const orderSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    createdAt: NativeDate;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    expiresAt: NativeDate;
+    userId: mongoose.Types.ObjectId;
+    orderNumber: string;
+    eventId: mongoose.Types.ObjectId;
+    requiresManualReview: boolean;
+    manualReviewReason: string;
+    paymentMethod: "card" | "bkash" | "bank_transfer";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    ticketIds: mongoose.Types.ObjectId[];
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
+    pricing?: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    } | null | undefined;
+    refundedAt?: NativeDate | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    refund?: {
+        amount: number;
+        reason: "event_cancelled" | "user_request" | "fraud";
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+    paymentId?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    expiresAt: NativeDate;
+    userId: mongoose.Types.ObjectId;
+    orderNumber: string;
+    eventId: mongoose.Types.ObjectId;
+    requiresManualReview: boolean;
+    manualReviewReason: string;
+    paymentMethod: "card" | "bkash" | "bank_transfer";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    ticketIds: mongoose.Types.ObjectId[];
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
+    pricing?: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    } | null | undefined;
+    refundedAt?: NativeDate | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    refund?: {
+        amount: number;
+        reason: "event_cancelled" | "user_request" | "fraud";
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+    paymentId?: string | null | undefined;
+}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    expiresAt: NativeDate;
+    userId: mongoose.Types.ObjectId;
+    orderNumber: string;
+    eventId: mongoose.Types.ObjectId;
+    requiresManualReview: boolean;
+    manualReviewReason: string;
+    paymentMethod: "card" | "bkash" | "bank_transfer";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    ticketIds: mongoose.Types.ObjectId[];
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
+    pricing?: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    } | null | undefined;
+    refundedAt?: NativeDate | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    refund?: {
+        amount: number;
+        reason: "event_cancelled" | "user_request" | "fraud";
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+    paymentId?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default orderSchema;

package/dist/Order.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+// Order Ticket Schema
+const orderTicketSchema = new mongoose_1.default.Schema({
+    ticketVariantId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        required: true
+    },
+    variantName: {
+        type: String,
+        required: true
+    },
+    quantity: {
+        type: Number,
+        required: true,
+        min: 1
+    },
+    pricePerTicket: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    subtotal: {
+        type: Number,
+        required: true,
+        min: 0
+    }
+}, { _id: false });
+// Pricing Schema
+const pricingSchema = new mongoose_1.default.Schema({
+    subtotal: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    platformFee: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    paymentFee: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    total: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    currency: {
+        type: String,
+        required: true,
+        default: 'BDT'
+    },
+    hostPayout: {
+        type: Number,
+        required: true,
+        min: 0
+    }
+}, { _id: false });
+// Refund Schema
+const refundSchema = new mongoose_1.default.Schema({
+    reason: {
+        type: String,
+        required: true,
+        enum: ['event_cancelled', 'user_request', 'fraud']
+    },
+    amount: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    refundedAt: {
+        type: Date,
+        default: Date.now
+    },
+    stripeRefundId: String
+}, { _id: false });
+// Main Order Schema
+const orderSchema = new mongoose_1.default.Schema({
+    orderNumber: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    // WHO
+    userId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        required: true,
+    },
+    // WHAT
+    eventId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        required: true,
+    },
+    paymentId: {
+        type: String,
+        required: false,
+    },
+    tickets: [orderTicketSchema],
+    // MONEY
+    pricing: pricingSchema,
+    // STATUS
+    status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'confirmed', 'cancelled', 'refunded'],
+        default: 'pending'
+    },
+    requiresManualReview: {
+        type: Boolean,
+        default: false
+    },
+    manualReviewReason: {
+        type: String,
+        default: null
+    },
+    paymentMethod: {
+        type: String,
+        required: true,
+        enum: ['card', 'bkash', 'bank_transfer']
+    },
+    paymentStatus: {
+        type: String,
+        required: true,
+        enum: ['pending', 'succeeded', 'failed'],
+        default: 'pending'
+    },
+    paidAt: Date,
+    // TICKETS ISSUED
+    ticketIds: [{
+            type: mongoose_1.default.Schema.Types.ObjectId,
+            ref: 'Ticket'
+        }],
+    // LIFECYCLE
+    createdAt: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    expiresAt: {
+        type: Date,
+        required: true
+    },
+    confirmedAt: Date,
+    cancelledAt: Date,
+    refundedAt: Date,
+    reminderSentAt: Date,
+    // CONTACT
+    buyerEmail: {
+        type: String,
+        required: true
+    },
+    buyerPhone: String,
+    // AUDIT
+    ipAddress: String,
+    userAgent: String,
+    // REFUND (if applicable)
+    refund: refundSchema
+});
+// Indexes for performance
+orderSchema.index({ userId: 1, createdAt: -1 });
+orderSchema.index({ eventId: 1, status: 1 });
+orderSchema.index({ status: 1, expiresAt: 1 });
+// Auto-generate order number
+orderSchema.pre('save', function (next) {
+    if (this.isNew && !this.orderNumber) {
+        const timestamp = Date.now().toString().slice(-6);
+        const random = Math.random().toString(36).substring(2, 8).toUpperCase();
+        this.orderNumber = `ORD-${timestamp}-${random}`;
+    }
+    next();
+});
+// Update updatedAt on save
+orderSchema.pre('save', function (next) {
+    // Note: We don't have updatedAt field, but could add if needed
+    next();
+});
+exports.default = orderSchema;