text: console.clear()
  const Discord = require("discord.js");
  const chalk = require('chalk');
  const config = require(`./botconfig.js`)
  const prefix = config.prefix;
  
  
  //dont remove or edit this line
  console.log(chalk.red('=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+='))
    console.log(chalk.cyan(`Made by Tejas Lamba#1924`))
    console.log(chalk`{yellowBright Credits } | {blueBright Visa2Code} | {cyanBright https://discord.gg/vRQtfrAPJ3}`)
    console.log(`Join Above for Support!`)
    console.log(chalk.red('=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+='))
    //til here dont touch above anything
  if (config.ExpressServer) {
  const express = require('express')
  const app = express()
   
  app.get('/', function (req, res) {
    res.send({
    Working: "online"
    })
  })
   console.log(chalk.greenBright(`Web Server Started`))
  app.listen(3000)
  }
  
  const client = new Discord.Client({
     intents : [
       Discord.Intents.FLAGS.GUILDS ,
       Discord.Intents.FLAGS.GUILD_MEMBERS ,
       Discord.Intents.FLAGS.GUILD_BANS ,
       Discord.Intents.FLAGS.GUILD_EMOJIS_AND_STICKERS ,
       Discord.Intents.FLAGS.GUILD_INTEGRATIONS ,
       Discord.Intents.FLAGS.GUILD_WEBHOOKS ,
       Discord.Intents.FLAGS.GUILD_INVITES ,
       Discord.Intents.FLAGS.GUILD_VOICE_STATES ,
       Discord.Intents.FLAGS.GUILD_PRESENCES ,
       Discord.Intents.FLAGS.GUILD_MESSAGES ,
       Discord.Intents.FLAGS.GUILD_MESSAGE_REACTIONS ,
       Discord.Intents.FLAGS.GUILD_MESSAGE_TYPING ,
       Discord.Intents.FLAGS.DIRECT_MESSAGES , 
       Discord.Intents.FLAGS.DIRECT_MESSAGE_REACTIONS ,
       Discord.Intents.FLAGS.DIRECT_MESSAGE_TYPING ,
      //all intents require for bot to run
    ],
      allowedMentions: {
          parse: ["everyone", "roles", "users"],
          repliedUser: true
      },
      partials: ["CHANNEL", "GUILD_MEMBER", "MESSAGE", "REACTION", "USER"]
  
  });
  require("dotenv").config()
  
  const { Database } = require("quickmongo");
  const db = new Database(config.mongo)
  const randomstring = require("randomstring");
  
  let support = new Discord.MessageButton()
  .setStyle(`LINK`)
  .setLabel(`Support`)
  .setEmoji(`884336184438968320`)
  .setURL(`https://discord.gg/vRQtfrAPJ3`)
  
  let inviteme = new Discord.MessageButton()
  .setStyle(`LINK`)
  .setLabel(`Invite Me!`)
  .setEmoji(`884336555949428756`)
  .setURL(`https://discord.gg/vRQtfrAPJ3`)
  
  let globalbuttons = new Discord.MessageActionRow().addComponents(support, inviteme)
  
  //parse users tag and convert it to a channelName
  function getChannelName(user) {
   const user1 = `${user.username}#${user.discriminator}`
  
    let value = user1.replace("#", "-").toLowerCase();
    
    value = value.replace(/ /g, "-");
    return value;
  }
  
  //checks if a ticket is already open
  function hasTicket(g, interaction) {
    let channelName = getChannelName(interaction.user);
    let ticket = g.channels.cache.find((ch) => ch.name == channelName);
    if (ticket) {
      interaction.editReply({ content: `You already have a ticket. <#${ticket.id}>`})
      return true;
    } else {
      return false;
    }
  }
  
  
  
  async function checktoken(token){
    if (!token) {
         console.log(chalk.redBright(`NO TOKEN PROVIDED`))
        process.exit()
      }
      
      if(token.length != "NzQ4MDg3OTA3NTE2MTUzODg5.X0YVJw.Wk6lEEwy158ZQ3wvKx3uvdnoWGA".length) {
        console.log(chalk.redBright(`INAVLID TOKEN`))
        process.exit()
      }
      
    let testclient = new Discord.Client({
     intents : [
       Discord.Intents.FLAGS.DIRECT_MESSAGE_TYPING ,
    ]
  });
    try {
      await testclient.login(token)
      testclient.on("ready", () => testclient.destroy() )
      
     
      
    } catch {
      console.log(chalk.redBright("INVALID TOKEN"))
      process.exit()
    }
  }
  checktoken(config.token)
  
  
  
  async function configcheck(config) {
    if (!config.prefix) {
      console.log(chalk.redBright("Fill botconfig.js"))
      return true
      }
    if (!config.status.name) {
      console.log(chalk.redBright("Fill botconfig.js"))
      return true
      }
    if (!config.status.type) {
      console.log(chalk.redBright("Fill botconfig.js"))
      return true
      }
  }
  
  let goodconfig = configcheck(config)
  
  if(!goodconfig) {
     process.exit()
     return;
   }
   
  //-----------------Global Embeds--------------\\
  
  
  const sfatsembed = new Discord.MessageEmbed()
      .setDescription(`this server needs to set up their staff roles first! \`${prefix}setstaff\``)
      .setColor(0x5865F2)
  
  const channelsetup = new Discord.MessageEmbed()
      .setDescription(`This server needs to set up their ticket channels first! \`${prefix}setchannels\``)
      .setColor(0x5865F2)
  
      const colldown1 = new Discord.MessageEmbed()
          .setDescription(`Your order is executed after 5 seconds, and it will be closed`)
          .setColor(0x5865F2)
  
  
  
  client.on('ready', async () => {
    console.log(chalk.greenBright(`Token Working`))
      console.log(chalk.greenBright(`Logging in to bot...`))
    
    console.log(chalk.bgRed(chalk.greenBright(`Logged into ${client.user.username}`)))
  
    client.user.setActivity(config.status.name, { type: config.status.type.toUpperCase() })
  });
    
  
  client.on("messageCreate", async(message) =>{
    if (message.author.bot || !message.guild) return;
    let args = message.content.toLowerCase().split(" ");
    let command = args.shift()
    if (command == prefix + `help`) {
      let embed = new Discord.MessageEmbed()
        .setTitle(`Bot commands list`)
        .setDescription(`> \`${prefix}send\` - Send a message to open tickets
  > \`${prefix}add\` - Adds a member to a specific ticket
  > \`${prefix}remove\` - Removes a member to a specific ticket.
  > \`${prefix}delete\` - Delete a specific ticket
  > \`${prefix}close\` - Close a specific ticket
  > \`${prefix}open\` - Open a specific ticket
  > \`${prefix}rename\` - Rename a specific ticket
  > \`${prefix}setchannels\` - set channels relating to ticket log and category
  > \`${prefix}setstaff\` - set staff roles`)
  .addField(`My Source Code`, `[Click Me!]()`, false)
        .setTimestamp()
        .setColor(0x5865F2)
        .setFooter(`All rights belong to https://discord.gg/vRQtfrAPJ3`)
      message.reply({ embeds: [embed], components: [globalbuttons] })
  
      
    }
    if (command == prefix + `add`) {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({content: `:x: This command requires \`MANAGE_MESSAGES\` permission.`});
      let args = message.content.split(' ').slice(1).join(' ');
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
  
      
  
      if (!sfats) return message.reply({ embeds: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
        let member = message.mentions.members.first() || message.guild.members.cache.get(args || message.guild.members.cache.find(x => x.user.username === args || x.user.username === args));
        if (!member) return message.reply({ content: `Mention a member of its ID`});
        try {
          channel.updateOverwrite(member.user, {
            VIEW_CHANNEL: true,
            SEND_MESSAGES: true,
            ATTACH_FILES: true,
            READ_MESSAGE_HISTORY: true,
          }).then(() => {
            const sucess1 = new Discord.MessageEmbed()
      .setDescription(`${member} has been successfully added to ${channel}`)
      .setColor(0x5865F2)
            message.reply({ embed: [sucess1] });
  
          });
        }
        catch (e) {
          return message.channel.send({ content: `An error occurred, please try again!` });
        }
      }
    }
    if (command == prefix + `remove`) {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({ content: `:x: This command requires \`MANAGE_MESSAGES\` permission.` });
      let args = message.content.split(' ').slice(1).join(' ');
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
      if (!sfats) return message.reply({ embed: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
        let member = message.mentions.members.first() || message.guild.members.cache.get(args || message.guild.members.cache.find(x => x.user.username === args || x.user.username === args));
        if (!member) return message.reply({ content: `Mention a member of its ID`});
        try {
          channel.updateOverwrite(member.user, {
            VIEW_CHANNEL: false,
          }).then(() => {
  
  
            const removep = new Discord.MessageEmbed()
              .setDescription(`Successfully delete ${member} from ${channel}`)
              .setColor(0x5865F2)
  
            message.reply({ embeds: [removep] });
          });
        }
        catch (e) {
          return message.channel.send({content: `An error occurred, please try again!`});
        }
      }
    }
    if (command == prefix + 'delete') {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({content: `:x: This command requires \`MANAGE_MESSAGES\` permission.`});
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
      if (!sfats) return message.rply({ embed: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
          
        message.reply({ embeds: [colldown1] })
        setTimeout(async () => {
  
            channel.delete()
        }, 5000)
      }
    }
    if (command == prefix + 'close') {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({content: `:x: This command requires \`MANAGE_MESSAGES\` permission.`});
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
      if (!sfats) return message.reply({ embeds: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
        let msg = await message.reply({ embeds: [colldown1] })
        setTimeout(async () => {
          try {
            msg.delete()
            
            channel.send({ embed: { description: `Ticket has been closed by <@!${message.author.id}>`, color: `YELLOW` } })
            let type = 'member'
            await Promise.all(channel.permissionOverwrites.filter(o => o.type === type).map(o => o.delete()));
            channel.setName(`closed-${(await db.get(`ticket_${channel.id}_${message.guild.id}`))}`)
  
          } catch (e) {
            return message.channel.send({content: `An error occurred, please try again!`});
          }
        }, 1000)
      }
    }
  
    if (command == prefix + 'open') {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({content: `:x: This command requires \`MANAGE_MESSAGES\` permission.`});
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
      if (!sfats) return message.reply({ embeds: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
        let msg = await message.reply({ embeds: [colldown1] })
        setTimeout(async () => {
          try {
            msg.delete()
            channel.send({ embed: { description: `Ticket opened by <@!${message.author.id}>`, color: `GREEN` } })
            let meember = client.users.cache.get(await db.get(`ticket_${channel.id}_${message.guild.id}`).ticket_by);
            channel.updateOverwrite(meember, {
              VIEW_CHANNEL: true,
              SEND_MESSAGES: true,
              ATTACH_FILES: true,
              READ_MESSAGE_HISTORY: true,
            })
            channel.updateOverwrite((await db.get(`Staff_${message.guild.id}.Admin`)), {
              VIEW_CHANNEL: true,
              SEND_MESSAGES: true,
              ATTACH_FILES: true,
              READ_MESSAGE_HISTORY: true,
            })
            channel.updateOverwrite((await db.get(`Staff_${message.guild.id}.Moder`)), {
              VIEW_CHANNEL: true,
              SEND_MESSAGES: true,
              ATTACH_FILES: true,
              READ_MESSAGE_HISTORY: true,
            })
            channel.setName(`ticket-${await db.get(`ticket_${channel.id}_${message.guild.id}`).count}`)
  
          } catch (e) {
            return message.channel.send({ content: `An error occurred, please try again!` });
          }
        }, 1000)
      }
    }
    if (command == prefix + 'rename' || command == prefix + 'setname') {
      if (!message.member.permissions.has("MANAGE_GUILD")) return message.reply({content: `:x: This command requires \`MANAGE_MESSAGES\` permission.`});
      let channel = message.mentions.channels.first() || message.channel;
      const sfats = await db.get(`Staff_${message.guild.id}`)
      if (!sfats) return message.reply({ embeds: [sfatsembed] })
      if (await db.get(`ticket_${channel.id}_${message.guild.id}`)) {
        let args = message.content.split(' ').slice(1).join(' ');
        if (!args) return message.reply({ embed: { description: `Please select the name you want for the ticket`, color: 0x5865F2 } })
        channel.setName(args)
        message.delete()
  
      }
    }
    if (command == prefix + 'setstaff'){
      
      if (!message.member.permissions.has("ADMINISTRATOR")) return message.reply({ content: `:x: This command requires \`ADMINISTRATOR\` permission.`});
      if (args.length != 2) return message.reply({ embed: { description: `Please provide an Admin role id, *then* a Mod role id with this command! `, color: 0x5865F2 } })
      if (message.mentions.roles.length < 2 && !Number(args[0]) && !Number(args[1])) return message.reply({ embed: { description: `Please mention an Admin role (or iD) first, *then* a Mod role (or iD) with this command! `, color: 0x5865F2 } })
      const Admin = message.guild.roles.cache.get(args[0]);
      const Moder = message.guild.roles.cache.get(args[1]);
      await db.set(`Staff_${message.guild.id}.Admin`, Admin.id)
      await db.set(`Staff_${message.guild.id}.Moder`, Moder.id)
      message.react("✅")
    }
    if (command == prefix + 'setchannels'){
      if (!message.member.permissions.has('ADMINISTRATOR')) return message.reply({ content: `:x: This command requires \`ADMINISTRATOR\` permission.` });
      if (args.length != 1) return message.reply({ embed: { description: `Please mention a categoryid with this command! `, color: 0x5865F2 } })
      
     
      const cat = message.guild.channels.cache.get(args[0]);
    
      if (cat.type !== "GUILD_CATEGORY") return message.channel.send({ content: "The second input should be a text category"});
     
      await db.set(`Channels_${message.guild.id}.Cat`, cat.id)
      message.react("✅")
    }
  
    if (command == prefix + 'send' || command == prefix + 'ticket') {
      if (!message.member.permissions.has('ADMINISTRATOR')) return message.reply({ content: `:x: This command requires \`ADMINISTRATOR\` permission.` });
      const sfats = await db.get(`Staff_${message.guild.id}`) 
      const sfas = await db.get(`Channels_${message.guild.id}`)
      if (!sfats || sfats === null) return message.reply({ embeds: [sfatsembed] })
      if (!sfas || sfas === null) return message.reply({ embeds: [channelsetup] })
      let idd = randomstring.generate({ length: 20 })
      let args = message.content.split(' ').slice(1).join(' ');
      if (!args) args = `Tickets`
  
      let specialbtn = new Discord.MessageButton()
      .setStyle(`SECONDARY`)
      .setLabel('Special Support')
      .setEmoji(config.emojis.special)
      .setCustomId("ss")
  
  
      let genbtn = new Discord.MessageButton()
      .setStyle(`SECONDARY`)
      .setLabel('General Support')
      .setEmoji(config.emojis.general)
      .setCustomId("gs")
  
  
      let prizebtn = new Discord.MessageButton()
      .setStyle(`SECONDARY`)
      .setLabel('Giveaway Claim')
      .setEmoji(config.emojis.giveaway)
      .setCustomId("gc")
   
  
      let trow = new Discord.MessageActionRow().addComponents(specialbtn, genbtn, prizebtn)
  
      message.delete()
      
      let embed = new Discord.MessageEmbed()
        .setTitle(config.ticketembed.title)
        .setDescription(config.ticketembed.description)
        .setThumbnail(message.guild.iconURL())
        .setTimestamp()
        .setColor(0x5865F2)
        .setFooter(`${message.guild.name}-${config.ticketembed.footer}`, message.guild.iconURL())
      let msg = await message.channel.send({ 
        embeds: [embed], 
        components: [trow] 
        })
  
        msg.pin()
        
        
      
    }
  })
  //ephemeral
  client.on("interactionCreate", async (interaction) => {
  
  if(!interaction.isButton()) return;
  
  if (interaction.customId == `ss`) {
  
    await interaction.reply({ content: `Your ticket is being processed. Please wait `, ephemeral: true})
      if (hasTicket(interaction.guild, interaction)) {
        return;
      }
  
     
  
   
     interaction.guild.channels.create(getChannelName(interaction.user), {
          permissionOverwrites: [
            {
              id: interaction.guild.roles.everyone,
              deny: ['VIEW_CHANNEL'],
            },
            {
              id: (await db.get(`Staff_${interaction.guild.id}.Admin`)),
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`,`MANAGE_MESSAGES`],
            },
            {
              id: interaction.member.id,
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`],
            },
          ], parent: (await db.get(`Channels_${interaction.guild.id}.Cat`)), position: 1, topic: `${interaction.member.id}`, reason: "All rights reserved to Visa2Code"
        }).then(async channel => {
          channel = channel
          
        
          await interaction.editReply(`
    **Your ticket has been successfully opened** <#${channel.id}>`, true)
              
          const embedticket = new Discord.MessageEmbed()
            .setTimestamp()
            .setTitle("Specialised Support")
            .setFooter(`Ticket opened at`)
            .setColor(0x5865F2)
            .setDescription(`Support will be with you soon.\n
    To close this ticket, interact with 🔒`)
          
          let bu1tton = new Discord.MessageButton()
            .setStyle(`SECONDARY`)
            .setLabel('Close')
            .setCustomId(`cl`)
            .setEmoji(`🔒`)
            
            
          channel.send({ content: `Welcome <@!${interaction.member.user.id}>`,  embeds: [embedticket], components: [new Discord.MessageActionRow().addComponents(bu1tton)] }).then(msg => {
            msg.pin()
          })
          })
  }
  if (interaction.customId == `gs`) {
      await interaction.reply({ content: `Your ticket is being processed. Please wait `, ephemeral: true})
      if (hasTicket(interaction.guild, interaction)) {
        return;
      }
  
     
   
     interaction.guild.channels.create(getChannelName(interaction.user), {
          permissionOverwrites: [
            {
              id: interaction.guild.roles.everyone,
              deny: ['VIEW_CHANNEL'],
            },
            {
              id: (await db.get(`Staff_${interaction.guild.id}.Admin`)),
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`,`MANAGE_MESSAGES`],
            },
            {
              id: interaction.member.id,
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`],
            },
          ], parent: (await db.get(`Channels_${interaction.guild.id}.Cat`)), position: 1, topic: `${interaction.member.id}`, reason: "All rights reserved to Visa2Code"
        }).then(async channel => {
          channel = channel
          
        
          await interaction.editReply(`
    **Your ticket has been successfully opened** <#${channel.id}>`, true)
              
          const embedticket = new Discord.MessageEmbed()
            .setTimestamp()
            .setTitle("General Support")
            .setFooter(`Ticket opened at`)
            .setColor(0x5865F2)
            .setDescription(`Support will be with you soon.\n
    To close this ticket, interact with 🔒`)
          
          let bu1tton = new Discord.MessageButton()
            .setStyle(`SECONDARY`)
            .setLabel('Close')
            .setCustomId(`cl`)
            .setEmoji(`🔒`)
            
            
          channel.send({ content: `Welcome <@!${interaction.member.user.id}>`,  embeds: [embedticket], components: [new Discord.MessageActionRow().addComponents(bu1tton)] }).then(msg => {
            msg.pin()
          })
          })
  }
  if (interaction.customId == `gc`) {
    await interaction.reply({ content: `Your ticket is being processed. Please wait `, ephemeral: true})
      if (hasTicket(interaction.guild, interaction)) {
        return;
      }
  
     
   
     interaction.guild.channels.create(getChannelName(interaction.user), {
          permissionOverwrites: [
            {
              id: interaction.guild.roles.everyone,
              deny: ['VIEW_CHANNEL'],
            },
            {
              id: (await db.get(`Staff_${interaction.guild.id}.Admin`)),
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`,`MANAGE_MESSAGES`],
            },
            {
              id: interaction.member.id,
              allow: ['VIEW_CHANNEL', `READ_MESSAGE_HISTORY`, `ATTACH_FILES`, `SEND_MESSAGES`],
            },
          ], parent: (await db.get(`Channels_${interaction.guild.id}.Cat`)), position: 1, topic: `${interaction.member.id}`, reason: "All rights reserved to Visa2Code"
        }).then(async channel => {
          channel = channel
          
        
          await interaction.editReply(`
    **Your ticket has been successfully opened** <#${channel.id}>`, true)
              
          const embedticket = new Discord.MessageEmbed()
            .setTimestamp()
            .setTitle("Giveaway Claim")
            .setFooter(`Ticket opened at`)
            .setColor(0x5865F2)
            .setDescription(`Support will be with you soon.\n
    To close this ticket, interact with 🔒`)
          
          let bu1tton = new Discord.MessageButton()
            .setStyle(`SECONDARY`)
            .setLabel('Close')
            .setCustomId(`cl`)
            .setEmoji(`🔒`)
            
            
          channel.send({ content: `Welcome <@!${interaction.member.user.id}>`,  embeds: [embedticket], components: [new Discord.MessageActionRow().addComponents(bu1tton)] }).then(msg => {
            msg.pin()
          })
          })
  }
  
  if (interaction.customId == `cl`) {
    interaction.reply({ content: `Your order is executed after 5 seconds, and it will be closed`, ephemeral: true})
       let no = new Discord.MessageButton()
            .setStyle(`SECONDARY`)
            .setLabel('No')
            .setCustomId(`no`)
  
  
             let yes = new Discord.MessageButton()
            .setStyle(`DANGER`)
            .setLabel('Yes')
            .setCustomId(`yes`)
  
            let row = new Discord.MessageActionRow().addComponents(no, yes)
  
  
     let ch = interaction.channel
              if (!ch) return;
              setTimeout(async () => {
                try {
                  const closemebed = new Discord.MessageEmbed()
                  .setDescription(`The ticket has already been closed <@!${interaction.member.id}> \n \n Do you want to delete it?`)
                  .setColor(`YELLOW`)
                  
                  ch.send({ embeds: [closemebed], components: [row] })
                 
                 
                  
  
                 const member = client.users.cache.get(ch.topic)
                 
                  ch.permissionOverwrites.edit(member.id,{
                     VIEW_CHANNEL: false
                     }
                  )
                  
                  ch.setName(`closed-ticket`)
                  
                } catch (e) {
                  interaction.editReply({ content: `An error occurred, please try again!`, ephemeral: true})
                  console.log(e)
                  
                }
              }, 4000)
  }
  
  if (interaction.customId == `yes`) {
    const closemebed = new Discord.MessageEmbed()
                  .setDescription(`Ticket will be deleted in 5 seconds`)
                  .setColor(`YELLOW`)
  
                interaction.reply({ embeds: [closemebed] })
  
                   setTimeout(async () => {
                try {
                      interaction.channel.delete()
                } catch (e) {
                  interaction.editReply({ content: `An error occurred, please try again!`, ephemeral: true})
                  console.log(e)
                  
                }
                    }, 4000)
  }
  if (interaction.customId == `no`) {
   
      interaction.message.delete()
    
  }
  
  });
  
  
  
    client.login(config.token)
  