Task Name: "Create Router for Auth Controller" 
			Description: "Generate a router for the auth controller and ensure all necessary parameters are received in the router."
			Requirements:
			1. Database: 
			2. Output needed: Return only the router code with necessary parameter checks and imports.
	       
			3. Tasks to implement: Create a router for auth controller., 
Ensure all APIs receive necessary parameters in the router., 
Import controller from '../controller/authController'., 
Set isImport to true., 
Add readSupportFile: file: authController.js, folder: src/controllers.
	
			4. Supporting data 
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');
const User = require('../models/User');
const sendMail = require('../utils/sendMail');
exports.registerUser = async (req, res) => {
    try {
        const { name, email, password, role } = req.body;

        // Validate input
        if (!name || !email || !password) {
            return res.status(400).json({ error: 'Name, email, and password are required fields.' });
        }

        // Check if user already exists
        const existingUser = await User.findOne({ email });
        if (existingUser) {
            return res.status(409).json({ error: 'Email is already registered.' });
        }

        // Hash the password
        const hashedPassword = await bcrypt.hash(password, 10);

        // Create a new user object
        const newUser = new User({
            name,
            email,
            password: hashedPassword,
            role: role || 'Team Member'  // Default role
        });

        // Save the user to the database
        await newUser.save();

        // Send verification email
        await sendMail(email, 'Verify your email', 'Please verify your email address by clicking on the link.');

        // Send success response
        res.status(201).json({ message: 'Registration successful! A verification email has been sent.' });
    } catch (error) {
        // Handle errors
        console.error('Error during registration:', error);
        res.status(500).json({ error: 'An error occurred during the registration process.' });
    }
};

// const bcrypt = require('bcrypt');
// const User = require('../models/User');  // Assuming User is a mongoose model
// const sendMail = require('../utils/sendEmail');
exports.userLogin = async (email, password) => {
    try {
        // Check if email and password are provided
        if (!email || !password) {
            throw new Error('Email and password must be provided');
        }

        // Find the user by email
        const user = await User.findOne({ email: email });
        if (!user) {
            throw new Error('Invalid email or password');
        }

        // Compare the provided password with the stored hashed password
        const isPasswordMatch = await bcrypt.compare(password, user.password);
        if (!isPasswordMatch) {
            throw new Error('Invalid email or password');
        }
        
        // Check if the user's email is verified
        if (!user.isVerified) {
            // Send verification email using sendMail function
            const verificationLink = `http://example.com/verify-email?token=${user.verificationToken}`;
            await sendMail(user.email, 'Email Verification', `Please verify your email by clicking the following link: ${verificationLink}`);
            
            return { success: false, message: 'Email verification required. Verification email has been sent to your email address.' };
        }

        // Respond with a success message if login is successful
        return { success: true, message: 'Login successful!' };

    } catch (error) {
        // Handle errors and respond with appropriate messages
        return { success: false, message: error.message };
    }
};

exports.userLogin = async (req, res) => {
    try {
        // Destructure email and password from the request body
        const { email, password } = req.body;

        // Check for missing fields
        if (!email || !password) {
            return res.status(400).json({ message: 'Email and password are required.' });
        }

        // Find user by email
        const user = await User.findOne({ email });

        // If user doesn't exist
        if (!user) {
            return res.status(401).json({ message: 'Invalid credentials.' });
        }

        // Compare hashed password with the provided password
        const isMatch = await bcrypt.compare(password, user.password);

        // If password doesn't match
        if (!isMatch) {
            return res.status(401).json({ message: 'Invalid credentials.' });
        }

        // Check if the user's email is verified
        if (!user.isVerified) {
            // If not verified, send a verification email
            await sendMail(user.email, 'Please verify your email address.');

            return res.status(403).json({
                message: 'Please verify your email address. Verification email has been sent.',
            });
        }

        // Generate a JWT token
        const token = jwt.sign({ userId: user._id }, process.env.JWT_SECRET, {
            expiresIn: '1h',
        });

        // Respond with a success message and token
        res.status(200).json({
            message: 'Login successful!',
            token,
            userDetails: {
                email: user.email,
                name: user.name,
            },
        });
    } catch (error) {
        // Handle any database or server errors
        res.status(500).json({ message: 'Server error. Please try again.' });
    }
};

			
		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');`  in this formate
```dependencies
const bcrypt = require('bcrypt');
```

Ensure this format is consistently followed in responses.