User:  
1  Follow this Booking schema model fields to create required response. 

Code : const mongoose = require('mongoose');
const Schema = mongoose.Schema;

// Define the Booking schema
const bookingSchema = new Schema({
  userId: {
    type: Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  hotelId: {
    type: Schema.Types.ObjectId,
    ref: 'Hotel',
    required: true
  },
  checkInDate: {
    type: Date,
    required: true
  },
  checkOutDate: {
    type: Date,
    required: true
  },
  numberOfPeople: {
    type: Number,
    required: true
  },
  totalPrice: {
    type: Number
  },
  status: {
    type: String,
    enum: ['confirmed', 'pending', 'canceled'],
    default: 'pending'
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

// Update the updatedAt field on document update
bookingSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

// Create and export the Booking model
const Booking = mongoose.model('Booking', bookingSchema);
module.exports = Booking;

User:  
2  Follow this Hotel schema model fields to create required response. 

Code : const mongoose = require('mongoose');
// Define the Hotel schema
const hotelSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'Hotel name is required']
  },
  location: {
    type: String,
    required: [true, 'Location is required']
  },
  roomType: {
    type: String,
    required: [true, 'Room type is required']
  },
  availability: {
    type: Boolean,
    default: true
  },
  amenities: {
    type: [String],
    default: []
  },
  pricePerNight: {
    type: Number,
    required: [true, 'Price per night is required'],
    validate: {
      validator: function(v) {
        return v > 0;
      },
      message: 'Price per night must be a positive number'
    }
  }
});

// Create a Hotel model
const Hotel = mongoose.model('Hotel', hotelSchema);

// Export the Hotel model
module.exports = Hotel;

User: Task Name: "Create Implement Waitlist Feature Api" 
		Description: "Generate a Node.js Waitlist Feature Api with given dependenceis"
		Requirements:
		1. Database: mongoose
		2. Output needed: Return only the function code as specified in dependencies

		3. Tasks to implement: Create a Api to add a user to the waitlist for a fully booked date. Export: exports.addToWaitlist = async () => {...}, 
Accept data from user body: userId, checkInDate, checkOutDate, hotelIds., 
Validate required fields: Ensure userId, checkInDate, checkOutDate, and hotelIds are provided., 
If the requested date is fully booked, add the user to the waitlist for that date., 
Store waitlist data with date, hotelIds, userId, and priority level., 
When a booking is canceled, notify users on the waitlist and offer the available slot., 
Respond to user with a success message confirming the user has been added to the waitlist., 
Handle errors like invalid dates, conflicting bookings, or database issues.

		4. Supporting data 
		
    Please generate the code for above tasks, following the instructions and including comments for clarity and logic for Dependencies must needed.

    While creating router for specifict file your have to read supporing file data and create for that 

    **Output Formats**: 

	Return dependencies like this `const bcrypt = require('bcrypt');` const Booking = require('./models/Booking'); in this formate
	```dependencies
	const bcrypt = require('bcrypt');
	const Booking = require('./models/Booking');

	```

	Ensure this format is consistently followed in responses.
    
Assistant: