Merge pull request #179 from Emerald-Services/1tzemerald-patch-4

Update package.json

.github/workflows/node.js.yml

@@ -1,32 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [10.x, 12.x, 14.x, 15.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm install discord.js --save
-    - run: npm install js-yaml
-    - run: npm run build --if-present
-    - run: node index.js

Addons/addon.js

@@ -0,0 +1,26 @@
+const Discord = require("discord.js");
+const fs = require("fs");
+const yaml = require("js-yaml");
+const { Command } = require('../Structures/Addon.js'); // Adjust the path as needed
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+
+module.exports = new Command({
+    name: "addon",
+    description: "This is a sample addon!",
+    options: [],
+    permissions: ["Administrator"],
+  
+    async run(interaction) {
+      let disableCommand = true;
+  
+      const PingEmbed = new Discord.EmbedBuilder()
+        .setDescription(
+          `This is a sample addon.\n\nPong! \`${interaction.client.ws.ping} ms\``
+        )
+        .setColor(supportbot.Embed.Colours.General);
+  
+      interaction.reply({
+        embeds: [PingEmbed],
+      });
+    },
+  });

Commands/addUser.js

@@ -0,0 +1,217 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ChannelType,
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.AddUser.Command,
+  description: cmdconfig.AddUser.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "user",
+      description: "The user to add",
+      type: ApplicationCommandOptionType.User,
+      required: true,
+    },
+  ],
+  permissions: cmdconfig.AddUser.Permission,
+
+  async run(interaction) {
+    const userToAdd = interaction.options.getUser("user");
+    const ticketChannel = interaction.channel;
+    const ticketDataPath = "./Data/TicketData.json";
+
+    if (
+      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
+      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
+    ) {
+      const onlyInTicket = new EmbedBuilder()
+        .setTitle(msgconfig.AddUser.NotInTicket_Title)
+        .setDescription(msgconfig.AddUser.NotInTicket_Description)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      return interaction.reply({
+        embeds: [onlyInTicket],
+        ephemeral: true,
+      });
+    }
+
+    const ticketInviteEmbed = new EmbedBuilder()
+      .setTitle(msgconfig.AddUser.Invite_Title)
+      .setDescription(msgconfig.AddUser.Invite_Description.replace("%username%", userToAdd.username))
+      .setColor(supportbot.Embed.Colours.General);
+
+    await interaction.reply({
+      embeds: [ticketInviteEmbed],
+      ephemeral: true,
+    });
+
+    try {
+      const dmEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.AddUser.DM_Title)
+        .setDescription(msgconfig.AddUser.DM_Description.replace("%channelname%", ticketChannel.name))
+        .setColor(supportbot.Embed.Colours.General);
+
+      const acceptButton = new ButtonBuilder()
+        .setCustomId("accept_invite")
+        .setLabel(msgconfig.AddUser.Accept_Label)
+        .setEmoji("✅")
+        .setStyle(ButtonStyle.Primary);
+
+      const rejectButton = new ButtonBuilder()
+        .setCustomId("reject_invite")
+        .setLabel(msgconfig.AddUser.Reject_Label)
+        .setEmoji("❌")
+        .setStyle(ButtonStyle.Secondary);
+
+      const row = new ActionRowBuilder().addComponents(acceptButton, rejectButton);
+
+      const dmMessage = await userToAdd.send({
+        embeds: [dmEmbed],
+        components: [row],
+      });
+
+      const filter = (i) => i.user.id === userToAdd.id;
+      const collector = dmMessage.createMessageComponentCollector({
+        filter,
+        time: 60000,
+      });
+
+      collector.on("collect", async (i) => {
+        if (i.customId === "accept_invite") {
+          try {
+            // Add user to thread or channel based on TicketType
+            if (supportbot.Ticket.TicketType === "threads") {
+              await ticketChannel.members.add(userToAdd.id); // For threads
+            } else if (supportbot.Ticket.TicketType === "channels") {
+              await ticketChannel.permissionOverwrites.create(userToAdd.id, {
+                ViewChannel: true,
+                SendMessages: true,
+                ReadMessageHistory: true,
+              }); // For channels
+            }
+
+            const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
+            const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
+            if (ticketIndex !== -1) {
+              ticketData.tickets[ticketIndex].subUsers.push(userToAdd.id);
+              fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
+            }
+
+            const acceptedEmbed = new EmbedBuilder()
+              .setTitle(msgconfig.AddUser.Accepted_Title)
+              .setDescription(msgconfig.AddUser.Accepted_Message)
+              .setColor(supportbot.Embed.Colours.Success);
+
+            await i.update({
+              embeds: [acceptedEmbed],
+              components: [],
+            });
+
+            // Send the added user ticket message in the ticket channel
+
+              const addeduserTicket = new EmbedBuilder()
+                .setTitle(msgconfig.AddUser.Added_Title)
+                .setDescription(msgconfig.AddUser.Added_Description.replace('%username%', userToAdd.username))
+                .setColor(supportbot.Embed.Colours.General);
+
+              await ticketChannel.send({
+                embeds: [addeduserTicket],
+              });
+
+
+            const addedToTicketEmbed = new EmbedBuilder()
+              .setTitle(msgconfig.AddUser.AddedToTicket_Title)
+              .setDescription(msgconfig.AddUser.AddedToTicket_Description.replace(
+                "%channel_link%",
+                `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
+              ))
+              .setColor(supportbot.Embed.Colours.General);
+
+            const ticketLinkButton = new ButtonBuilder()
+              .setLabel(msgconfig.AddUser.ViewTicket_Label)
+              .setURL(`https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id}`)
+              .setStyle(ButtonStyle.Link);
+
+            await userToAdd.send({
+              embeds: [addedToTicketEmbed],
+              components: [new ActionRowBuilder().addComponents(ticketLinkButton)],
+            });
+
+          } catch (err) {
+            console.error("Error adding user to the ticket:", err);
+
+            const errorEmbed = new EmbedBuilder()
+              .setTitle(msgconfig.AddUser.Error_Title)
+              .setDescription(msgconfig.AddUser.Error_Adding)
+              .setColor(supportbot.Embed.Colours.Error);
+
+            await i.update({
+              embeds: [errorEmbed],
+              components: [],
+            });
+          }
+        } else {
+          const declinedEmbed = new EmbedBuilder()
+            .setTitle(msgconfig.AddUser.Declined_Title)
+            .setDescription(msgconfig.AddUser.Declined_Message)
+            .setColor(supportbot.Embed.Colours.Error);
+
+          await i.update({
+            embeds: [declinedEmbed],
+            components: [],
+          });
+        }
+      });
+
+      collector.on("end", (collected) => {
+        if (collected.size === 0) {
+          userToAdd.send({
+            embeds: [
+              new EmbedBuilder()
+                .setTitle(msgconfig.AddUser.NoResponse_Title)
+                .setDescription(msgconfig.AddUser.NoResponse_Message)
+                .setColor(supportbot.Embed.Colours.Warning),
+            ],
+          });
+        }
+      });
+    } catch (error) {
+      if (error.code === 50007) {
+        const errorEmbed = new EmbedBuilder()
+          .setTitle(msgconfig.AddUser.DM_Error_Title)
+          .setDescription(msgconfig.AddUser.DM_Error_Description.replace("%username%", userToAdd.username))
+          .setColor(supportbot.Embed.Colours.Error);
+
+        await ticketChannel.send({
+          embeds: [errorEmbed],
+        });
+      } else {
+        console.error("Error sending DM:", error);
+
+        const unexpectedErrorEmbed = new EmbedBuilder()
+          .setTitle(msgconfig.AddUser.Unexpected_Error_Title)
+          .setDescription(msgconfig.AddUser.Unexpected_Error_Description.replace("%error%", error.message))
+          .setColor(supportbot.Embed.Colours.Error);
+
+        await ticketChannel.send({
+          embeds: [unexpectedErrorEmbed],
+        });
+      }
+    }
+  },
+});

Commands/close.js

@@ -0,0 +1,304 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.CloseTicket.Command,
+  description: cmdconfig.CloseTicket.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "reason",
+      description: "Ticket Close Reason",
+      type: Discord.ApplicationCommandOptionType.String,
+    },
+  ],
+  permissions: cmdconfig.CloseTicket.Permission,
+
+  async run(interaction) {
+    const { getRole, getChannel } = interaction.client;
+
+    if (supportbot.Ticket.Close.StaffOnly) {
+      let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+      let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+
+      if (!SupportStaff || !Admin)
+        return interaction.reply("Some roles seem to be missing!\nPlease check for errors when starting the bot.");
+
+      const NoPerms = new Discord.EmbedBuilder()
+        .setTitle("Invalid Permissions!")
+        .setDescription(`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``)
+        .setColor(supportbot.Embed.Colours.Warn);
+
+      if (!interaction.member.roles.cache.has(SupportStaff.id) && !interaction.member.roles.cache.has(Admin.id))
+        return interaction.reply({ embeds: [NoPerms] });
+    }
+
+    // Check if it's a thread or channel based on config
+    if (
+      (supportbot.Ticket.TicketType === "threads" && interaction.channel.type !== Discord.ChannelType.PrivateThread) ||
+      (supportbot.Ticket.TicketType === "channels" && interaction.channel.type !== Discord.ChannelType.GuildText)
+    ) {
+      const NotTicketChannel = new Discord.EmbedBuilder()
+        .setTitle("Invalid Channel!")
+        .setDescription(`This command can only be used in a ${supportbot.Ticket.TicketType === "threads" ? "ticket thread" : "ticket channel"}.`)
+        .setColor(supportbot.Embed.Colours.Warn);
+
+      return interaction.reply({ embeds: [NotTicketChannel], ephemeral: true });
+    }
+
+    await interaction.deferReply();
+
+    let tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+    let TicketData = tickets.tickets.findIndex((t) => t.id === interaction.channel.id);
+    let ticket = tickets.tickets[TicketData];
+
+    if (TicketData === -1) {
+      const Exists = new Discord.EmbedBuilder()
+        .setTitle("No Ticket Found!")
+        .setDescription(msgconfig.Error.NoValidTicket)
+        .setColor(supportbot.Embed.Colours.Warn);
+      return interaction.followUp({ embeds: [Exists] });
+    }
+
+    let reason = interaction.options?.getString("reason") || "No Reason Provided.";
+
+    const CloseButton = new Discord.ButtonBuilder()
+      .setCustomId("confirmCloseTicket")
+      .setLabel(supportbot.Ticket.Close.Confirmation_Button)
+      .setEmoji(supportbot.Ticket.Close.Confirmation_Emoji)
+      .setStyle(supportbot.Ticket.Close.Confirmation_Style);
+
+    const row = new Discord.ActionRowBuilder().addComponents(CloseButton);
+
+    const CloseTicketRequest = new Discord.EmbedBuilder()
+      .setTitle(`**${supportbot.Ticket.Close.Title}**`)
+      .setDescription(`${msgconfig.Ticket.ConfirmClose}`)
+      .setColor(supportbot.Embed.Colours.General);
+
+    await interaction.followUp({
+      embeds: [CloseTicketRequest],
+      components: [row],
+    });
+
+    const filter = (btnInteraction) => btnInteraction.customId === "confirmCloseTicket" && btnInteraction.user.id === interaction.user.id;
+
+    interaction.channel.awaitMessageComponent({ filter, time: 20000 })
+      .then(async (btnInteraction) => {
+        await handleCloseTicket(interaction, reason, ticket, TicketData);
+        await btnInteraction.reply({ content: "Ticket successfully closed.", ephemeral: true });
+      })
+      .catch((err) => {
+        interaction.followUp(`${msgconfig.Ticket.CloseTimeout}`);
+        console.error(err);
+      });
+  },
+});
+
+async function handleCloseTicket(interaction, reason, ticket, TicketData) {
+  const { getChannel } = interaction.client;
+
+  let tickets = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+  let tUser = interaction.client.users.cache.get(ticket.user);
+  let transcriptChannel = await getChannel(supportbot.Ticket.Log.TicketDataLog, interaction.guild);
+
+  if (!transcriptChannel)
+    return interaction.followUp("Some Channels seem to be missing!");
+
+  try {
+    tickets.tickets[TicketData].open = false;
+    fs.writeFileSync(
+      "./Data/TicketData.json",
+      JSON.stringify(tickets, null, 4),
+      (err) => {
+        if (err) console.error(err);
+      }
+    );
+
+    const transcriptEmbed = new Discord.EmbedBuilder()
+      .setTitle(msgconfig.TicketLog.Title)
+      .setColor(msgconfig.TicketLog.Colour)
+      .setFooter({
+        text: supportbot.Embed.Footer,
+        iconURL: interaction.user.displayAvatarURL(),
+      })
+      .addFields(
+        { name: "Ticket", value: `${interaction.channel.name} (${interaction.channel.id})` },
+        { name: "User", value: `${tUser?.username || "N/A"}#${tUser?.discriminator || "N/A"} (${tUser?.id || ticket.user})` },
+        { name: "Closed By", value: interaction.user.tag },
+        { name: "Reason", value: reason }
+      );
+
+    let msgs = await interaction.channel.messages.fetch({ limit: 100 });
+    let html = `
+      <html>
+        <head>
+          <link href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
+          <style>
+            body {
+              background-color: #1a1a1a;
+              font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+              color: white;
+              margin: 0;
+              padding: 0;
+              height: 100%;
+              display: flex;
+              flex-direction: column;
+            }
+            .container {
+              backdrop-filter: blur(10px);
+              background-color: rgba(0, 128, 0, 0.3);
+              border-radius: 15px;
+              padding: 20px;
+              margin: 20px;
+              box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+              flex-grow: 1;
+              display: flex;
+              flex-direction: column;
+              max-width: 1000px;
+              width: 100%;
+              margin: auto;
+            }
+            .message {
+              display: flex;
+              align-items: center;
+              margin-bottom: 10px;
+              padding: 10px;
+              background-color: rgba(255, 255, 255, 0.1);
+              border-radius: 10px;
+            }
+            .avatar {
+              width: 40px;
+              height: 40px;
+              border-radius: 50%;
+              margin-right: 10px;
+            }
+            .content {
+              flex: 1;
+            }
+            .username {
+              font-weight: bold;
+            }
+            .timestamp {
+              font-size: 0.8em;
+              color: #bbb;
+            }
+            .download-button {
+              background-color: #4CAF50;
+              color: white;
+              padding: 10px 20px;
+              text-align: center;
+              text-decoration: none;
+              display: inline-block;
+              font-size: 16px;
+              margin-top: 20px;
+              border-radius: 5px;
+            }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <h1 class="text-2xl font-bold mb-4">Ticket Transcript</h1>
+            <p><strong>Server Name:</strong> ${interaction.guild.name}</p>
+            <p><strong>Ticket:</strong> ${interaction.channel.name}</p>
+            <p><strong>Messages:</strong> ${msgs.size} Messages</p>
+            <div class="mt-4">
+    `;
+
+    msgs = msgs.sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+    msgs.forEach((msg) => {
+      if (msg.content) {
+        html += `
+          <div class="message">
+            <img class="avatar" src="${msg.author.displayAvatarURL()}" alt="Avatar">
+            <div class="content">
+              <p class="username">${msg.author.tag}</p>
+              <p class="timestamp">${msg.createdAt.toLocaleString()}</p>
+              <p>${convertMarkdownToHTML(msg.content)}</p>
+            </div>
+          </div>
+        `;
+      }
+    });
+
+    const fileName = `${interaction.channel.name}.html`;
+
+    html += `
+            </div>
+            <a href="${fileName}" download class="download-button">Download Transcript</a>
+          </div>
+        </body>
+      </html>
+    `;
+
+    let file = new Discord.AttachmentBuilder(
+      Buffer.from(html),
+      { name: fileName }
+    );
+
+    await transcriptChannel
+      .send({ embeds: [transcriptEmbed], files: [file] })
+      .catch((err) => {
+        console.error(err);
+      });
+
+    if (supportbot.Ticket.DMTranscripts) {
+      await tUser
+        ?.send({ embeds: [transcriptEmbed], files: [file] })
+        .catch((err) => {
+          console.error(err);
+        });
+
+      if (ticket.subUsers) {
+        ticket.subUsers.forEach(async (subUser) => {
+          await interaction.client.users.cache
+            .get(subUser)
+            ?.send({ embeds: [transcriptEmbed], files: [file] });
+        });
+      }
+    }
+
+    await interaction.channel.delete().catch((error) => {
+      console.error(error);
+      if (error.code !== Discord.Constants.APIErrors.UNKNOWN_CHANNEL) {
+        console.error("Failed to delete the interaction:", error);
+      }
+    });
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+function convertMarkdownToHTML(text) {
+  // Convert **bold** to <strong>bold</strong>
+  text = text.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+
+  // Convert *italic* to <em>italic</em>
+  text = text.replace(/\*(.*?)\*/g, '<em>$1</em>');
+
+  // Convert __underline__ to <u>underline</u>
+  text = text.replace(/__(.*?)__/g, '<u>$1</u>');
+
+  // Convert ~~strikethrough~~ to <s>strikethrough</s>
+  text = text.replace(/~~(.*?)~~/g, '<s>$1</s>');
+
+  // Convert inline code `code` to <code>code</code>
+  text = text.replace(/`(.*?)`/g, '<code>$1</code>');
+
+  // Convert blockquotes > quote to <blockquote>quote</blockquote>
+  text = text.replace(/^> (.*?$)/gm, '<blockquote>$1</blockquote>');
+
+  // Convert multiline code blocks ```code``` to <pre><code>code</code></pre>
+  text = text.replace(/```(.*?)```/gs, '<pre><code>$1</code></pre>');
+
+  // Convert line breaks to <br>
+  text = text.replace(/\n/g, '<br>');
+
+  return text;
+}

Commands/embed.js

@@ -0,0 +1,167 @@
+// File path: ./commands/embed.js
+
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.Embed.Command,
+  description: cmdconfig.Embed.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "title",
+      description: "Embed Title",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: true,
+    },
+    {
+      name: "message",
+      description: "Embed Message",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: true,
+    },
+    {
+      name: "color",
+      description: "Embed HEX Color",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "fields",
+      description: "Embed Fields (title|content;title|content;...)",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "thumbnail",
+      description: "Embed Thumbnail URL",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "image",
+      description: "Embed Image URL",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "footer",
+      description: "Embed Footer Text",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "footericon",
+      description: "Embed Footer Icon URL",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "author",
+      description: "Embed Author Name",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "authoricon",
+      description: "Embed Author Icon URL",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "authorurl",
+      description: "Embed Author URL",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: false,
+    },
+    {
+      name: "timestamp",
+      description: "Include Timestamp",
+      type: Discord.ApplicationCommandOptionType.Boolean,
+      required: false,
+    },
+    {
+      name: "inline",
+      description: "Make Fields Inline",
+      type: Discord.ApplicationCommandOptionType.Boolean,
+      required: false,
+    }
+  ],
+  permissions: cmdconfig.Embed.Permission,
+
+  async run(interaction) {
+    const { getRole } = interaction.client;
+    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+
+    if (!SupportStaff || !Admin) {
+      return interaction.reply("Some roles seem to be missing!\nPlease check for errors when starting the bot.");
+    }
+
+    const NoPerms = new Discord.EmbedBuilder()
+      .setTitle("Invalid Permissions!")
+      .setDescription(`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``)
+      .setColor(supportbot.Embed.Colours.Warn);
+
+    if (
+      interaction.member.roles.cache.has(SupportStaff.id) ||
+      interaction.member.roles.cache.has(Admin.id)
+    ) {
+      const EmbedTitle = interaction.options.getString("title").replace(/\\n/g, '\n');
+      const EmbedSubject = interaction.options.getString("message").replace(/\\n/g, '\n');
+      const GeneralColour = interaction.options.getString("color") || supportbot.Embed.Colours.Default;
+      const EmbedThumbnail = interaction.options.getString("thumbnail");
+      const EmbedImage = interaction.options.getString("image");
+      const EmbedFields = interaction.options.getString("fields");
+      const EmbedFooter = interaction.options.getString("footer")?.replace(/\\n/g, '\n');
+      const EmbedFooterIcon = interaction.options.getString("footericon");
+      const EmbedAuthor = interaction.options.getString("author")?.replace(/\\n/g, '\n');
+      const EmbedAuthorIcon = interaction.options.getString("authoricon");
+      const EmbedAuthorURL = interaction.options.getString("authorurl");
+      const EmbedTimestamp = interaction.options.getBoolean("timestamp");
+      const InlineFields = interaction.options.getBoolean("inline");
+
+      const EmbedMsg = new Discord.EmbedBuilder()
+        .setTitle(EmbedTitle)
+        .setDescription(EmbedSubject)
+        .setColor(GeneralColour)
+        .setThumbnail(EmbedThumbnail)
+        .setImage(EmbedImage);
+
+      if (EmbedFields) {
+        const fieldsArray = EmbedFields.split(';');
+        fieldsArray.forEach(field => {
+          const [title, value] = field.split('|');
+          if (title && value) {
+            EmbedMsg.addFields({ name: title.replace(/\\n/g, '\n'), value: value.replace(/\\n/g, '\n'), inline: InlineFields || false });
+          }
+        });
+      }
+
+      if (EmbedFooter) {
+        EmbedMsg.setFooter({ text: EmbedFooter, iconURL: EmbedFooterIcon });
+      }
+
+      if (EmbedAuthor) {
+        EmbedMsg.setAuthor({ name: EmbedAuthor, iconURL: EmbedAuthorIcon, url: EmbedAuthorURL });
+      }
+
+      if (EmbedTimestamp) {
+        EmbedMsg.setTimestamp();
+      }
+
+      interaction.reply({
+        embeds: [EmbedMsg],
+      });
+    } else {
+      return interaction.reply({ embeds: [NoPerms] });
+    }
+  },
+});

Commands/forceaddUser.js

@@ -0,0 +1,134 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.ForceAddUser.Command,
+  description: cmdconfig.ForceAddUser.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "user",
+      description: "The user to forcefully add",
+      type: ApplicationCommandOptionType.User,
+      required: true,
+    },
+  ],
+  permissions: cmdconfig.ForceAddUser.Permission,
+
+  async run(interaction) {
+    const userToAdd = interaction.options.getUser("user");
+    const ticketChannel = interaction.channel;
+    const ticketDataPath = "./Data/TicketData.json";
+
+    if (
+      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
+      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
+    ) {
+      const onlyInTicket = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.NotInTicket_Title)
+        .setDescription(msgconfig.ForceAddUser.NotInTicket_Description)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      return interaction.reply({
+        embeds: [onlyInTicket],
+        ephemeral: true,
+      });
+    }
+
+    try {
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        try {
+            // Explicitly ensure the bot is in the thread
+            const botMember = await ticketChannel.members.fetch(interaction.client.user.id).catch(() => null);
+            if (!botMember) {
+                await ticketChannel.join();
+            }
+    
+            // Delay to ensure API has processed the bot's membership
+            await new Promise(res => setTimeout(res, 1000));
+    
+            // Attempt to add the user to the thread
+            await ticketChannel.members.add(userToAdd.id);
+    
+            console.log("User successfully added to the thread.");
+        } catch (err) {
+            console.error("Error adding user to the thread:", err.message);
+            const errorEmbed = new EmbedBuilder()
+                .setTitle(msgconfig.ForceAddUser.Error_Title)
+                .setDescription(`An error occurred: ${err.message}`)
+                .setColor(supportbot.Embed.Colours.Error);
+    
+            return interaction.reply({
+                embeds: [errorEmbed],
+                ephemeral: true,
+            });
+        }
+
+      } else if (supportbot.Ticket.TicketType === "channels") {
+        await ticketChannel.permissionOverwrites.create(userToAdd.id, {
+          ViewChannel: true,
+          SendMessages: true,
+          ReadMessageHistory: true,
+        }); 
+      }
+
+      const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
+      const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
+      if (ticketIndex !== -1) {
+        ticketData.tickets[ticketIndex].subUsers.push(userToAdd.id);
+        fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
+      }
+
+      const addedEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.Added_Title)
+        .setDescription(
+          msgconfig.ForceAddUser.Added_Description.replace("%username%", userToAdd.username)
+        )
+        .setColor(supportbot.Embed.Colours.Success);
+
+      await interaction.reply({
+        embeds: [addedEmbed],
+        ephemeral: true,
+      });
+
+      const addedToTicketEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.AddedToTicket_Title)
+        .setDescription(
+          msgconfig.ForceAddUser.AddedToTicket_Description.replace(
+            "%channel_link%",
+            `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
+          )
+        )
+        .setColor(supportbot.Embed.Colours.General);
+
+      await userToAdd.send({
+        embeds: [addedToTicketEmbed],
+      });
+    } catch (err) {
+      console.error("Error adding user to the ticket:", err);
+
+      const errorEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.ForceAddUser.Error_Title)
+        .setDescription(msgconfig.ForceAddUser.Error_Adding)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      await interaction.reply({
+        embeds: [errorEmbed],
+        ephemeral: true,
+      });
+    }
+  },
+});

Commands/help.js

@@ -0,0 +1,62 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.Help.Command,
+  description: cmdconfig.Help.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [],
+  permissions: cmdconfig.Help.Permission,
+
+  async run(interaction) {
+    const { getRole } = interaction.client;
+    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+    if (!SupportStaff || !Admin) {
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+      );
+    }
+
+    // Separate regular commands and addon commands
+    let botCommands = "";
+    let addonCommands = "";
+
+    interaction.client.commands.forEach((command) => {
+      if (command.permissions) {
+        if (command.addon) {
+          addonCommands += `\`${command.name}\` `;
+        } else {
+          botCommands += `\`${command.name}\` `;
+        }
+      }
+    });
+
+    // Create embed
+    const HelpEmbed1 = new Discord.EmbedBuilder()
+      .setTitle(supportbot.General.Name + " Commands")
+      .setThumbnail(interaction.user.displayAvatarURL())
+      .setColor(supportbot.Embed.Colours.General)
+      .addFields({
+        name: "🖥️ Commands\n",
+        value: botCommands || "No commands available.",
+        inline: false,
+      });
+
+    HelpEmbed1.setFooter({
+      text: supportbot.Embed.Footer,
+      iconURL: interaction.user.displayAvatarURL(),
+    });
+
+    interaction.reply({
+      ephemeral: true,
+      embeds: [HelpEmbed1],
+    });
+  },
+});

Commands/info.js

@@ -0,0 +1,51 @@
+// SupportBot | Emerald Services
+// Info Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+const cmdconfig = yaml.load(
+  fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+
+const msgconfig = yaml.load(
+  fs.readFileSync("./Configs/messages.yml", "utf8")
+);
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.Info.Command,
+  description: cmdconfig.Info.Description,
+  options: [],
+  permissions: cmdconfig.Info.Permission,
+
+  async run(interaction) {
+    let disableCommand = true;
+
+  const InfoButton = new Discord.ButtonBuilder()
+    .setLabel(msgconfig.Info.Button)
+    .setURL(msgconfig.Info.URL)
+    .setStyle("Link");
+
+  const inforow = new Discord.ActionRowBuilder().addComponents(InfoButton);
+
+  const InfoEmbed = new Discord.EmbedBuilder()
+    .setURL(msgconfig.Info.URL)
+    .setTitle(msgconfig.Info.Title)
+    .setDescription(msgconfig.Info.Description)
+    .setColor(msgconfig.Info.Colour)
+
+  interaction.reply({
+    embeds: [InfoEmbed],
+    components: [inforow],
+  });
+
+  },
+});

Commands/ping.js

@@ -0,0 +1,34 @@
+// SupportBot | Emerald Services
+// Ping Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.Ping.Command,
+  description: cmdconfig.Ping.Description,
+  options: [],
+  permissions: cmdconfig.Ping.Permission,
+
+  async run(interaction) {
+    let disableCommand = true;
+
+    const PingEmbed = new Discord.EmbedBuilder()
+      .setDescription(
+        `:ping_pong: **Ping:** \`${interaction.client.ws.ping} ms\``
+      )
+      .setColor(supportbot.Embed.Colours.General);
+
+    interaction.reply({
+      embeds: [PingEmbed],
+    });
+  },
+});

Commands/profile.js

@@ -0,0 +1,324 @@
+const { EmbedBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ApplicationCommandType, ActionRowBuilder, ButtonBuilder, ButtonStyle, ApplicationCommandOptionType } = require("discord.js");
+const fs = require("fs");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+const clockedInUsers = new Set();
+
+// async function getRole(roleName, guild) {
+//  return guild.roles.cache.find(role => role.name === roleName);
+// }
+
+function updateClockedInStatus(profileEmbed, clockedIn) {
+  profileEmbed.data.fields = profileEmbed.data.fields.map(field => {
+    if (field.name === 'Clocked In Status') {
+      field.value = clockedIn ? '✅ Clocked In' : '❌ Clocked Out';
+    }
+    return field;
+  });
+  return profileEmbed;
+}
+
+module.exports = new Command({
+  name: cmdconfig.Profile.Command,
+  description: cmdconfig.Profile.Description,
+  type: ApplicationCommandType.ChatInput,
+  permissions: cmdconfig.Profile.Permission,
+  options: [
+    {
+      name: 'user',
+      description: 'The user to view the profile of',
+      type: ApplicationCommandOptionType.User,
+      required: false
+    }
+  ],
+
+  async run(interaction) {
+    await interaction.deferReply({ ephemeral: true });  // Acknowledge the interaction immediately
+
+    const userOption = interaction.options.getUser('user');
+    const viewingUser = userOption || interaction.user;
+    const viewingUserId = viewingUser.id;
+    const interactionUserId = interaction.user.id;
+
+    const user = interaction.guild.members.cache.get(viewingUserId);
+    const { getRole, getChannel } = interaction.client;
+
+    const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+
+    if (!Staff || !Admin) {
+      return interaction.editReply({
+        content: "Some roles seem to be missing!\nPlease check for errors when starting the bot.",
+        ephemeral: true,
+      });
+    }
+
+    const isStaff = user.roles.cache.has(Staff.id) || user.roles.cache.has(Admin.id);
+    const isOwnProfile = interactionUserId === viewingUserId;
+
+    const profilePath = `./Data/Profiles/${viewingUserId}.json`;
+    let profileData;
+
+    if (fs.existsSync(profilePath)) {
+      profileData = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+    } else {
+      profileData = {
+        bio: "",
+        timezone: "",
+        clockedIn: false
+      };
+      fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+    }
+
+    const { bio, timezone, clockedIn } = profileData;
+
+    let profileEmbed = new EmbedBuilder()
+      .setTitle(`${viewingUser.username}'s Profile`)
+      .setColor(supportbot.Embed.Colours.General)
+      .setThumbnail(viewingUser.displayAvatarURL())
+      .addFields(
+        { name: 'Bio', value: bio || 'No bio set.', inline: false },
+        { name: 'Timezone', value: timezone || 'No timezone set.', inline: true }
+      );
+
+    if (isStaff) {
+      profileEmbed.addFields({ name: 'Clocked In Status', value: clockedIn ? '✅ Clocked In' : '❌ Clocked Out', inline: true });
+    }
+
+    const buttonRow = new ActionRowBuilder();
+    if (isOwnProfile) {
+      buttonRow.addComponents(
+        new ButtonBuilder()
+          .setCustomId('editProfile')
+          .setLabel('Edit Profile')
+          .setStyle(ButtonStyle.Secondary)
+      );
+
+      if (isStaff) {
+        buttonRow.addComponents(
+          new ButtonBuilder()
+            .setCustomId('clockInOut')
+            .setLabel(clockedIn ? 'Clock Out' : 'Clock In')
+            .setStyle(ButtonStyle.Secondary)
+        );
+      }
+    }
+
+    if (isStaff && supportbot.Ticket.ClaimTickets.Enabled) {
+      buttonRow.addComponents(
+        new ButtonBuilder()
+          .setCustomId('viewTicketStats')
+          .setLabel('View Ticket Stats')
+          .setStyle(ButtonStyle.Secondary)
+      );
+    }
+
+    await interaction.editReply({ embeds: [profileEmbed], components: buttonRow.components.length > 0 ? [buttonRow] : [] });
+
+    const filter = i => (
+      ['editProfile', 'clockInOut', 'viewTicketStats', 'showOpenTickets', 'backToStats', 'backToProfile'].includes(i.customId) 
+      && i.user.id === interactionUserId
+    );
+
+    const collector = interaction.channel.createMessageComponentCollector({ filter, time: 60000 });
+
+    collector.on('collect', async i => {
+      if (i.customId === 'editProfile') {
+        const modal = new ModalBuilder()
+          .setCustomId('editProfileModal')
+          .setTitle('Edit Profile')
+          .addComponents(
+            new ActionRowBuilder().addComponents(
+              new TextInputBuilder()
+                .setCustomId('bio')
+                .setLabel('Bio')
+                .setStyle(TextInputStyle.Paragraph)
+                .setPlaceholder('Enter your bio')
+                .setValue(String(bio))
+                .setRequired(false)
+            ),
+            new ActionRowBuilder().addComponents(
+              new TextInputBuilder()
+                .setCustomId('timezone')
+                .setLabel('Timezone')
+                .setStyle(TextInputStyle.Short)
+                .setPlaceholder('Enter your timezone')
+                .setValue(String(timezone))
+                .setRequired(false)
+            )
+          );
+
+        await i.showModal(modal);
+      }
+
+      if (i.customId === 'clockInOut') {
+        profileData.clockedIn = !profileData.clockedIn;
+        fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+        profileEmbed = updateClockedInStatus(profileEmbed, profileData.clockedIn);
+
+        if (profileData.clockedIn) {
+          clockedInUsers.add(viewingUserId);
+        } else {
+          clockedInUsers.delete(viewingUserId);
+        }
+
+        const updatedButtonRow = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+              .setCustomId('editProfile')
+              .setLabel('Edit Profile')
+              .setStyle(ButtonStyle.Secondary)
+          );
+
+        if (isStaff) {
+          updatedButtonRow.addComponents(
+            new ButtonBuilder()
+              .setCustomId('clockInOut')
+              .setLabel(profileData.clockedIn ? 'Clock Out' : 'Clock In')
+              .setStyle(ButtonStyle.Secondary)
+          );
+
+          if (supportbot.Ticket.ClaimTickets.Enabled) {
+            updatedButtonRow.addComponents(
+              new ButtonBuilder()
+                .setCustomId('viewTicketStats')
+                .setLabel('View Ticket Stats')
+                .setStyle(ButtonStyle.Secondary)
+            );
+          }
+        }
+
+        await i.update({ embeds: [profileEmbed], components: [updatedButtonRow] });
+
+        let clockedinout = new EmbedBuilder()
+          .setTitle(profileData.clockedIn ? 'Clocked In!' : 'Clocked Out!') 
+          .setDescription(profileData.clockedIn ? 'You have successfully clocked in.' : 'You have successfully clocked out.')
+          .setColor(supportbot.Embed.Colours.General)
+
+        await interaction.followUp({ embeds: [clockedinout], ephemeral: true });
+      }
+
+      if (i.customId === 'viewTicketStats') {
+        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+        const ticketsClaimed = TicketData.tickets.filter(t => t.claimedBy === viewingUserId);
+        const ticketsOpen = ticketsClaimed.filter(t => t.open);
+        const totalTickets = ticketsClaimed.length;
+
+        let totalResponseTime = 0;
+        let responseCount = 0;
+
+        ticketsClaimed.forEach(ticket => {
+          if (ticket.claimedAt && ticket.createdAt) {
+            const responseTime = new Date(ticket.claimedAt) - new Date(ticket.createdAt);
+            totalResponseTime += responseTime;
+            responseCount++;
+          }
+        });
+
+        const averageResponseTime = responseCount ? totalResponseTime / responseCount : 0;
+        const averageResponseTimeMinutes = Math.round(averageResponseTime / 60000);
+
+        const statsEmbed = new EmbedBuilder()
+          .setTitle(msgconfig.TicketStats.Title)
+          .setDescription(`> Ticket stats for <@${viewingUserId}>`)
+          .setColor(supportbot.Embed.Colours.General)
+          .addFields(
+            { name: msgconfig.TicketStats.OpenTickets, value: `${ticketsOpen.length}`, inline: true },
+            { name: msgconfig.TicketStats.TotalTickets, value: `${totalTickets}`, inline: true },
+            { name: msgconfig.TicketStats.ResponseTime, value: `${averageResponseTimeMinutes} minutes`, inline: false }
+          );
+
+        const statsButtonRow = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+              .setCustomId('showOpenTickets')
+              .setLabel('Show Open Tickets')
+              .setStyle(ButtonStyle.Secondary),
+            new ButtonBuilder()
+              .setCustomId('backToProfile')
+              .setLabel('Back to Profile')
+              .setStyle(ButtonStyle.Secondary)
+          );
+
+        await i.update({ embeds: [statsEmbed], components: [statsButtonRow] });
+      }
+
+      if (i.customId === 'showOpenTickets') {
+        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+        const ticketsOpen = TicketData.tickets.filter(t => t.claimedBy === viewingUserId && t.open);
+
+        const openTicketsEmbed = new EmbedBuilder()
+          .setTitle('Active Tickets')
+          .setDescription(ticketsOpen.map(t => `<#${t.id}>`).join('\n') || 'No active tickets.')
+          .setColor(supportbot.Embed.Colours.General);
+
+        const openTicketsButtonRow = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+              .setCustomId('backToStats')
+              .setLabel('Back to Stats')
+              .setStyle(ButtonStyle.Secondary)
+          );
+
+        await i.update({ embeds: [openTicketsEmbed], components: [openTicketsButtonRow] });
+      }
+
+      if (i.customId === 'backToStats') {
+        const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+        const ticketsClaimed = TicketData.tickets.filter(t => t.claimedBy === viewingUserId);
+        const ticketsOpen = ticketsClaimed.filter(t => t.open);
+        const totalTickets = ticketsClaimed.length;
+
+        let totalResponseTime = 0;
+        let responseCount = 0;
+
+        ticketsClaimed.forEach(ticket => {
+          if (ticket.claimedAt && ticket.createdAt) {
+            const responseTime = new Date(ticket.claimedAt) - new Date(ticket.createdAt);
+            totalResponseTime += responseTime;
+            responseCount++;
+          }
+        });
+
+        const averageResponseTime = responseCount ? totalResponseTime / responseCount : 0;
+        const averageResponseTimeMinutes = Math.round(averageResponseTime / 60000);
+
+        const statsEmbed = new EmbedBuilder()
+          .setTitle(msgconfig.TicketStats.Title)
+          .setDescription(`> Ticket stats for <@${viewingUserId}>`)
+          .setColor(supportbot.Embed.Colours.General)
+          .addFields(
+            { name: msgconfig.TicketStats.OpenTickets, value: `${ticketsOpen.length}`, inline: true },
+            { name: msgconfig.TicketStats.TotalTickets, value: `${totalTickets}`, inline: true },
+            { name: msgconfig.TicketStats.ResponseTime, value: `${averageResponseTimeMinutes} minutes`, inline: false }
+          );
+
+        const statsButtonRow = new ActionRowBuilder()
+          .addComponents(
+            new ButtonBuilder()
+              .setCustomId('showOpenTickets')
+              .setLabel('Show Open Tickets')
+              .setStyle(ButtonStyle.Secondary),
+            new ButtonBuilder()
+              .setCustomId('backToProfile')
+              .setLabel('Back to Profile')
+              .setStyle(ButtonStyle.Secondary)
+          );
+
+        await i.update({ embeds: [statsEmbed], components: [statsButtonRow] });
+      }
+
+      if (i.customId === 'backToProfile') {
+        await i.update({ embeds: [profileEmbed], components: buttonRow.components.length > 0 ? [buttonRow] : [] });
+      }
+    });
+  }
+});
+
+module.exports.clockedInUsers = clockedInUsers;

Commands/removeUser.js

@@ -0,0 +1,134 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.RemoveUser.Command,
+  description: cmdconfig.RemoveUser.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "user",
+      description: "The user to remove",
+      type: ApplicationCommandOptionType.User,
+      required: true,
+    },
+  ],
+  permissions: cmdconfig.RemoveUser.Permission,
+
+  async run(interaction) {
+
+    const { getRole } = interaction.client;
+    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+    if (!SupportStaff || !Admin) {
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+      );
+    }
+
+    const NoPerms = new EmbedBuilder()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
+      )
+      .setColor(supportbot.Embed.Colours.Warn);
+
+    if (
+      !interaction.member.roles.cache.has(SupportStaff.id) &&
+      !interaction.member.roles.cache.has(Admin.id)
+    ) {
+      return interaction.reply({ embeds: [NoPerms] });
+    }
+
+    const userToRemove = interaction.options.getUser("user");
+    const ticketChannel = interaction.channel;
+    const ticketDataPath = "./Data/TicketData.json";
+
+    // Check if the channel is a ticket thread or text channel based on TicketType
+    if (
+      (supportbot.Ticket.TicketType === "threads" && !ticketChannel.isThread()) ||
+      (supportbot.Ticket.TicketType === "channels" && ticketChannel.type !== ChannelType.GuildText)
+    ) {
+      const onlyInTicket = new EmbedBuilder()
+        .setTitle(msgconfig.RemoveUser.NotInTicket_Title)
+        .setDescription(msgconfig.RemoveUser.NotInTicket_Description)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      return interaction.reply({
+        embeds: [onlyInTicket],
+        ephemeral: true,
+      });
+    }
+
+    try {
+      // Remove user from thread or channel based on TicketType
+      if (supportbot.Ticket.TicketType === "threads") {
+        await ticketChannel.members.remove(userToRemove.id); // For threads
+      } else if (supportbot.Ticket.TicketType === "channels") {
+        await ticketChannel.permissionOverwrites.delete(userToRemove.id); // For channels
+      }
+
+      // Update the ticket data
+      const ticketData = JSON.parse(fs.readFileSync(ticketDataPath, "utf8"));
+      const ticketIndex = ticketData.tickets.findIndex((t) => t.id === ticketChannel.id);
+      if (ticketIndex !== -1) {
+        const subUsers = ticketData.tickets[ticketIndex].subUsers;
+        const userIndex = subUsers.indexOf(userToRemove.id);
+        if (userIndex !== -1) {
+          subUsers.splice(userIndex, 1);
+          fs.writeFileSync(ticketDataPath, JSON.stringify(ticketData, null, 4));
+        }
+      }
+
+      const removedEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.RemoveUser.Removed_Title)
+        .setDescription(msgconfig.RemoveUser.Removed_Message)
+        .setColor(supportbot.Embed.Colours.Success);
+
+      await interaction.reply({
+        embeds: [removedEmbed],
+        ephemeral: true,
+      });
+
+      const removedFromTicketEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.RemoveUser.RemovedFromTicket_Title)
+        .setDescription(msgconfig.RemoveUser.RemovedFromTicket_Description.replace(
+          "%channel_link%",
+          `[${ticketChannel.name}](https://discord.com/channels/${ticketChannel.guild.id}/${ticketChannel.id})`
+        ))
+        .setColor(supportbot.Embed.Colours.General);
+
+      await userToRemove.send({
+        embeds: [removedFromTicketEmbed],
+      });
+
+    } catch (err) {
+      console.error("Error removing user from the ticket:", err);
+
+      const errorEmbed = new EmbedBuilder()
+        .setTitle(msgconfig.RemoveUser.Error_Title)
+        .setDescription(msgconfig.RemoveUser.Error_Removing)
+        .setColor(supportbot.Embed.Colours.Error);
+
+      await interaction.reply({
+        embeds: [errorEmbed],
+        ephemeral: true,
+      });
+    }
+  },
+});

Commands/settings.js

@@ -0,0 +1,235 @@
+const { Command } = require('../Structures/Addon.js');
+const Discord = require("discord.js");
+const fs = require("fs");
+const yaml = require("js-yaml");
+const path = require("path");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const settingsFilePath = path.resolve(__dirname, '../Data/settings.json');
+
+function loadSettings() {
+  try {
+    if (fs.existsSync(settingsFilePath)) {
+      const data = fs.readFileSync(settingsFilePath, 'utf8');
+      return JSON.parse(data);
+    } else {
+      return {};
+    }
+  } catch (error) {
+    console.error("Error reading settings file:", error);
+    return {};
+  }
+}
+
+function saveSettings(settings) {
+  try {
+    fs.writeFileSync(settingsFilePath, JSON.stringify(settings, null, 2), 'utf8');
+  } catch (error) {
+    console.error("Error writing settings file:", error);
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.Settings.Command,
+  description: cmdconfig.Settings.Description,
+  permissions: cmdconfig.Settings.Permission,
+  options: [
+    {
+      name: 'setstatus',
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      description: 'Set the bot status',
+      options: [
+        {
+          name: 'status',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'Choose the bot status',
+          required: true,
+          choices: [
+            { name: 'Online 🟢', value: 'online' },
+            { name: 'Idle 🌙', value: 'idle' },
+            { name: 'Do Not Disturb ⛔', value: 'dnd' },
+            { name: 'Invisible 👻', value: 'invisible' }
+          ],
+        },
+      ],
+    },
+    {
+      name: 'setactivity',
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      description: 'Set the bot activity',
+      options: [
+        {
+          name: 'type',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'Choose the activity type',
+          required: true,
+          choices: [
+            { name: 'Playing 🎮', value: 'PLAYING' },
+            { name: 'Watching 👀', value: 'WATCHING' },
+            { name: 'Listening 🎧', value: 'LISTENING' },
+            { name: 'Competing 🏆', value: 'COMPETING' }
+          ],
+        },
+        {
+          name: 'message',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'The activity message',
+          required: true,
+        },
+      ],
+    },
+    {
+      name: 'streammode',
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      description: 'Set the bot streaming status',
+      options: [
+        {
+          name: 'toggle',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'Turn streaming mode on or off',
+          required: true,
+          choices: [
+            { name: 'On', value: 'on' },
+            { name: 'Off', value: 'off' }
+          ],
+        },
+        {
+          name: 'twitchurl',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'Twitch stream URL (Required if turning on)',
+          required: false,
+        },
+      ],
+    },
+    {
+      name: 'setnickname',
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      description: 'Set the bot nickname',
+      options: [
+        {
+          name: 'nickname',
+          type: Discord.ApplicationCommandOptionType.String,
+          description: 'The new nickname for the bot',
+          required: true,
+        },
+      ],
+    },
+  ],
+
+  async run(interaction) {
+    const subcommand = interaction.options.getSubcommand();
+    const settings = loadSettings();
+
+    if (subcommand === 'setstatus') {
+      const status = interaction.options.getString('status');
+
+      try {
+        interaction.client.user.setPresence({
+          status: status,
+          activities: interaction.client.user.presence.activities || [],
+        });
+
+        settings.status = status;
+        saveSettings(settings);
+
+        const embed = new Discord.EmbedBuilder()
+          .setDescription(`Status set to **${status.charAt(0).toUpperCase() + status.slice(1)}**`)
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set status: ${error.message}`, ephemeral: true });
+      }
+    } 
+    
+    if (subcommand === 'setactivity') {
+      const activityType = interaction.options.getString('type');
+      const activityMessage = interaction.options.getString('message');
+
+      try {
+        interaction.client.user.setPresence({
+          activities: [{ name: activityMessage, type: Discord.ActivityType[activityType] }],
+          status: interaction.client.user.presence.status || 'online',
+        });
+
+        settings.activity = { type: activityType, message: activityMessage };
+        saveSettings(settings);
+
+        const embed = new Discord.EmbedBuilder()
+          .setDescription(`Activity set to **${activityType.toLowerCase()} ${activityMessage}**`)
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set activity: ${error.message}`, ephemeral: true });
+      }
+    } else if (subcommand === 'streammode') {
+      const toggle = interaction.options.getString('toggle');
+      const twitchUrl = interaction.options.getString('twitchurl');
+
+      if (toggle === 'on') {
+        if (!twitchUrl) {
+          return interaction.reply({ content: 'Please provide a Twitch URL to stream.', ephemeral: true });
+        }
+
+        try {
+          interaction.client.user.setPresence({
+            activities: [{ name: 'Streaming', type: Discord.ActivityType.Streaming, url: twitchUrl }],
+            status: 'online',
+          });
+
+          settings.streaming = { active: true, url: twitchUrl };
+          saveSettings(settings);
+
+          const embed = new Discord.EmbedBuilder()
+            .setDescription(`**Streaming mode enabled!**\nStreaming: [Twitch](${twitchUrl})`)
+            .setColor(supportbot.Embed.Colours.General);
+
+          return interaction.reply({ embeds: [embed], ephemeral: true });
+        } catch (error) {
+          return interaction.reply({ content: `Failed to enable streaming mode: ${error.message}`, ephemeral: true });
+        }
+      } else if (toggle === 'off') {
+        try {
+          interaction.client.user.setPresence({
+            activities: interaction.client.user.presence.activities.filter(a => a.type !== Discord.ActivityType.Streaming),
+            status: settings.status || 'online',
+          });
+
+          settings.streaming = { active: false };
+          saveSettings(settings);
+
+          const embed = new Discord.EmbedBuilder()
+            .setDescription(`**Streaming mode disabled!**`)
+            .setColor(supportbot.Embed.Colours.General);
+
+          return interaction.reply({ embeds: [embed], ephemeral: true });
+        } catch (error) {
+          return interaction.reply({ content: `Failed to disable streaming mode: ${error.message}`, ephemeral: true });
+        }
+      }
+    } else if (subcommand === 'setnickname') {
+      const nickname = interaction.options.getString('nickname');
+
+      try {
+        const guild = interaction.guild;
+        const botMember = guild.members.cache.get(interaction.client.user.id);
+        await botMember.setNickname(nickname);
+
+        settings.nickname = nickname;
+        saveSettings(settings);
+
+        const embed = new Discord.EmbedBuilder()
+          .setDescription(`Bot nickname set to **${nickname}**`)
+          .setColor(supportbot.Embed.Colours.General);
+
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+      } catch (error) {
+        return interaction.reply({ content: `Failed to set nickname: ${error.message}`, ephemeral: true });
+      }
+    } else {
+      return interaction.reply({ content: 'Invalid command usage.', ephemeral: true });
+    }
+  },
+});

Commands/suggest.js

@@ -0,0 +1,115 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+// Load configurations
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+// Ensure suggestions file exists and is correctly loaded
+let suggestions;
+try {
+  suggestions = require("../Data/SuggestionData.json");
+} catch (error) {
+  suggestions = {};
+}
+
+module.exports = new Command({
+  name: cmdconfig.Suggestion.Command,
+  description: cmdconfig.Suggestion.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "suggestion",
+      description: "Create a Suggestion",
+      type: Discord.ApplicationCommandOptionType.String,
+      required: true,
+    },
+  ],
+  permissions: cmdconfig.Suggestion.Permission,
+
+  async run(interaction) {
+    const { getChannel } = interaction.client;
+
+    const suggestChannel = await getChannel(
+      supportbot.Suggestions.Channel,
+      interaction.guild
+    );
+
+    const NoChannel = new Discord.EmbedBuilder()
+      .setTitle("Missing Channel!")
+      .setDescription(msgconfig.Error.InvalidChannel)
+      .setColor(supportbot.Embed.Colours.Error);
+
+    if (!suggestChannel) return interaction.reply({ embeds: [NoChannel] });
+
+    let suggestion = interaction.options.getString("suggestion");
+
+    const SuggestEmbed = new Discord.EmbedBuilder()
+      .addFields(
+        { name: "Suggestion", value: suggestion, inline: true },
+        { name: "From", value: `<@${interaction.user.id}>` },
+        { name: `${supportbot.Suggestions.UpvoteEmoji} ${supportbot.Suggestions.UpvoteTitle}`, value: "0", inline: true },
+        { name: `${supportbot.Suggestions.DownvoteEmoji} ${supportbot.Suggestions.DownvoteTitle}`, value: "0", inline: true }
+      )
+      .setThumbnail(interaction.user.displayAvatarURL())
+      .setFooter({
+        text: supportbot.Embed.Footer,
+        iconURL: interaction.user.displayAvatarURL(),
+      })
+      .setColor(supportbot.Embed.Colours.General);
+
+    const UpvoteButton = new Discord.ButtonBuilder()
+      .setCustomId("upvote")
+      .setEmoji(supportbot.Suggestions.UpvoteEmoji)
+      .setStyle(supportbot.Suggestions.Buttons.Upvote);
+
+    const DownvoteButton = new Discord.ButtonBuilder()
+      .setCustomId("downvote")
+      .setEmoji(supportbot.Suggestions.DownvoteEmoji)
+      .setStyle(supportbot.Suggestions.Buttons.Downvote);
+
+    const RemoveVoteButton = new Discord.ButtonBuilder()
+      .setCustomId("removevote")
+      .setLabel(supportbot.Suggestions.Buttons.RemoveVote_Title)
+      .setStyle(supportbot.Suggestions.Buttons.RemoveVote); // Red button
+
+    const row = new Discord.ActionRowBuilder().addComponents(UpvoteButton, DownvoteButton, RemoveVoteButton);
+
+    const suggestionMsg = await suggestChannel.send({ embeds: [SuggestEmbed], components: [row] });
+
+    suggestions[suggestionMsg.id] = {
+      suggestion: suggestion,
+      author: interaction.user.id,
+      upvotes: [],
+      downvotes: []
+    };
+
+    fs.writeFileSync("./Data/SuggestionData.json", JSON.stringify(suggestions, null, 2));
+
+    if (supportbot.Suggestions.Threads.Enabled) {
+      await suggestionMsg.startThread({
+        name: supportbot.Suggestions.Threads.Title,
+        autoArchiveDuration: 60,
+        type: Discord.ChannelType.PublicThread,
+        reason: supportbot.Suggestions.Threads.Reason,
+      });
+    }
+
+    const Submitted = new Discord.EmbedBuilder()
+      .setTitle(`${msgconfig.Suggestions.Sent_Title}`)
+      .setDescription(`${msgconfig.Suggestions.Sent}`)
+      .addFields(
+        { name: "Sent to:", value: `<#${suggestChannel.id}>` },
+      )
+      .setColor(supportbot.Embed.Colours.Success);
+
+    await interaction.reply({ 
+      ephemeral: true, 
+      embeds: [Submitted] 
+    });
+  },
+});

Commands/ticket.js

@@ -0,0 +1,470 @@
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ChannelType,
+  ActionRowBuilder,
+  ButtonBuilder,
+  StringSelectMenuBuilder,
+  StringSelectMenuOptionBuilder,
+  ButtonStyle,
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const panelconfig = yaml.load(fs.readFileSync("./Configs/ticket-panel.yml", "utf8"));
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+const TicketNumberID = require("../Structures/TicketID.js");
+
+async function getClockedInUsers(guild) {
+  const clockedInUsers = new Set();
+
+  const profilesDir = './Data/Profiles';
+  const profileFiles = fs.readdirSync(profilesDir);
+
+  for (const file of profileFiles) {
+    const profileData = JSON.parse(fs.readFileSync(`${profilesDir}/${file}`, "utf8"));
+    if (profileData.clockedIn) {
+      const userId = file.replace('.json', '');
+      const member = await guild.members.fetch(userId);
+      if (member) clockedInUsers.add(member.id);
+    }
+  }
+  return clockedInUsers;
+}
+
+async function assignTicketToUser(ticketChannel, Staff, Admin, interaction, attempts = 0) {
+
+  try {
+    const clockedInUsers = await getClockedInUsers(interaction.guild);
+
+    if (clockedInUsers.size === 0 || attempts >= 2) {
+      const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
+      if (claimChannel) {
+        const claimEmbed = new EmbedBuilder()
+          .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
+          .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage)
+          .setColor(supportbot.Embed.Colours.General);
+
+        const claimButton = new ButtonBuilder()
+          .setCustomId(`claimticket-${ticketChannel.id}`)
+          .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle || 'Claim Ticket')
+          .setStyle(ButtonStyle.Primary);
+
+        const row = new ActionRowBuilder().addComponents(claimButton);
+
+        const claimMessage = await claimChannel.send({
+          content: `<@&${Staff.id}> <@&${Admin.id}>`,
+          embeds: [claimEmbed],
+          components: [row],
+        });
+
+        const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.member.roles.cache.has(Staff.id);
+        const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
+
+        collector.on('collect', async i => {
+          await ticketChannel.send({ content: `<@${i.user.id}> has claimed the ticket.` });
+        });
+
+        collector.on('end', async collected => {
+          if (collected.size === 0) {
+            await claimMessage.delete();
+
+            await claimChannel.send({
+              content: `Ticket is still unclaimed. \nCC: [<@&${Staff.id}> <@&${Admin.id}]`,
+              embeds: [new EmbedBuilder().setDescription(`Ticket is still unclaimed: <#${ticketChannel.id}>`).setColor(supportbot.Embed.Colours.Warn)],
+            });
+          }
+        });
+
+        return null;
+      } else {
+        console.error("Claim channel not found");
+        return null;
+      }
+    }
+
+    const clockedInArray = Array.from(clockedInUsers);
+    const assignedUserId = clockedInArray[Math.floor(Math.random() * clockedInArray.length)];
+    const assignedUser = await interaction.guild.members.fetch(assignedUserId);
+
+    const claimEmbed = new EmbedBuilder()
+      .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
+      .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage.replace('%user%', interaction.user.id))
+      .setColor(supportbot.Embed.Colours.General);
+
+    const claimButton = new ButtonBuilder()
+      .setCustomId(`claimticket-${ticketChannel.id}`)
+      .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle || 'Claim Ticket')
+      .setStyle(ButtonStyle.Primary);
+
+    const row = new ActionRowBuilder().addComponents(claimButton);
+
+    const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
+    if (!claimChannel) {
+      console.error("Claim channel not found");
+      return null;
+    }
+
+    const claimMessage = await claimChannel.send({
+      content: `${assignedUser}`,
+      embeds: [claimEmbed],
+      components: [row],
+    });
+
+    const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.user.id === assignedUserId;
+    const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
+
+    collector.on('collect', async i => {
+      await ticketChannel.send({ content: `<@${assignedUserId}>` }).then(msg => setTimeout(() => msg.delete(), 5000));
+    });
+
+    collector.on('end', async collected => {
+      if (collected.size === 0) {
+        await claimMessage.delete();
+
+        if (attempts >= 1) {
+          await claimChannel.send({
+            content: `No one claimed the ticket. Tagging roles: <@&${Staff.id}> <@&${Admin.id}>`,
+            embeds: [new EmbedBuilder().setDescription(`Ticket is still unclaimed: <#${ticketChannel.id}>`).setColor(supportbot.Embed.Colours.Warn)],
+          });
+
+          const claimEmbed = new EmbedBuilder()
+            .setTitle(msgconfig.Ticket.ClaimTickets.ClaimTitle)
+            .setDescription(msgconfig.Ticket.ClaimTickets.ClaimMessage)
+            .setColor(supportbot.Embed.Colours.General);
+
+          const claimButton = new ButtonBuilder()
+            .setCustomId(`claimticket-${ticketChannel.id}`)
+            .setLabel(supportbot.Ticket.ClaimTickets.ButtonTitle)
+            .setEmoji(supportbot.Ticket.ClaimTickets.ButtonEmoji)
+            .setStyle(ButtonStyle.Primary);
+
+          const row = new ActionRowBuilder().addComponents(claimButton);
+
+          const claimMessage = await claimChannel.send({
+            embeds: [claimEmbed],
+            components: [row],
+          });
+
+          const filter = i => i.customId === `claimticket-${ticketChannel.id}` && i.member.roles.cache.has(Staff.id);
+          const collector = claimMessage.createMessageComponentCollector({ filter, time: 120000 });
+
+          collector.on('collect', async i => {
+            console.log(`Ticket ${ticketChannel.id} claimed by user ${i.user.id}`);
+            await ticketChannel.member.add(i.user.id);
+          });
+
+          collector.on('end', async collected => {
+            if (collected.size === 0) {
+              console.log(`No one claimed the ticket (${ticketChannel.id}), notifying all staff`);
+              await claimMessage.delete();
+
+              await claimChannel.send({
+                content: `No one claimed the ticket. Tagging roles: <@&${Staff.id}> <@&${Admin.id}>`,
+              });
+            }
+          });
+        } else {
+          const ReassigningEmbed = new EmbedBuilder()
+            .setTitle(msgconfig.Ticket.ClaimTickets.ReassigningTitle)
+            .setDescription(msgconfig.Ticket.ClaimTickets.ReassigningMessage.replace('%user%', assignedUserId))
+            .setColor(supportbot.Embed.Colours.General);
+
+          await claimChannel.send({ embeds: [ReassigningEmbed], components: [] });
+          await assignTicketToUser(ticketChannel, Staff, Admin, interaction, attempts + 1);
+        }
+      }
+    });
+
+    return assignedUserId;
+  } catch (error) {
+    console.error("Error in assignTicketToUser function:", error);
+    if (error instanceof CombinedError) {
+      console.error("CombinedError details:", error.errors);
+    }
+    return null;
+  }
+}
+
+module.exports = new Command({
+  name: cmdconfig.OpenTicket.Command,
+  description: cmdconfig.OpenTicket.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [
+    {
+      name: "reason",
+      description: "Ticket Reason",
+      type: ApplicationCommandOptionType.String,
+    },
+  ],
+  permissions: cmdconfig.OpenTicket.Permission,
+
+  async run(interaction) {
+    try {
+      let TicketReason = null;
+      if (supportbot.Ticket.TicketReason) {
+        TicketReason = interaction.reason || null; // Retrieve the reason from the interaction object
+      }
+
+      let TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+      const { getRole, getChannel } = interaction.client;
+      let User = interaction.guild.members.cache.get(interaction.user.id);
+
+      if (
+        supportbot.Ticket.TicketsPerUser &&
+        TicketData.tickets.filter((t) => t.user === interaction.user.id && t.open).length >= supportbot.Ticket.TicketsPerUser
+      ) {
+        return interaction.reply({
+          embeds: [
+            {
+              title: "Too Many Tickets!",
+              description: `You can't have more than ${supportbot.Ticket.TicketsPerUser} open tickets!`,
+              color: supportbot.Embed.Colours.Warn,
+            },
+          ],
+          ephemeral: true,
+        });
+      }
+
+      if (User.roles.cache.has(supportbot.Roles.ModRoles.Blacklisted)) {
+        return interaction.reply({
+          content: msgconfig.Ticket.Blacklisted,
+          ephemeral: true,
+        });
+      }
+
+      if (User.roles.cache.has(supportbot.Roles.ModRoles.Muted)) {
+        return interaction.reply({
+          content: msgconfig.Ticket.Muted,
+          ephemeral: true,
+        });
+      }
+
+      let ticketNumberID = await TicketNumberID.pad();
+      const TicketSubject = TicketReason || msgconfig.Ticket.InvalidSubject;
+
+      const TicketExists = new EmbedBuilder()
+        .setTitle("Ticket Exists!")
+        .setDescription(msgconfig.Ticket.TicketExists);
+
+      if (
+        await interaction.guild.channels.cache.find(
+          (ticketChannel) => ticketChannel.name === `${supportbot.Ticket.Channel}${ticketNumberID}`
+        )
+      ) {
+        return await interaction.reply({
+          embeds: [TicketExists],
+          ephemeral: true,
+        });
+      }
+
+      const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+      if (!Staff || !Admin)
+        return interaction.reply({
+          content: "Some roles seem to be missing!\nPlease check for errors when starting the bot.",
+          ephemeral: true,
+        });
+
+      let ticketChannel;
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        const TicketHome = interaction.guild.channels.cache.find(
+          (c) => c.name === supportbot.Ticket.TicketHome || c.id === supportbot.Ticket.TicketHome
+        );
+
+        const channel = await getChannel(supportbot.Ticket.TicketHome, interaction.guild);
+        ticketChannel = await channel.threads.create({
+          name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
+          type: ChannelType.PrivateThread,
+          parent: TicketHome,
+          autoArchiveDuration: 60,
+          reason: 'support ticket',
+        });
+      } else if (supportbot.Ticket.TicketType === "channels") {
+        const category = interaction.guild.channels.cache.find(
+          (c) => c.name === supportbot.Ticket.TicketChannelsCategory || c.id === supportbot.Ticket.TicketChannelsCategory
+        );
+
+        if (!category) {
+          return interaction.reply({
+            content: "The ticket category does not exist!",
+            ephemeral: true,
+          });
+        }
+
+        ticketChannel = await interaction.guild.channels.create({
+          name: `${supportbot.Ticket.Channel}${ticketNumberID}`,
+          type: ChannelType.GuildText,
+          parent: category.id,
+          reason: 'support ticket',
+        });
+
+        // Move to secondary category if the primary one is full
+        if (category.children.size >= 50) {
+          const secondaryCategory = interaction.guild.channels.cache.find(
+            (c) => c.name === supportbot.Ticket.TicketChannelsCategory2 || c.id === supportbot.Ticket.TicketChannelsCategory2
+          );
+
+          if (secondaryCategory) {
+            await ticketChannel.setParent(secondaryCategory.id);
+          } else {
+            return interaction.reply({
+              content: "The secondary ticket category does not exist!",
+              ephemeral: true,
+            });
+          }
+        }
+      }
+
+      // Assign ticket to a user if claiming tickets is enabled
+      if (supportbot.Ticket.ClaimTickets.Enabled) {
+        const assignedUserId = await assignTicketToUser(ticketChannel, Staff, Admin, interaction);
+        if (!assignedUserId) {
+          const claimChannel = await interaction.guild.channels.cache.get(supportbot.Ticket.ClaimTickets.Channel);
+        }
+      }
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        await ticketChannel.members.add(interaction.user.id); 
+
+    } else if (supportbot.Ticket.TicketType === "channels") {
+
+        await ticketChannel.permissionOverwrites.create(interaction.user.id, {
+            ViewChannel: true,
+            SendMessages: true,
+            ReadMessageHistory: true,
+        }); 
+
+        await ticketChannel.permissionOverwrites.create(Admin, {
+          ViewChannel: true,
+          SendMessages: true,
+          ReadMessageHistory: true,
+      }); 
+
+        await ticketChannel.permissionOverwrites.create(interaction.guild.roles.everyone, {
+          ViewChannel: false,
+        }); 
+    }
+    
+      // Save ticket data
+      TicketData.tickets.push({
+        id: ticketChannel.id,
+        name: ticketChannel.name,
+        user: interaction.user.id,
+        number: ticketNumberID,
+        reason: TicketSubject,
+        open: true,
+        subUsers: [],
+        createdAt: new Date().toISOString(),
+        claimedAt: null,
+      });
+
+      fs.writeFileSync(
+        "./Data/TicketData.json",
+        JSON.stringify(TicketData, null, 4),
+        (err) => {
+          if (err) console.error(err);
+        }
+      );
+
+      // Notify the user that the ticket was created
+      const CreatedTicket = new EmbedBuilder()
+        .setDescription(
+          msgconfig.Ticket.TicketCreatedAlert.replace(/%ticketauthor%/g, interaction.user.id)
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username)
+            .replace(/%ticketreason%/g, TicketSubject)
+        )
+        .setColor(supportbot.Embed.Colours.General);
+      await interaction.reply({ embeds: [CreatedTicket], ephemeral: true });
+
+      // Create the ticket message
+      const TicketMessage = new EmbedBuilder()
+        .setAuthor({
+          name: msgconfig.Ticket.TicketAuthorTitle.replace(/%ticketauthor%/g, interaction.user.id)
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username),
+          iconURL: interaction.user.displayAvatarURL(),
+        })
+        .setTitle(
+          msgconfig.Ticket.TicketTitle.replace(/%ticketauthor%/g, interaction.user.id)
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username)
+        )
+        .setDescription(
+          msgconfig.Ticket.TicketMessage.replace(/%ticketauthor%/g, interaction.user.id)
+            .replace(/%ticketid%/g, ticketChannel.id)
+            .replace(/%ticketusername%/g, interaction.user.username)
+            .replace(/%ticketreason%/g, TicketSubject)
+        )
+        .setColor(supportbot.Embed.Colours.General);
+
+      // Add reason field if ticket reason is enabled
+      if (supportbot.Ticket.TicketReason && TicketReason) {
+        TicketMessage.addFields(
+          { name: "Reason", value: TicketReason, inline: false }
+        );
+      }
+
+      // Create the control panel
+      const SelectMenus = new StringSelectMenuBuilder()
+      .setCustomId("ticketcontrolpanel")
+      .setPlaceholder("Ticket Control Panel")
+      .addOptions(
+        new StringSelectMenuOptionBuilder()
+          .setLabel("Close")
+          .setDescription("Close the ticket.")
+          .setEmoji(supportbot.SelectMenus.Tickets.CloseEmoji)
+          .setValue("ticketclose"),
+        new StringSelectMenuOptionBuilder()
+          .setLabel("Archive")
+          .setDescription("Archive the ticket.")
+          .setEmoji(supportbot.SelectMenus.Tickets.ArchiveEmoji)
+          .setValue("archiveticket"),
+        ...(supportbot.Ticket.TicketType === "threads" ? [
+          new StringSelectMenuOptionBuilder()
+            .setLabel("Lock Ticket")
+            .setDescription("Lock the ticket.")
+            .setEmoji(supportbot.SelectMenus.Tickets.LockEmoji)
+            .setValue("lockticket")
+        ] : []), 
+        new StringSelectMenuOptionBuilder()
+          .setLabel("Rename Ticket")
+          .setDescription("Rename the ticket.")
+          .setEmoji(supportbot.SelectMenus.Tickets.RenameEmoji)
+          .setValue("renameticket")
+      );
+
+        if (supportbot.Ticket.TicketType === "threads") {
+          SelectMenus.addOptions(
+            new StringSelectMenuOptionBuilder()
+              .setLabel("Enable Invites")
+              .setDescription("Enable invites.")
+              .setEmoji(supportbot.SelectMenus.Tickets.EnableInvitesEmoji)
+              .setValue("enableinvites"),
+            new StringSelectMenuOptionBuilder()
+              .setLabel("Disable Invites")
+              .setDescription("Disable invites.")
+              .setEmoji(supportbot.SelectMenus.Tickets.DisableInvitesEmoji)
+              .setValue("disableinvites"),
+          );
+        }
+
+      const row2 = new ActionRowBuilder().addComponents(SelectMenus);
+
+      await ticketChannel.send({
+        embeds: [TicketMessage],
+        components: [row2],
+      });
+
+    } catch (error) {
+      console.error("Error in run method:", error);
+    }
+  },
+});

Commands/ticketpanel.js

@@ -0,0 +1,120 @@
+// ticketpanel.js
+const fs = require("fs");
+const {
+  EmbedBuilder,
+  ApplicationCommandType,
+  ActionRowBuilder,
+  ButtonBuilder,
+} = require("discord.js");
+const yaml = require("js-yaml");
+
+const panelconfig = yaml.load(fs.readFileSync("./Configs/ticket-panel.yml", "utf8"));
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+const Command = require("../Structures/Command.js");
+
+module.exports = new Command({
+  name: cmdconfig.TicketPanel.Command,
+  description: cmdconfig.TicketPanel.Description,
+  type: ApplicationCommandType.ChatInput,
+  options: [],
+  permissions: cmdconfig.TicketPanel.Permission,
+
+  async run(interaction) {
+    if (!panelconfig.Panel) {
+      console.log(
+        "\u001b[31m",
+        `[TICKET PANEL]`,
+        "\u001b[33m",
+        "Ticket Panel is not setup, You can set this in", `\u001b[31m`, '/Configs/ticket-panel.yml', `\n  `,
+      );
+      return interaction.reply({
+        content: "Ticket Panel is not set up. Please configure it in `/Configs/ticket-panel.yml`.",
+        ephemeral: true,
+      });
+    }
+
+    const { getChannel } = interaction.client;
+
+    const channel = await getChannel(
+      supportbot.Ticket.TicketHome,
+      interaction.guild
+    );
+
+    if (!channel) {
+      console.log(`[TICKET PANEL] ${channelName} channel not found. Please check your config file.`);
+      return interaction.reply({
+        content: `${channelName} channel not found. Please check your config file.`,
+        ephemeral: true,
+      });
+    }
+
+    const panelid = JSON.parse(fs.readFileSync("./Data/ticket-panel-id.json", "utf8"));
+
+    try {
+      await channel.messages.fetch(panelid.TicketPanelID);
+      return interaction.reply({
+        content: "Ticket panel message already exists.",
+        ephemeral: true,
+      });
+    } catch (error) {
+      let embed = new EmbedBuilder()
+        .setTitle(panelconfig.PanelTitle)
+        .setColor(panelconfig.PanelColour)
+        .setFooter({
+          text: supportbot.Embed.Footer,
+          iconURL: interaction.user.displayAvatarURL(),
+        });
+
+      if (panelconfig.TicketPanel_Description) {
+        embed.setDescription(panelconfig.PanelMessage);
+      }
+
+      if (panelconfig.TicketPanel_Thumbnail) {
+        embed.setThumbnail(panelconfig.PanelThumbnail);
+      }
+
+      if (panelconfig.TicketPanel_Image) {
+        embed.setImage(panelconfig.PanelImage);
+      }
+
+      const createTicketButton = new ButtonBuilder()
+        .setCustomId("createticket")
+        .setLabel(panelconfig.Button.Text)
+        .setEmoji(panelconfig.Button.Emoji)
+        .setStyle(panelconfig.Button.Color);
+
+      let row = new ActionRowBuilder().addComponents(createTicketButton);
+
+      try {
+        const message = await channel.send({
+          embeds: [embed],
+          components: [row],
+        });
+
+        let data = {
+          id: panelid.id,
+          TicketPanelID: message.id,
+        };
+
+        fs.writeFileSync(
+          "./Data/ticket-panel-id.json",
+          JSON.stringify(data),
+          "utf8"
+        );
+
+        return interaction.reply({
+          content: "Ticket panel message has been sent!",
+          ephemeral: true,
+        });
+      } catch (e) {
+        console.log("Error sending message:", e);
+        return interaction.reply({
+          content: "An error occurred while sending the ticket panel message.",
+          ephemeral: true,
+        });
+      }
+    }
+  },
+});

Commands/translate.js

@@ -0,0 +1,117 @@
+// SupportBot | Emerald Services
+// Translate Command
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+const cmdconfig = yaml.load(
+  fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+
+const msgconfig = yaml.load(
+  fs.readFileSync("./Configs/messages.yml", "utf8")
+)
+
+const Command = require("../Structures/Command.js");
+const translate = require("@vitalets/google-translate-api");
+
+module.exports = new Command({
+  name: cmdconfig.Translate.Command,
+  description: cmdconfig.Translate.Description,
+  type: Discord.ApplicationCommandType.ChatInput,
+  options: [
+    {
+      type: Discord.ApplicationCommandOptionType.String,
+      name: "language",
+      description: "A 2 letter language code",
+      required: true,
+    },
+    {
+      type: Discord.ApplicationCommandOptionType.String,
+      name: "text",
+      description: "The text to translate",
+      required: true,
+    }, // The input text for the translation
+  ],
+  permissions: cmdconfig.Translate.Permission, // The permission the user/role at least requires
+
+  async run(interaction) {
+    let disableCommand = true;
+
+    const { getRole } = interaction.client;
+    let SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+    let Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+    if (!SupportStaff || !Admin)
+    
+      return interaction.reply(
+        "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+      );
+
+      const NoPerms = new Discord.EmbedBuilder()
+      .setTitle("Invalid Permissions!")
+      .setDescription(
+        `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
+      )
+      .setColor(supportbot.Embed.Colours.Warn);
+
+    if (
+      !interaction.member.roles.cache.has(SupportStaff.id) &&
+      !interaction.member.roles.cache.has(Admin.id)
+    )
+      return interaction.reply({ embeds: [NoPerms] });
+
+    const { getChannel } = interaction.client;
+    let lang = interaction.options.getString("language"); // Grab choice of language code by user
+    let url = "https://www.science.co.il/language/Codes.php"; // URL to all available language codes
+    let text = await interaction.options.getString("text"); // Grab the text to translate by the user
+    let translatelog = await getChannel(
+      supportbot.Translate.TranslateLog,
+      interaction.guild
+    ); // Grab the set logging channel for translations
+
+
+    // Return message if user has provided an invalid language code
+    const result = await translate(text, { to: lang }).catch(async (err) => {
+      if (err && err.code == 400) {
+        await interaction.reply({
+          embeds: [
+            new Discord.EmbedBuilder()
+              .setColor(supportbot.Embed.Colours.Warn)
+              .setTitle("Valid Language Codes")
+              .setURL(url)
+              .setDescription(
+                "Click the title to see which 2 letter language codes are valid."
+              ),
+          ],
+          ephemeral: true,
+        });
+      }
+    });
+    if (!result) return;
+
+    // Embed containing language code, original text and translated text
+    let transembed = new Discord.EmbedBuilder()
+      .setAuthor({ name: interaction.user.tag, iconURL: interaction.user.displayAvatarURL({ dynamic: true }) })
+      .setColor(supportbot.Embed.Colours.Success)
+      .setDescription(`**Translation to ${lang}**`)
+      .addFields(
+        { name: "Original text", value: text },
+        { name: "Translated text", value: result.text },
+      )
+      .setFooter({ text: `Author: ${interaction.user.id}` })
+      .setTimestamp();
+
+    // Send embed [transembed] with translated message to channel
+    await interaction.reply({ embeds: [transembed] });
+
+    // Send embed [transembed] to logging channel
+    await translatelog.send({ embeds: [transembed] });
+  },
+  
+})

Configs/commands.yml

@@ -0,0 +1,127 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://dsc.gg/emerald-dev
+#           Official Documentation: https://emeraldsrv.dev/wiki
+#           Third-Party Documentation: https://emeraldsrv.dev/third-party
+#
+#           Command Configuration
+
+# If you don't want to mess with this configuration, You can manage commands via Discord Settings the Intregations.
+
+Help:
+  Command: "help"
+  Description: "Get a list of all the commands."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+Info:
+  Command: "info"
+  Description: "Get information about the **ServerName**."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+TicketPanel:
+  Command: "ticketpanel"
+  Description: "Create the ticket creation panel"
+  Permission: ["Administrator"]
+  Enabled: true  
+
+Profile:
+  Command: "profile"
+  Description: "Shows the profile for a discord member."
+  Permission: ["SendMessages"]
+  # Command is automatically disabled when the TicketClaims is disabled.
+
+OpenTicket:
+  Command: "ticket"
+  Description: "Create a support ticket."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+AddUser:
+  Command: "add"
+  Description: "Add a user to a support ticket."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+ForceAddUser:
+  Command: "forceadd"
+  Description: "Add a user to a support ticket by bypassing the invite system."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+RemoveUser:
+  Command: "remove"
+  Description: "Remove a user from a support ticket."
+  Permission: ["SendMessages"]
+  Enabled: true
+  
+CloseTicket:
+  Command: "close"
+  Description: "Close a support ticket"
+  Permission: ["SendMessages"]
+  Enabled: true
+
+Suggestion:
+  Command: "suggest"
+  Description: "Create a suggestion."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+Embed:
+  Command: "embed"
+  Description: "Build a discord embed."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+Translate:
+  Command: "translate"
+  Description: "Translate something to english"
+  Permission: ["SendMessages"]
+  Enabled: false
+
+UserInfo:
+  Command: "userinfo"
+  Description: "Get info about a user."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+Ping:
+  Command: "ping"
+  Description: "Pong."
+  Permission: ["SendMessages"]
+  Enabled: true
+
+# ---------------------------------------
+#   Bot Administrator Commands
+# ---------------------------------------
+
+Settings:
+  Command: "settings"
+  Description: "Update bot settings."
+  Permission: ["Administrator"]
+  Enabled: true
+
+# ---------------------------------------
+#   Command Description Configuration
+# ---------------------------------------
+
+BlacklistDesc: "Blacklist a user from creating Tickets."
+TicketAddDesc: "Add a user to a support ticket."
+TicketRemoveDesc: "Remove a user from a support ticket."
+TranslateCommandDesc: "Translates the language provided, along with the abbreviation (2 char) long language code"
+OpenTicketDesc: "Open a new support ticket."
+CloseTicketDesc: "Close your support ticket."
+InfoCommandDesc: "Get information about the brand."
+PingCommandDesc: "Pong!"
+HelpCommandDesc: "Get a list of all the commands."
+EmbedCommandDesc: "Send a message as an embed."
+SuggestCommandDesc: "Suggest a feature for the server."
+UserInfoCommandDesc: "Get info about a user."

Configs/messages.yml

@@ -0,0 +1,183 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://dsc.gg/emerald-dev
+#           Official Documentation: https://emeraldsrv.com/wiki
+#           Third-Party Documentation: https://emeraldsrv.com/third-party
+#
+#           Messages Configuration
+
+Info:
+  Title: "About Us"
+  Description: "SupportBot is an open-sourced support system for discord. It's completely free to use with high amounts of customization to match your own brand."
+  Button: "Visit Site"
+  URL: "https://docs.emeraldsrv.com"
+  Colour: "#f74343"
+
+Welcome:
+  Embed:
+    Colour: "#f74343"
+    Title: "Welcome to ServerName"
+    Message: ":smile: %joined_user% has just landed!"
+    Thumbnail: "BOT"
+
+    ImageEnabled: false
+    ImageURL: "https://animagelink.png/"
+
+Leave:
+  Embed:
+    Colour: "#f74343"
+    Title: "Goodbye!"
+    Message: ":slight_frown: %joined_user% has recently dropped out!"
+    Thumbnail: "BOT"
+
+    ImageEnabled: false
+    ImageURL: "https://animagelink.png/"
+
+Suggestions:
+  Sent_Title: "Suggestion Sent!"
+  Sent: ":white_check_mark: **You have successfully sent a suggestion.**"
+  NoSelfVote: ":x: **You cannot vote on your own suggestion.**"
+  RemoveVoteButton: "Remove Vote"
+
+Ticket:
+
+#  Available Placeholders:
+
+#  %ticketusername% - User who created the ticket.
+#  <@%ticketauthor%> - Tags the user who created the ticket.
+#  <#%ticketid%> - Mentions the ticket channel.
+
+  TicketAuthorTitle: "%ticketusername%'s Ticket"
+  TicketTitle: "Support Ticket"
+  TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
+  TicketThumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
+  TicketCreatedAlert: ":ticket: Ticked Created: <#%ticketid%>"
+  TicketExists: "❌ Ticket already exists"
+  TicketClaim: ":white_check_mark: Ticket claimed by" #The user who claimed the ticket will be added to the end of this message
+  TicketUnclaim: ":white_check_mark: Ticket unclaimed by" #The user who claimed the ticket will be added to the end of this message
+
+  TicketArchived: ":white_check_mark: Ticket archived."
+  TicketUnarchived: ":white_check_mark: Ticket unarchived."
+  TicketLocked: ":lock: Ticket is locked."
+  DisableInvites: "🔒 Invites have been disabled for this ticket." 
+  EnableInvites: "🔓 Invites have been enabled for this ticket." 
+
+#  Available Placeholders:
+
+#  <@%user%> - Tags the user who was added to the ticket.
+
+  Blacklisted: ":x: You are not allowed to open a ticket"
+  Muted: ":x: You are `Muted` and therefore not allowed to open any tickets"
+  InvalidSubject: "No Reason Provided!"
+
+  ConfirmClose: "Please confirm closing the ticket by clicking the button below."
+  CloseTimeout: "Ticket close confirmation timed out."
+
+  RenamedSuccess: "🏷️ Ticket renamed successfully!"
+
+  ClaimTickets:
+    ClaimTitle: "Incoming Support Request!"
+    ClaimMessage: "A new ticket has been created by <@!%user%>. Click the button below to claim this ticket."
+    ClaimMessage_Edit: "<#%channel%> was claimed by <@!%user%>."
+
+    ClaimedTitle: "Ticket Claimed!"
+    Claimed: "You have successfully claimed this ticket. <#%channel%>"
+    NoPermsToClaimTitle: "Error, no permissions!"
+    NoPermsToClaim: ":x: **Err!** You do not permissions to claim this ticket."
+
+    ReassigningTitle: "Reassigning!..."
+    ReassigningMessage: "<@%user%> did not claim the ticket. **Reassigning...**"
+
+TicketStats: 
+  OpenTickets: "✅ Open Tickets"
+  TotalTickets: "🎫 Total Tickets"
+  ResponseTime: "⏱️ Average Response Time"
+
+  Title: "Your Ticket Stats"
+
+TicketLog:
+  Title: "Ticket Log"
+  Colour: "#0cc559"
+
+AddUser:
+  NotInTicket_Title: "Ticket Invitation"
+  NotInTicket_Description: "This command can only be used within a ticket thread."
+  
+  Invite_Title: "User Invited"
+  Invite_Description: "%username% has been invited to join the ticket."
+
+  DM_Title: "Ticket Invitation"
+  DM_Description: "You have been invited to join the ticket %channelname%. Do you accept?"
+  
+  Accept_Label: "Accept"
+  Reject_Label: "Reject"
+  ViewTicket_Label: "Go to Ticket"
+  
+  Accepted_Title: "Invitation Accepted"
+  Accepted_Message: "You have been added to the ticket."
+  AddedToTicket_Title: "Added to Ticket"
+  AddedToTicket_Description: "You have been added to the ticket %channel_link%."
+
+  # Added Message for inside the ticket, this informs everyone inside the ticket that the user has been added.
+  Added_Title: "User Added"
+  Added_Description: "Successfully added **%username%** to the ticket."
+  
+  Declined_Title: "Invitation Declined"
+  Declined_Message: "You have declined the invitation."
+  
+  NoResponse_Title: "No Response"
+  NoResponse_Message: "You did not respond in time. Please contact staff if you wish to join the ticket."
+  
+  Error_Title: "Error"
+  Error_Adding: "There was an error adding you to the ticket. Please try again."
+  
+  DM_Error_Title: "Error"
+  DM_Error_Description: "Unable to send a DM to %username%. Please ensure your DMs are enabled."
+  
+  Unexpected_Error_Title: "Error"
+  Unexpected_Error_Description: "An unexpected error occurred: %error%"
+
+RemoveUser:
+  NotInTicket_Title: "Error"
+  NotInTicket_Description: "This command can only be used in ticket threads."
+  
+  Removed_Title: "User Removed"
+  Removed_Message: "The user has been successfully removed from the ticket."
+  
+  RemovedFromTicket_Title: "Removed from Ticket"
+  RemovedFromTicket_Description: "You have been removed from the ticket channel %channel_link%."
+
+  Error_Title: "Error"
+  Error_Removing: "There was an error removing the user from the ticket."
+
+ForceAddUser:
+  NotInTicket_Title: "Not a Ticket"
+  NotInTicket_Description: "This command can only be used within a ticket thread."
+
+  Added_Title: "User Added"
+  Added_Description: "Successfully added %username% to the ticket."
+
+  AddedToTicket_Title: "You have been added to a Ticket"
+  AddedToTicket_Description: "You have been added to the ticket channel [%channel_link%]."
+
+  Error_Title: "Error"
+  Error_Adding: "There was an error adding the user to the ticket."
+
+Error:
+  IncorrectPerms: ":x: **Err!** You do not have the correct permissions to use this."
+  InvalidChannel: ":x: **Err!** Channel not found. Please create it!"
+  UserNotFound: ":x: **Err!** This user doesn't exist, Are they in this server?"
+  NoValidTicket: ":warning: You cannot execute this command here."
+  TicketExists: ":warning: This ticket cannot be opened, It already exists!"
+
+
+
+
+  

Configs/supportbot-ai.yml

@@ -0,0 +1,39 @@
+# -------------------------
+#   SupportBot AI
+#
+# In order to use the SupportBot AI, You need to setup an OpenAI Account. 
+# this can be done at https://platform.openai.com/
+# -------------------------
+
+Enabled: true
+
+General:
+  Name: "SupportBot AI"
+  # What would you like to call your AI
+  Model: "gpt-4o-mini"
+  # You can see a list of OpenAI Models here: https://platform.openai.com/docs/models
+
+  Tokens: 400
+  # Max tokens you can set is 400
+  # For more information about tokens, go to https://openai.com/api/pricing/
+  OpenAI_Key: "OPEN_AI_API_KEY"
+  # To create an OpenAI API key, go to https://platform.openai.com/api-keys
+
+
+  PastebinAPI_Key: "PASTEBIN_API_KEY"
+  # You can get your Pastebin API Key from https://pastebin.com
+  PastebinAPI_URL: "https://pastebin.com/api/api_post.php" 
+
+Channels:
+  AIChannel: "AI_BOT_CHANNEL"
+  # This is the channel where AI will respond in without needing to mention the bot.
+
+Embed:
+  Color: 0x0cc559  # 0x<hexcode>
+  Footer: "SupportBot | Developed by Emerald Development"
+
+Messages:
+  MessageTooLong: "The response was too long, so I've posted it here: {pastebin}"
+  ErrorResponse: "I didn't receive a proper response from OpenAI. Please try again later."
+  OpenAIError: "I'm having some trouble talking to SupportBot AI's Model, OpenAI. Please try again later."
+  AIDisabled: "I am disabled, You have enable me in `supportbot-ai.yml`"

Configs/supportbot.yml

@@ -0,0 +1,242 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Development
+#           Installed with MIT License
+#
+#           Discord Support: https://dsc.gg/emerald-dev
+#           Official Documentation: https://github.com/Emerald-Services/SupportBot/wiki
+#           Third-Party Documentation: COMING SOON
+
+SupportBot_Version: "v8.2"
+# Do not change the version number
+
+# -------------------------
+#   General
+# -------------------------
+
+General:
+  Name: "SupportBot"
+  Token: "BOT_TOKEN_HERE"
+  # To get your Discord Bot Token, Go to https://discord.com/developers/applications
+
+  Addons:
+    Enabled: true
+    
+# -------------------------
+#  Activity
+# -------------------------
+
+Activity:
+  Status: "SupportBot v8"
+  Type: "Competing"
+  # The Type can either be Playing, Watching, Listening or Competing
+  StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
+  # Set The Type to "Streaming" for a streaming status!
+
+  # You can update the activity via Discord using: /settings
+
+# -------------------------
+#  Embeds
+# -------------------------
+
+Embed:
+  Colours:
+    General: 0x0cc559 # 0x<hexcode>
+    Success: 0x04b545 # 0x<hexcode>
+    Error: 0xd13030 # 0x<hexcode>
+    Warn: 0xfca117 # 0x<hexcode>
+
+  Footer: "SupportBot | Developed by Emerald Development"
+
+# -------------------------
+#  Roles
+# -------------------------
+
+Roles:
+  AutoRole:
+    Enabled: true
+    Role: "ROLE_ID"
+
+  StaffMember:
+    Staff: "STAFF_ROLE_ID"
+    Admin: "ADMIN_ROLE_ID"
+
+  ModRoles:
+    Muted: "MUTED_ROLE_ID"
+    Blacklisted: "BLACKLISTED_ROLE_ID"
+
+# ----------------------------
+#  System Messages
+# ----------------------------
+
+Welcome: 
+  Enabled: true
+  Channel: "WELCOME_CHANNEL_ID"
+
+Leave: 
+  Enabled: true
+  Channel: "LEAVE_CHANNEL_ID"
+
+# ----------------------------
+#  Suggestions
+# ----------------------------
+
+Suggestions:
+  Channel: "SUGGEST_CHANNEL_ID"
+  UpvoteEmoji: "✅"
+  DownvoteEmoji: "❌"
+
+  UpvoteTitle: "Yes"
+  DownvoteTitle: "No"
+
+  OwnSuggestion: true
+  # If false this will not allow the user to vote for a suggestion they created
+  # If true this will allow the user to vote for a suggestion they created
+
+  ShowUsers: true
+  
+  Threads:
+    Enabled: true
+    Title: "Suggestion-releated Thread"
+    Reason: "A thread releted to this suggestion"
+
+  Buttons:
+    Upvote: "2"
+    Downvote: "2"
+    RemoveVote: "4"
+    RemoveVote_Title: "Remove Vote"
+
+    # Available Button Styles
+    # 1 - Blurple
+    # 2 - Grey
+    # 3 - Green
+    # 4 - Red
+
+# -------------------------
+#  Tickets
+# -------------------------
+
+Ticket:
+  TicketType: "channels" # Choose how you want tickets to be created.
+  # Options:
+  # channels - Tickets will be created as channels in the 
+  # threads - Tickets will be created as threads through the "TicketHome"
+
+  # For TicketType "Threads"
+  TicketHome: "TICKETHOME_CHANNEL_ID" 
+  # What is TicketHome?
+  # - Channel where the Ticket creation panel is sent.
+  # - Channel where ticket threads are made. (only if ticket threads is enabled above.)
+
+  # For TicketType "Channels"
+  TicketChannelsCategory: "TICKET_CATEGORY_ID" # if Type is set to channels
+  TicketChannelsCategory2: "BACKUP_TICKET_CATEGORY_ID" # This will be used if the first category has reached the max channel limit.
+  TicketArchiveCategory: "ARCHIVE_TICKET_CATEGORY_ID"
+
+  # ---
+
+  Channel: "ticket-" # The prefix for ticket channel names
+  TicketsPerUser: 100
+  DMTranscripts: true
+  TicketReason: true
+  # If ticket reason is set to false, It will not prompt to create a reason
+  TicketSubject: "description"
+  # "description" will display the ticket reason within the channel description
+  # "embed" will display the ticket reason within the ticket embed
+  Timeout: 5
+  # Set to true to allow all staff to access the ticket
+
+  Log:
+    TicketDataLog: "TICKET_LOG_ID"
+    TickeDataTitle: "Ticket Data"
+
+  Close:
+    StaffOnly: true
+    # Set to false is anyone is able to close a ticket.
+
+    Confirmation_Button: "Confirm Close"
+    Confirmation_Emoji: "🗑️"
+    Confirmation_Style: "2"
+
+    Title: "Are you sure you want to close this ticket?"
+
+    # Available Button Styles
+    # 1 - Blurple
+    # 2 - Grey
+    # 3 - Green
+    # 4 - Red
+
+  Invites:
+    StaffOnly: true
+
+  ClaimTickets:
+    Enabled: true
+    Channel: "CLAIM_TICKETS_CHANNEL_ID" 
+    # Channel name or Channel ID
+    
+    ClaimAcceptTime: 120000
+    # How long the assigned user has to accept the ticket before it gets re-assigned to someone else.
+    # 120000 = 2 Minutes
+    # 180000 = 3 Minutes
+    # 240000 = 4 Minutes
+    # 300000 = 5 Minutes
+    # Time in Mliseconds
+
+    ButtonTitle: "Claim Ticket"
+    ButtonEmoji: "🎫"
+    Button: "1"
+
+    # Available Button Styles
+    # 1 - Blurple
+    # 2 - Grey
+    # 3 - Green
+    # 4 - Red
+
+# -------------------------
+#  Buttons
+# -------------------------
+Buttons:
+  Tickets:
+    ClaimEmoji: "🧑‍💻"
+    ClaimStyle: "1"
+
+    Unarchive: "Unarchive Ticket"
+    Unarchive_Emoji: "♻️"
+    Unarchive_Style: "2"
+
+    Unlock: "Unlock Ticket"
+    Unlock_Emoji: "🔓"
+    Unlock_Style: "2"
+
+    # Available Button Styles
+    # 1 - Blurple
+    # 2 - Grey
+    # 3 - Green
+    # 4 - Red
+
+# -------------------------
+#  Select Menus
+# -------------------------
+
+SelectMenus:
+  Tickets:
+    PanelEmoji: "⚙️"
+    
+    CloseEmoji: "🗑️"
+    ArchiveEmoji: "♻️"
+    LockEmoji: "🔐"
+    RenameEmoji: "🏷️"
+
+    EnableInvitesEmoji: "📤"
+    DisableInvitesEmoji: "📥"
+
+# -------------------------
+#  Misc
+# -------------------------
+
+Translate:
+  TranslateLog: "TRANSLATE_LOG_ID"

Configs/ticket-panel.yml

@@ -0,0 +1,43 @@
+#      ___                            _    ___        _
+#    / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_
+#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |
+#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|
+#                |_|  |_|
+#
+#           SupportBot created by Emerald Services
+#           Installed with MIT License
+#
+#           Discord Support: https://emeraldsrv.dev/discord
+#           Community Resources: https://emeraldsrv.dev/resources
+
+# -------------------------------
+#   Ticket Panel Configuration
+# -------------------------------
+
+Panel: true
+
+# ----------------------------------------
+#   Ticket Panel Message Configuration #2b2d31
+# ----------------------------------------
+
+PanelTitle: "SupportBot"
+PanelColour: "#0cc559"
+
+Button:
+  Text: "Create Ticket"
+  Emoji: "🎫"
+  Color: "2"
+
+# Available Button Styles
+# 1 - Blurple
+# 2 - Grey
+# 3 - Red
+# 4 - Green
+
+TicketPanel_Description: true
+TicketPanel_Thumbnail: false
+TicketPanel_Image: true
+
+PanelMessage: "Click on the button to file a `Ticket` and our team will try their best to assist you in the best way we can!"
+PanelThumbnail: "https://i.imgur.com/ieeZejl.png"
+PanelImage: "https://i.imgur.com/dejQvkg.png"

Data/Profiles.json

@@ -0,0 +1 @@
+{}

Data/StaffData.json

@@ -0,0 +1 @@
+{}

Data/SuggestionData.json

@@ -0,0 +1 @@
+{}

Data/SupportBot-AI.json

@@ -0,0 +1 @@
+{}

Data/TicketData.json

@@ -0,0 +1,5 @@
+{
+    "tickets": [
+
+    ]
+}

Data/profiles/0000000000000000.json

@@ -0,0 +1,5 @@
+{
+  "bio": "",
+  "timezone": "",
+  "clockedIn": false
+}

Data/settings.json

@@ -0,0 +1 @@
+{}

Data/ticket-panel-id.json

@@ -0,0 +1,4 @@
+{
+    "id": 0,
+    "TicketPanelID": "0000000000000000000"
+}

Events/guildCreate.js

@@ -0,0 +1,9 @@
+const Event = require("../Structures/Event.js");
+module.exports = new Event("guildCreate", async (client) => {
+  console.log(
+    `\u001b[31m`,
+    `${client.user.username} is not in the correct server set in your config. Please leave all other servers and restart the bot.`
+  );
+  console.log(`\u001b[31m`, `${client.user.username} will now exit.`);
+  return process.exit(1);
+});

Events/guildDelete.js

@@ -0,0 +1,10 @@
+const Event = require("../Structures/Event.js");
+
+module.exports = new Event("guildDelete", async (client) => {
+  console.log(
+    `\u001b[31m`,
+    `${client.user.username} is not in the correct server set in your config. Please join the server and restart the bot.`
+  );
+  console.log(`\u001b[31m`, `${client.user.username} will now exit.`);
+  return process.exit(1);
+});

Events/guildMemberAdd.js

@@ -0,0 +1,56 @@
+
+const Discord = require('discord.js');
+const fs = require("fs");
+const Event = require("../Structures/Event.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(
+    fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+  
+const cmdconfig = yaml.load(
+    fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+  
+const msgconfig = yaml.load(
+    fs.readFileSync("./Configs/messages.yml", "utf8")
+);
+
+module.exports = new Event("guildMemberAdd", async (client, member, interaction, guild) => {
+
+    if (supportbot.Welcome.Enabled) {
+        const WelcomeChannel = member.guild.channels.cache.get(supportbot.Welcome.Channel) ||
+                               member.guild.channels.cache.find(channel => channel.name === supportbot.Welcome.Channel);
+
+        const WelcomeEmbed = new Discord.EmbedBuilder()
+            .setColor(msgconfig.Welcome.Embed.Colour)
+            .setTitle(msgconfig.Welcome.Embed.Title)
+            .setDescription(msgconfig.Welcome.Embed.Message.replace(/%joined_user%/g, member.user))
+            .setTimestamp();
+        
+        if (msgconfig.Welcome.Embed.Thumbnail === "BOT") {
+            WelcomeEmbed.setThumbnail(client.user.displayAvatarURL())
+        } else if (msgconfig.Welcome.Embed.Thumbnail === "USER") {
+            WelcomeEmbed.setThumbnail(member.user.displayAvatarURL())
+        }
+    
+        if (msgconfig.Welcome.Embed.ImageEnabled) {
+            WelcomeEmbed.setImage(msgconfig.Welcome.Embed.ImageURL)
+        }
+    
+        if (WelcomeChannel) {
+            WelcomeChannel.send({ embeds: [WelcomeEmbed] });
+        }
+    
+        if (supportbot.Roles.AutoRole.Enabled) {
+            const role = member.guild.roles.cache.get(supportbot.Roles.AutoRole.Role) ||
+                         member.guild.roles.cache.find(role => role.name === supportbot.Roles.AutoRole.Role);
+            if (role) {
+                member.roles.add(role);
+            }
+        }
+    
+        console.log(`\u001b[32m`, `[+]`, `\u001b[33m`, `${member.user.username} joined the server!`);
+    }
+
+});

Events/guildMemberRemove.js

@@ -0,0 +1,50 @@
+
+const Discord = require('discord.js');
+const fs = require("fs");
+const Event = require("../Structures/Event.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(
+    fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+  
+const cmdconfig = yaml.load(
+    fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+  
+const msgconfig = yaml.load(
+    fs.readFileSync("./Configs/messages.yml", "utf8")
+);
+
+module.exports = new Event("guildMemberRemove", async (client, member, interaction, guild) => {
+
+    if (supportbot.Leave.Enabled) {
+        const LeaveChannel = member.guild.channels.cache.get(supportbot.Leave.Channel) ||
+                             member.guild.channels.cache.find(channel => channel.name === supportbot.Leave.Channel);
+
+        const LeaveEmbed = new Discord.EmbedBuilder()
+            .setColor(msgconfig.Leave.Embed.Colour)
+            .setTitle(msgconfig.Leave.Embed.Title)
+            .setDescription(msgconfig.Leave.Embed.Message.replace(/%left_user%/g, member.user))
+            .setTimestamp();
+        
+        if (msgconfig.Leave.Embed.Thumbnail === "BOT") {
+            LeaveEmbed.setThumbnail(client.user.displayAvatarURL());
+        } else if (msgconfig.Leave.Embed.Thumbnail === "USER") {
+            LeaveEmbed.setThumbnail(member.user.displayAvatarURL());
+        }
+    
+        if (msgconfig.Leave.Embed.ImageEnabled) {
+            LeaveEmbed.setImage(msgconfig.Leave.Embed.ImageURL);
+        }
+    
+        if (LeaveChannel) {
+            LeaveChannel.send({
+                embeds: [LeaveEmbed]
+            });
+        }
+    
+        console.log(`\u001b[31m`, `[-]`, `\u001b[33m`, `${member.user.username} left the server!`);
+    }
+
+});

Events/interactionCreate.js

@@ -0,0 +1,691 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+
+const Event = require("../Structures/Event.js");
+
+let suggestions;
+try {
+  suggestions = require("../Data/SuggestionData.json");
+} catch (error) {
+  suggestions = {};
+}
+
+module.exports = new Event("interactionCreate", async (client, interaction) => {
+
+  if (interaction.type === Discord.InteractionType.ApplicationCommand) {
+    const command = client.commands.find(
+      (cmd) => cmd.name.toLowerCase() === interaction.commandName
+    );
+
+    if (interaction.user.bot || !interaction.guild) return;
+
+    const NotValid = new Discord.EmbedBuilder()
+      .setDescription(`:x: \`Invalid Command\``)
+      .setColor(supportbot.Embed.Colours.Error);
+
+    if (!command)
+      return interaction.reply({
+        embeds: [NotValid],
+        ephemeral: true,
+      });
+
+    const permission = interaction.member.permissions.has(command.permissions);
+
+    const ValidPerms = new Discord.EmbedBuilder()
+      .setDescription(
+        "> :x: `Invalid Permissions` Do you have the correct permissions to execute this command?"
+      )
+      .setColor(supportbot.Embed.Colours.Error);
+
+    if (!permission)
+      return interaction.reply({
+        embeds: [ValidPerms],
+        ephemeral: true,
+      });
+
+    try {
+      if (command.name === cmdconfig.OpenTicket.Command && supportbot.Ticket.TicketReason) {
+        const modal = new Discord.ModalBuilder()
+          .setCustomId("ticketReasonModal")
+          .setTitle("Ticket Reason")
+          .addComponents(
+            new Discord.ActionRowBuilder().addComponents(
+              new Discord.TextInputBuilder()
+                .setCustomId("reasonInput")
+                .setLabel("Reason")
+                .setStyle(Discord.TextInputStyle.Paragraph)
+                .setRequired(true)
+            )
+          );
+
+        await interaction.showModal(modal);
+      } else {
+        console.log("\u001b[32m", "[Executed]", "\u001b[37;1m", `${interaction.user.username} has executed ${command.name}`);
+        await command.run(interaction);
+      }
+    } catch (error) {
+      console.error("Error executing command:", error);
+      await interaction.reply({
+        content: "An error occurred while executing the command.",
+        ephemeral: true,
+      });
+    }
+  }
+
+  if (interaction.isModalSubmit()) {
+    if (interaction.customId === "ticketReasonModal") {
+      const reason = interaction.fields.getTextInputValue("reasonInput");
+      interaction.customId = `createticket-${reason}`;
+      const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
+      if (cmd) {
+        interaction.reason = reason; // Attach the reason to the interaction object
+        await cmd.run(interaction);
+      } else {
+        console.error("Command not found.");
+      }
+    }
+  }
+
+  if (interaction.customId === "renameTicketModal") {
+    const newTicketName = interaction.fields.getTextInputValue("renameTicket");
+
+    // Fixing the ticketChannelId extraction and lookup
+    const ticketChannelId = interaction.channel.id;
+
+    let ticketChannel;
+    if (supportbot.Ticket.TicketType === "threads") {
+        ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
+    } else if (supportbot.Ticket.TicketType === "channels") {
+        ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
+    }
+
+    if (!ticketChannel) {
+        return interaction.reply({
+            content: "Ticket channel not found.",
+            ephemeral: true,
+        });
+    }
+
+    try {
+        await ticketChannel.setName(newTicketName);
+
+        const renamedsuccess = new Discord.EmbedBuilder()
+            .setDescription(msgconfig.Ticket.RenamedSuccess)
+            .setColor(supportbot.Embed.Colours.Success);
+
+        return interaction.reply({
+            embeds: [renamedsuccess],
+            ephemeral: true,
+        });
+    } catch (error) {
+        console.error("Error renaming the ticket:", error);
+        return interaction.reply({
+            content: "There was an error renaming the ticket.",
+            ephemeral: true,
+        });
+    }
+}
+
+  if (interaction.isStringSelectMenu()) {
+    if (interaction.customId === "ticketcontrolpanel") {
+      const selectedOption = interaction.values[0];
+      const { getRole, getChannel } = interaction.client;
+      switch (selectedOption) {
+
+        case "ticketclose":
+          const closeCommand = client.commands.get(cmdconfig.CloseTicket.Command);
+          if (closeCommand) {
+            await closeCommand.run(interaction);
+          } else {
+            console.error("[X] Close Command Not Found");
+          }
+          break;
+
+          case "archiveticket":
+              const arcembed = new Discord.EmbedBuilder()
+                .setDescription(msgconfig.Ticket.TicketArchived)
+                .setColor(supportbot.Embed.Colours.Success);
+
+              const CloseButton = new Discord.ButtonBuilder()
+                .setCustomId("confirmCloseTicket")
+                .setLabel(supportbot.Ticket.Close.Confirmation_Button)
+                .setEmoji(supportbot.Ticket.Close.Confirmation_Emoji)
+                .setStyle(supportbot.Ticket.Close.Confirmation_Style);
+
+              const unarchiveButton = new Discord.ButtonBuilder()
+                .setCustomId("unarchiveTicket")
+                .setLabel(supportbot.Buttons.Tickets.Unarchive)
+                .setEmoji(supportbot.Buttons.Tickets.Unarchive_Emoji)
+                .setStyle(supportbot.Buttons.Tickets.Unarchive_Style);
+
+              const ArchivedOptions = new Discord.ActionRowBuilder() 
+                .addComponents(CloseButton, unarchiveButton);
+
+                await interaction.channel.send({
+                  embeds: [arcembed],
+                  components: [ArchivedOptions],
+                });
+
+                if (supportbot.Ticket.TicketType === "threads") {
+                  await interaction.channel.setArchived(true);
+                }
+              
+                if (supportbot.Ticket.TicketType === "channels") {
+                  const { getRole, getChannel } = interaction.client;
+                  await interaction.channel.setParent(supportbot.Ticket.TicketArchiveCategory);
+
+                  const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+                  const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
+              
+                  if (ticketInfo) {
+                    const user = interaction.guild.members.cache.get(ticketInfo.user) || ticketInfo.user;
+                    const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimedBy) || ticketInfo.claimedBy;
+                    const Admin = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Admin);
+                    const Staff = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Staff);
+              
+                    if (user && user.id) {
+                      await interaction.channel.permissionOverwrites.edit(user.id, {
+                        ViewChannel: false,
+                        SendMessages: false,
+                      });
+                    }
+              
+                    if (supportbot.ClaimTickets === true) {
+                      if (claimedBy && claimedBy.id) {
+                        await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
+                          ViewChannel: true,
+                          SendMessages: true,
+                          ReadMessageHistory: true,
+                        });
+                      }  
+                    }
+  
+                    if (supportbot.ClaimTickets === false) {
+                      if (Staff && Staff.id) {
+                        await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
+                          ViewChannel: true,
+                          SendMessages: true,
+                          ReadMessageHistory: true,
+                        });
+                      }  
+                    }
+              
+                    if (Admin && Admin.id) {
+                      await interaction.channel.permissionOverwrites.edit(Admin.id, {
+                        ViewChannel: true,
+                        SendMessages: true,
+                        ReadMessageHistory: true,
+                      });
+                    }
+              
+                    await interaction.channel.permissionOverwrites.edit(interaction.guild.roles.everyone.id, {
+                      ViewChannel: false,
+                      SendMessages: false,
+                      ReadMessageHistory: false,
+                    });
+                  }
+            
+                }
+
+                break;
+
+                case "lockticket":
+                  const lockembed = new Discord.EmbedBuilder()
+                    .setDescription(msgconfig.Ticket.TicketLocked)
+                    .setColor(supportbot.Embed.Colours.Success);
+              
+                  const unlockButton = new Discord.ButtonBuilder()
+                    .setCustomId("unlockTicket")
+                    .setLabel(supportbot.Buttons.Tickets.Unlock)
+                    .setEmoji(supportbot.Buttons.Tickets.Unlock_Emoji)
+                    .setStyle(supportbot.Buttons.Tickets.Unlock_Style);
+              
+                  const LockedOptions = new Discord.ActionRowBuilder()
+                    .addComponents(unlockButton);
+              
+                  await interaction.channel.send({
+                    embeds: [lockembed],
+                    components: [LockedOptions],
+                    ephemeral: false, 
+                  });
+              
+
+                  if (supportbot.Ticket.TicketType === "threads") {
+                    await interaction.channel.setLocked(true);  
+                  }
+              
+                  break;
+
+                  case "unlockTicket":
+                    const unlockEmbed = new Discord.EmbedBuilder()
+                      .setDescription(msgconfig.Ticket.TicketUnlocked)
+                      .setColor(supportbot.Embed.Colours.Success);
+                
+                    await interaction.channel.send({
+                      embeds: [unlockEmbed],
+                      ephemeral: false,
+                    });
+                
+                    if (supportbot.Ticket.TicketType === "threads") {
+                      await interaction.channel.setLocked(false);  
+                    }
+                
+                    break;
+              
+        case "enableinvites":
+          await handleInvites(interaction, true);
+          break;
+
+        case "disableinvites":
+          await handleInvites(interaction, false);
+          break;
+
+        case "renameticket":
+          const modal = new Discord.ModalBuilder()
+          .setCustomId("renameTicketModal")
+          .setTitle("Rename Channel")
+          .addComponents(
+            new Discord.ActionRowBuilder()
+              .addComponents(
+                new Discord.TextInputBuilder()
+                  .setCustomId("renameTicket")
+                  .setLabel("New Channel Name")
+                  .setStyle(Discord.TextInputStyle.Short)
+                  .setRequired(true)
+                )
+              );
+            await interaction.showModal(modal);
+            break;
+
+      }
+    }
+  }
+
+  if (interaction.isButton()) {
+    if (interaction.customId === "unarchiveTicket") {
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        await interaction.channel.setArchived(false);
+      }
+    
+      if (supportbot.Ticket.TicketType === "channels") {
+        const { getRole, getChannel } = interaction.client;
+        await interaction.channel.setParent(supportbot.Ticket.TicketChannelsCategory);
+
+        const ticketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+        const ticketInfo = ticketData.tickets.find(t => t.id === interaction.channel.id);
+      
+        if (ticketInfo) {
+          const user = interaction.guild.members.cache.get(ticketInfo.user) || ticketInfo.user;
+          const claimedBy = interaction.guild.members.cache.get(ticketInfo.claimedBy) || ticketInfo.claimedBy;
+          const Admin = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Admin);
+          const Staff = await interaction.guild.roles.fetch(supportbot.Roles.StaffMember.Staff);
+      
+          if (user && user.id) {
+            await interaction.channel.permissionOverwrites.edit(user.id, {
+              ViewChannel: true,
+              SendMessages: true,
+              ReadMessageHistory: true,
+            });
+          }
+      
+          if (supportbot.ClaimTickets === true) {
+            if (claimedBy && claimedBy.id) {
+              await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
+                ViewChannel: true,
+                SendMessages: true,
+                ReadMessageHistory: true,
+              });
+            }  
+          }
+
+          if (supportbot.ClaimTickets === false) {
+            if (Staff && Staff.id) {
+              await interaction.channel.permissionOverwrites.edit(claimedBy.id, {
+                ViewChannel: true,
+                SendMessages: true,
+                ReadMessageHistory: true,
+              });
+            }  
+          }
+      
+          if (Admin && Admin.id) {
+            await interaction.channel.permissionOverwrites.edit(Admin.id, {
+              ViewChannel: true,
+              SendMessages: true,
+              ReadMessageHistory: true,
+            });
+          }
+      
+          await interaction.channel.permissionOverwrites.edit(interaction.guild.roles.everyone.id, {
+            ViewChannel: false,
+            SendMessages: false,
+            ReadMessageHistory: false,
+          });
+        }
+      }
+    
+      const unrcembed = new Discord.EmbedBuilder()
+        .setDescription(msgconfig.Ticket.TicketUnarchived)
+        .setColor(supportbot.Embed.Colours.Success);
+    
+      await interaction.update({
+        embeds: [unrcembed],
+        components: [],
+      });
+    
+    }
+
+    if (interaction.customId === "createticket") {
+      if (supportbot.Ticket.TicketReason) {
+        const modal = new Discord.ModalBuilder()
+          .setCustomId("ticketReasonModal")
+          .setTitle("Ticket Reason")
+          .addComponents(
+            new Discord.ActionRowBuilder().addComponents(
+              new Discord.TextInputBuilder()
+                .setCustomId("reasonInput")
+                .setLabel("Reason")
+                .setStyle(Discord.TextInputStyle.Paragraph)
+                .setRequired(true)
+            )
+          );
+
+        await interaction.showModal(modal);
+      } else {
+        try {
+          const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
+          if (!cmd) return;
+          await cmd.run(interaction);
+        } catch (error) {
+          console.error("Error executing the ticket command:", error);
+          await interaction.reply({
+            content: "An error occurred while creating the ticket.",
+            ephemeral: true,
+          });
+        }
+      }
+    }
+
+    if (interaction.customId === "openticket") {
+      if (supportbot.Ticket.TicketReason) {
+        const modal = new Discord.ModalBuilder()
+          .setCustomId("ticketReasonModal")
+          .setTitle("Ticket Reason")
+          .addComponents(
+            new Discord.ActionRowBuilder().addComponents(
+              new Discord.TextInputBuilder()
+                .setCustomId("reasonInput")
+                .setLabel("Reason")
+                .setStyle(Discord.TextInputStyle.Paragraph)
+                .setRequired(true)
+            )
+          );
+
+        await interaction.showModal(modal);
+      } else {
+        try {
+          const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
+          if (!cmd) return;
+          await cmd.run(interaction);
+        } catch (error) {
+          console.error(error);
+        }
+      }
+    }
+
+    if (interaction.customId.startsWith("claimticket-")) {
+      const ticketChannelId = interaction.customId.split("-")[1];
+      const ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
+      if (!ticketChannel) {
+        return interaction.reply({
+          content: "Ticket channel not found.",
+          ephemeral: true,
+        });
+      }
+
+      const { getRole, getChannel } = interaction.client;
+      const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+
+      const RolePerms = new Discord.EmbedBuilder()
+        .setTitle("Invalid Permissions!")
+        .setDescription(
+          `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
+        )
+        .setColor(supportbot.Embed.Colours.Warn);
+
+      if (!Staff || !Admin) {
+        return interaction.reply({
+          embeds: [RolePerms],
+          ephemeral: true,
+        });
+      }
+
+      const NoPermsClaim = new Discord.EmbedBuilder()
+        .setTitle(msgconfig.Ticket.ClaimTickets.NoPermsToClaimTitle)
+        .setDescription(
+          msgconfig.Ticket.ClaimTickets.NoPermsToClaim.replace("%channel%", ticketChannel.name)
+        )
+        .setColor(supportbot.Embed.Colours.Error);
+
+      if (!interaction.member.roles.cache.has(Staff.id) && !interaction.member.roles.cache.has(Admin.id)) {
+        return interaction.reply({
+          embeds: [NoPermsClaim],
+          ephemeral: true,
+        });
+      }
+
+      if (supportbot.Ticket.TicketType === "threads") {
+        await ticketChannel.members.add(interaction.user.id); 
+
+    } else if (supportbot.Ticket.TicketType === "channels") {
+        await ticketChannel.permissionOverwrites.create(interaction.user.id, {
+            ViewChannel: true,
+            SendMessages: true,
+            ReadMessageHistory: true,
+        }); 
+
+        await ticketChannel.permissionOverwrites.create(Admin, {
+            ViewChannel: true,
+            SendMessages: true,
+            ReadMessageHistory: true,
+        }); 
+
+        await ticketChannel.permissionOverwrites.create(interaction.guild.roles.everyone, {
+          ViewChannel: false,
+        }); 
+    }
+    
+      const pingclaimedstaff = await ticketChannel.send(`<@${interaction.user.id}>`);
+
+      setTimeout(() => {
+        pingclaimedstaff.delete();
+      }, 2000);
+
+      const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
+      const ticketIndex = TicketData.tickets.findIndex((t) => t.id === ticketChannelId);
+      if (ticketIndex !== -1) {
+        TicketData.tickets[ticketIndex].claimedBy = interaction.user.id;
+        TicketData.tickets[ticketIndex].claimedAt = new Date().toISOString();
+        fs.writeFileSync("./Data/TicketData.json", JSON.stringify(TicketData, null, 4));
+      }
+
+      const claimMessage = await interaction.message.fetch();
+      const claimedEmbed = new Discord.EmbedBuilder(claimMessage.embeds[0].data)
+        .setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
+        .setDescription(
+          msgconfig.Ticket.ClaimTickets.ClaimMessage_Edit.replace("%user%", interaction.user.id).replace("%channel%", ticketChannel.id)
+        )
+        .setColor(supportbot.Embed.Colours.Success);
+
+      const successfullyClaimed = new Discord.EmbedBuilder()
+        .setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
+        .setDescription(msgconfig.Ticket.ClaimTickets.Claimed.replace("%channel%", ticketChannel.id))
+        .setColor(supportbot.Embed.Colours.Success);
+
+      await claimMessage.edit({ embeds: [claimedEmbed], components: [] });
+      await interaction.reply({
+        embeds: [successfullyClaimed],
+        ephemeral: true,
+      });
+    }
+
+    // SUGGESTION INTERACTIONS [START]
+
+    if (
+      interaction.customId === "upvote" ||
+      interaction.customId === "downvote" ||
+      interaction.customId === "removevote"
+    ) {
+      const suggestion = suggestions[interaction.message.id];
+      if (!suggestion)
+        return interaction.reply({ content: "Suggestion not found.", ephemeral: true });
+
+      const userId = interaction.user.id;
+      const hasUpvoted = suggestion.upvotes.includes(userId);
+      const hasDownvoted = suggestion.downvotes.includes(userId);
+
+      if (interaction.customId === "upvote") {
+        if (hasUpvoted) {
+          suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
+        } else {
+          suggestion.upvotes.push(userId);
+          if (hasDownvoted) {
+            suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
+          }
+        }
+      } else if (interaction.customId === "downvote") {
+        if (hasDownvoted) {
+          suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
+        } else {
+          suggestion.downvotes.push(userId);
+          if (hasUpvoted) {
+            suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
+          }
+        }
+      } else if (interaction.customId === "removevote") {
+        suggestion.upvotes = suggestion.upvotes.filter((id) => id !== userId);
+        suggestion.downvotes = suggestion.downvotes.filter((id) => id !== userId);
+      }
+
+      fs.writeFileSync("./Data/SuggestionData.json", JSON.stringify(suggestions, null, 2));
+
+      const upvoteCount = suggestion.upvotes.length;
+      const downvoteCount = suggestion.downvotes.length;
+
+      const updatedEmbed = new Discord.EmbedBuilder(interaction.message.embeds[0].data).setFields([
+        { name: "Suggestion", value: suggestion.suggestion, inline: true },
+        { name: "From", value: `<@${suggestion.author}>` },
+        {
+          name: `${supportbot.Suggestions.UpvoteEmoji} ${supportbot.Suggestions.UpvoteTitle}`,
+          value: `${upvoteCount}`,
+          inline: true,
+        },
+        {
+          name: `${supportbot.Suggestions.DownvoteEmoji} ${supportbot.Suggestions.DownvoteTitle}`,
+          value: `${downvoteCount}`,
+          inline: true,
+        },
+      ]);
+
+      await interaction.update({ embeds: [updatedEmbed] });
+    }
+
+  }
+
+  async function handleInvites(interaction, enable) {
+    if (supportbot.Ticket.Invites.StaffOnly) {
+      const { getRole, getChannel } = interaction.client;
+      const SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
+      const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
+
+      if (!SupportStaff || !Admin) {
+        return interaction.reply(
+          "Some roles seem to be missing!\nPlease check for errors when starting the bot."
+        );
+      }
+
+      const NoPerms = new Discord.EmbedBuilder()
+        .setTitle("Invalid Permissions!")
+        .setDescription(
+          `${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
+        )
+        .setColor(supportbot.Embed.Colours.Warn);
+
+      if (
+        !interaction.member.roles.cache.has(SupportStaff.id) &&
+        !interaction.member.roles.cache.has(Admin.id)
+      ) {
+        return interaction.reply({ embeds: [NoPerms] });
+      }
+    }
+
+    await interaction.channel.setInvitable(enable);
+
+    const message = enable ? msgconfig.Ticket.EnableInvites : msgconfig.Ticket.DisableInvites;
+    const embed = new Discord.EmbedBuilder().setDescription(message).setColor(supportbot.Embed.Colours.General);
+
+    await interaction.reply({
+      embeds: [embed],
+      ephemeral: true,
+    });
+  }
+
+  // Modal submission handler for editing profile
+  if (interaction.type === Discord.InteractionType.ModalSubmit && interaction.customId === "editProfileModal") {
+    const userId = interaction.user.id;
+    const profilePath = `./Data/Profiles/${userId}.json`;
+
+    let profileData;
+    if (fs.existsSync(profilePath)) {
+      profileData = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+    } else {
+      profileData = {
+        bio: "",
+        timezone: "",
+        clockedIn: false,
+      };
+    }
+
+    try {
+      const newBio = interaction.fields.getTextInputValue("bio");
+      const newTimezone = interaction.fields.getTextInputValue("timezone");
+
+      profileData.bio = newBio;
+      profileData.timezone = newTimezone;
+
+      fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+
+      const updatedProfileEmbed = new Discord.EmbedBuilder()
+        .setTitle(`${interaction.user.username}'s Profile`)
+        .setColor(supportbot.Embed.Colours.General)
+        .setThumbnail(interaction.user.displayAvatarURL())
+        .addFields(
+          { name: "Bio", value: newBio || "No bio set.", inline: false },
+          { name: "Timezone", value: newTimezone || "No timezone set.", inline: true }
+        );
+
+      if (profileData.clockedIn !== undefined) {
+        updatedProfileEmbed.addFields({
+          name: "Clocked In Status",
+          value: profileData.clockedIn ? "✅ Clocked In" : "❌ Clocked Out",
+          inline: true,
+        });
+      }
+
+      await interaction.reply({ embeds: [updatedProfileEmbed], ephemeral: true });
+    } catch (error) {
+      console.error("Failed to update profile data: ", error);
+      await interaction.reply({
+        content: "There was an error while updating your profile. Please try again later.",
+        ephemeral: true,
+      });
+    }
+  }
+});

Events/messageCreate.js

@@ -0,0 +1,166 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const yaml = require("js-yaml");
+const axios = require("axios");
+const { OpenAI } = require('openai');
+
+// Load configuration files with validation
+function loadConfig(path) {
+    try {
+        return yaml.load(fs.readFileSync(path, "utf8"));
+    } catch (error) {
+        console.error(`Error loading config file at ${path}:`, error);
+        throw error;
+    }
+}
+
+const supportbotai = yaml.load(fs.readFileSync("./Configs/supportbot-ai.yml"));
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
+// Validate configuration values
+function validateConfig(config, keys) {
+    keys.forEach(key => {
+        if (!config[key]) {
+            throw new Error(`Missing configuration key: ${key}`);
+        }
+    });
+}
+
+const CHANNELS = [supportbotai.Channels.AIChannel];
+
+// Initialize Discord client
+const client = new Discord.Client({
+    intents: ['Guilds', 'GuildMembers', 'GuildMessages']
+});
+
+// Load custom Event structure
+const Event = require("../Structures/Event.js");
+
+// Initialize OpenAI client
+const openai = new OpenAI({
+    apiKey: supportbotai.General.OpenAI_Key,
+});
+
+const PASTEBIN_API_KEY = supportbotai.General.PastebinAPI_Key;
+const PASTEBIN_API_URL = supportbotai.General.PastebinAPI_URL;
+
+// Function to create a paste on Pastebin
+async function createPaste(content) {
+    try {
+        const response = await axios.post(PASTEBIN_API_URL, new URLSearchParams({
+            api_dev_key: PASTEBIN_API_KEY,
+            api_option: 'paste',
+            api_paste_code: content,
+            api_paste_private: 1, // 0 = public, 1 = unlisted, 2 = private
+            api_paste_expire_date: '1D', // Expire in 1 day
+            api_paste_format: 'text'
+        }));
+        return response.data;
+    } catch (error) {
+        console.error('Pastebin Error:', error);
+        throw error;
+    }
+}
+
+// Event handler for message creation
+module.exports = new Event("messageCreate", async (client, message) => {
+    if (message.author.bot || !message.guild) return;
+    if (!CHANNELS.includes(message.channelId) && !message.mentions.users.has(client.user.id)) return;
+
+if (supportbotai.Enabled) {
+
+    const sendTypingInterval = setInterval(() => {
+        message.channel.sendTyping();
+    }, 5000);
+
+    let conversation = [{
+        role: "system",
+        content: "SupportBot is your friendly neighbourhood support bot."
+    }];
+
+    let prevMessages = await message.channel.messages.fetch({ limit: 10 });
+    prevMessages = prevMessages.reverse().filter(msg => !msg.author.bot || msg.author.id === client.user.id);
+
+    prevMessages.forEach((msg) => {
+        const username = msg.author.username.replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
+
+        conversation.push({
+            role: msg.author.id === client.user.id ? "assistant" : "user",
+            name: username,
+            content: msg.content,
+        });
+    });
+
+    try {
+        const response = await openai.chat.completions.create({
+            model: supportbotai.General.Model,
+            messages: conversation,
+            max_tokens: supportbotai.General.Tokens,
+        });
+
+        clearInterval(sendTypingInterval);
+
+        if (response.choices && response.choices.length > 0) {
+            const replyContent = response.choices[0].message.content;
+
+            const SupportBotAI = new Discord.EmbedBuilder()
+                .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
+                .setDescription(replyContent)
+                .setColor(supportbotai.Embed.Color)
+                .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
+                .setTimestamp();
+
+            if (replyContent.length > 2000) {
+                const pasteLink = await createPaste(replyContent);
+
+                const SupportBotAIPastebin = new Discord.EmbedBuilder()
+                    .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
+                    .setDescription(supportbotai.Messages.MessageTooLong.replace("{pastebin}", pasteLink))
+                    .setColor(supportbotai.Embed.Color)
+                    .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
+                    .setTimestamp();
+
+                message.reply({ embeds: [SupportBotAIPastebin] });
+            } else {
+                message.reply({ embeds: [SupportBotAI] });
+            }
+        } else {
+            const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
+                .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
+                .setDescription(supportbotai.Messages.ErrorResponse)
+                .setColor(supportbotai.Embed.Color)
+                .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
+                .setTimestamp();
+
+            message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
+        }
+    } catch (error) {
+        clearInterval(sendTypingInterval);
+
+        const SupportBotAIErrorResponse = new Discord.EmbedBuilder()
+            .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
+            .setDescription(supportbotai.Messages.OpenAIError)
+            .setColor(supportbot.Embed.Colours.Error)
+            .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
+            .setTimestamp();
+
+        console.error('OpenAI Error:', error);
+        message.reply({ embeds: [SupportBotAIErrorResponse], ephemeral: true });
+    }
+
+}
+
+if (supportbotai.Enabled === false) {
+    const AIDisabled = new Discord.EmbedBuilder()
+        .setAuthor({ name: supportbotai.General.Name, iconURL: client.user.displayAvatarURL() })
+        .setDescription(supportbotai.Messages.AIDisabled)
+        .setColor(supportbot.Embed.Colours.Error)
+        .setFooter({ text: supportbotai.Embed.Footer, iconURL: message.author.displayAvatarURL() })
+        .setTimestamp();
+
+    message.reply({ embeds: [AIDisabled], ephemeral: true })
+    return;
+}
+
+});

Events/ready.js

@@ -0,0 +1,145 @@
+// SupportBot | Emerald Services
+// Ready Event
+
+const fs = require("fs");
+
+const Discord = require("discord.js");
+const { Client, GatewayIntentBits, ActivityType } = require('discord.js');
+const client = new Discord.Client({intents: 32767})
+
+const yaml = require("js-yaml");
+
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+const panelconfig = yaml.load(
+  fs.readFileSync("./Configs/ticket-panel.yml", "utf8")
+);
+
+const cmdconfig = yaml.load(
+  fs.readFileSync("./Configs/commands.yml", "utf8")
+);
+
+const msgconfig = yaml.load(
+  fs.readFileSync("./Configs/messages.yml", "utf8")
+);
+
+const Event = require("../Structures/Event.js");
+
+let chan1 = client.channels.cache.get(supportbot.Ticket.TicketHome);
+
+module.exports = new Event("ready", async (client, interaction) => {
+  const { getRole, getChannel, getCategory } = client;
+
+  if (supportbot.Activity.Type === "Playing", "playing") {
+    client.user.setPresence({
+      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Playing }],
+      status: supportbot.Activity.Type,
+    });
+  }
+
+  if (supportbot.Activity.Type === "Watching", "watching") {
+    client.user.setPresence({
+      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Watching }],
+      status: supportbot.Activity.Type,
+    });
+  }
+  
+  if (supportbot.Activity.Type === "Listening", "listening") {
+    client.user.setPresence({
+      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Listening }],
+      status: supportbot.Activity.Type,
+    });
+  }
+
+  if (supportbot.Activity.Type === "Competing", "competing") {
+    client.user.setPresence({
+      activities: [{ name: supportbot.Activity.Status, type: Discord.ActivityType.Competing }],
+      status: supportbot.Activity.Type,
+    });
+  }
+
+  console.log(`\u001b[33m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(`    `);
+  console.log(`\u001b[31m`, `┏━━━┓╋╋╋╋╋╋╋╋╋╋╋╋╋┏┓┏━━┓╋╋╋┏┓`);
+  console.log(`\u001b[31m`, `┃┏━┓┃╋╋╋╋╋╋╋╋╋╋╋╋┏┛┗┫┏┓┃╋╋┏┛┗┓`);
+  console.log(`\u001b[31m`, `┃┗━━┳┓┏┳━━┳━━┳━━┳┻┓┏┫┗┛┗┳━┻┓┏┛`);
+  console.log(`\u001b[31m`, `┗━━┓┃┃┃┃┏┓┃┏┓┃┏┓┃┏┫┃┃┏━┓┃┏┓┃┃`);
+  console.log(`\u001b[31m`, `┃┗━┛┃┗┛┃┗┛┃┗┛┃┗┛┃┃┃┗┫┗━┛┃┗┛┃┗┓`);
+  console.log(`\u001b[31m`, `┗━━━┻━━┫┏━┫┏━┻━━┻┛┗━┻━━━┻━━┻━┛`);
+  console.log(`\u001b[31m`, `┗╋╋╋╋╋╋╋┃┃╋┃┃`);
+  console.log(`\u001b[31m`, `╋╋╋╋╋╋╋┗┛╋┗┛`);
+  console.log(`    `);
+  console.log(`\u001b[33m`, `――――――――――――――――――――――――――――――――――――――――――――`);
+  console.log(`    `);  
+  console.log(`\u001b[33m`, `${supportbot.General.Name} | [${supportbot.SupportBot_Version}]`, `\u001b[32m`, `Connected to Discord`,);
+  console.log("\u001b[32m", "SupportBot created by Emerald Development ");
+  console.log(`    `);
+  console.log(`\u001b[33m`, `――――――――――――――――― [Links] ――――――――――――――――――`);
+  console.log("\u001b[32m", "Discord: https://dsc.gg/emerald-dev");
+  console.log("\u001b[32m", "Website: https://emeraldsrv.com");
+  console.log("\u001b[32m", "Community: https://community.emeraldsrv.com");
+  console.log("\u001b[32m", "Documentation: https://docs.emeraldsrv.com");
+  console.log(`    `);
+  console.log(`\u001b[33m`, `――――――――――――――――― [Invite] ――――――――――――――――――`);
+  console.log("\u001b[32m", `Invite URL: https://discord.com/api/oauth2/authorize?client_id=${client.user.id}&permissions=8&scope=bot%20applications.commands`);
+  console.log(`    `);
+  console.log(`\u001b[33m`, `――――――――――――――――― [Config Check] ――――――――――――――――――`);
+  console.log("\u001b[32m", "Config initialization...");
+
+  const roles = [
+    supportbot.Roles.StaffMember.Admin,
+    supportbot.Roles.StaffMember.Staff,
+    supportbot.Roles.ModRoles.Blacklisted,
+    supportbot.Roles.ModRoles.Muted
+  ];
+
+  if (supportbot.Roles.AutoRole.Role) roles.push(supportbot.Roles.AutoRole.Role);
+  
+   const channels = [
+     supportbot.Suggestions.Channel,
+     supportbot.Ticket.Log.TicketLog,
+     supportbot.Ticket.Log.TranscriptLog,
+     supportbot.Ticket.TicketHome,
+     supportbot.Welcome.Channel,
+     supportbot.Leave.Channel,
+     supportbot.Translate.Log
+   ];
+  //const categories = [supportbot.TicketCategory];
+
+  if (!channels) {
+      console.log("\u001b[31m", `[MISSING CHANNEL]`, `\u001b[37;1m`, `${channels}`, "\u001b[31m", `channel not found. Please check your config file.`);
+      return;
+  }
+//  else {
+//      console.log(`\u001b[32m`, `[CHANNEL LOCATED]`, `\u001b[37;1m`, `${channels}`, `\u001b[32;1m`, `channel has been found.`);
+//  }
+
+  const missingC = [];
+  const missingR = [];
+  const missingCat = [];
+  
+  for (let r of roles) {
+    const find = await getRole(r, client.guilds.cache.first());
+    if (!find) missingR.push(r);
+  }
+ // for (let cat of categories) {
+ //   const find = await getCategory(cat, client.guilds.cache.first());
+ //   if (!find) missingCat.push(cat);
+ // }
+
+ const missingRoles = await Promise.all(roles.map(role => getRole(role, client.guilds.cache.first())));
+ const missingChannels = await Promise.all(channels.map(channel => getChannel(channel, client.guilds.cache.first())));
+
+ if (missingRoles.some(role => !role)) {
+  console.log("\u001b[31m", `Missing roles in your server configuration: ${missingRoles.filter(role => !role).join(', ')}`);
+  }
+
+  if (missingChannels.some(channel => !channel)) {
+  console.log("\u001b[31m", `Missing channels in your server configuration: ${missingChannels.filter(channel => !channel).join(', ')}`);
+  }
+
+  console.log("\u001b[32m", "Configs initialized, No problems were detected.");
+  console.log(`    `);
+
+});

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Emerald Services
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Toru Nagashima
+Copyright (c) 2024 Emerald Services
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,13 +1,96 @@
-  ![imgur](https://i.imgur.com/TQj40Mt.png)
+<h1 align="center">
+    <br>
+    <a href="https://github.com/Emerald-Services/SupportBot"><img src="https://i.imgur.com/cuadAYv.png"></a>
+    <br>
+    SupportBot
+    <br>
+</h1>
 
-  ## What is SupportBot?
+<div align="center">
+
+<a href="https://opensource.org/licenses/MIT">
+    <img src="https://img.shields.io/badge/license-MIT-green?style=for-the-badge" alt="shield.png">
+</a>
+
+<a href="https://github.com/discordjs">
+    <img src="https://img.shields.io/badge/DISCORD.JS%20-%20v14-blue?style=for-the-badge" alt="shield.png">
+</a>
+
+<a href="https://github.com/nodejs/node">
+    <img src="https://img.shields.io/badge/NODE.JS%20-%20v20.x-green?style=for-the-badge" alt="shield.png">
+</a>
+
+<a href="https://github.com/Emerald-Services/SupportBot/releases">
+    <img src="https://img.shields.io/github/downloads/Emerald-Services/SupportBot/total?style=for-the-badge" alt="shield.png">
+</a>
+
+## Supported Versions
+
+| SupportBot | Node.JS | Discord.JS |  Supported |
+|------------|---------|------------|------------|
+|    8.x     |   20.x  |    14.x.   | ✅ Yes
+|    7.7.3   |   16.x  |    13.x.   | ✅ Yes
+|    7.x     |   16.x  |    13.x.   | ❌ No
+|    6.x     |   14.x  |    13.x.   | ❌ No
+|    5.x     |   12.x  |    13.x.   | ❌ No
+|    4.x     |   11.x  |    13.x.   | ❌ No
+|    Older   | 10.x    |    13.x.   | ❌ No
+
+</div>
+
+<p align="center">
+  <a href="https://emeraldsrv.com/">Website</a>
+  •
+  <a href="https://github.com/Emerald-Services/SupportBot/wiki">Wiki</a>
+<br>
+  <a href="#about">About</a>
+  •
+  <a href="#support">Support</a>
+  •
+  <a href="#license">License</a>
+  •
+  <a href="https://github.com/Emerald-Services/SupportBot/wiki/Third-Party-Developer">Third-Party</a>
+  •
+  <a href="#contributors">Contributors</a>
+</p>
+
+## About
+
+SupportBot is an Open-Source discord bot built with [discord.js](https://github.com/discordjs/discord.js). It's primarily focused to help servers organise and manage their support system in a unique way with full customisation to match your brand.
+
+## Support
+
+<a href="https://emeraldsrv.com/discord">
+    <img alt="Discord" src="https://img.shields.io/discord/597779408295821323?logo=discord&logoColor=white&style=for-the-badge">
+</a>
+
+
+## License
+
+Released under the [MIT](https://opensource.org/licenses/MIT) license.
+
+
+## Third-Party
+
+- [Official addons repository](https://github.com/Emerald-Services/Addons/)
+- [Syphers Addons](https://github.com/SypherRed/SB_Addons_Unofficial)
+- [BuiltByBit](https://builtbybit.com/supportbot)
+- [Polymart](https://polymart.org/resource/supportbot-1-discord-ticket-bot.518)
+
+
+## Contributors
+
+<a href="https://github.com/Emerald-Services/SupportBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=Emerald-Services/SupportBot">
+</a>
+
+## Hosting
+
+You can use our [Pterodactyl egg](https://github.com/Emerald-Services/Pterodactyl-Egg) to host it on your own panel. We currently don't offer hosting for you, altough we might add this in the future.
+If you don't know how to install pterodactyl, you could always host it on replit:
+
+[![Run on Repl.it](https://repl.it/badge/github/ItsNyoty/IKI-bot)]([https://repl.it/github/ItsNyoty/iki](https://repl.it/github/Emerald-Services/SupportBot
+)
 
-  SupportBot is an open-sourced support system for discord. It's completely free to use with high amounts of customisation to match your own brand. 
 
-  ## Quick Links
 
-  **|** [Discord](https://emeraldsrv.dev/discord) **|**
-  [Hosting](https://emeraldsrv.dev/hosting) **|**
-  [Documentation](https://docs.emeraldsrv.dev) **|**
-  [Download via Polymart](https://polymart.org/resource/supportbot-1-discord-ticket-bot.518) **|**
-  [Download via MC-Market](https://www.mc-market.org/resources/8940/) **|**

SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 7.7.2   | :white_check_mark: |
+| 7.7.1   | :white_check_mark: |
+| < 4.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

Structures/Addon.js

@@ -0,0 +1,27 @@
+
+// SupportBot | Emerald Services
+// Addon Structure
+class Command {
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.permissions = options.permissions;
+    this.options = options.options || [];
+    this.run = options.run;
+    this.defaultPermission = true;
+  }
+
+  // Method to dynamically update options
+  setOptions(options) {
+    this.options = options;
+  }
+}
+
+class Event {
+  constructor(event, run) {
+    this.event = event;
+    this.run = run;
+  }
+}
+
+module.exports = { Command, Event };

Structures/Client.js

@@ -0,0 +1,194 @@
+const fs = require("fs");
+const Discord = require("discord.js");
+const { GatewayIntentBits, Partials } = require('discord.js');
+const yaml = require("js-yaml");
+const { Command, Event } = require('./Addon.js'); // Adjust the path as needed
+
+const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
+const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
+
+class Client extends Discord.Client {
+  constructor() {
+    super({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMembers,
+        GatewayIntentBits.GuildMessages
+      ],
+      partials: [Partials.Channel]
+    });
+
+    this.commands = new Discord.Collection();
+  }
+
+  async getChannel(channel, guild) {
+    if (!channel) return null; // Add check for undefined channel
+    return guild.channels.cache.find(
+      (c) =>
+        (c.type === Discord.ChannelType.GuildText || c.type === Discord.ChannelType.GuildNews) &&
+        (c.id === channel || (c.name && c.name.toLowerCase() === channel.toLowerCase()))
+    );
+  }
+
+  async getRole(role, guild) {
+    if (!role) return null; // Add check for undefined role
+    return guild.roles.cache.find(
+      (r) => r.id === role || (r.name && r.name.toLowerCase() === role.toLowerCase())
+    );
+  }
+
+  async getCategory(category, guild) {
+    if (!category) return null; // Add check for undefined category
+    return guild.channels.cache.find(
+      (c) =>
+        c.type === Discord.ChannelType.GuildCategory &&
+        (c.id === category || (c.name && c.name.toLowerCase() === category.toLowerCase()))
+    );
+  }
+
+  async start(token) {
+    let tempCommandFiles = fs.readdirSync("./Commands").filter((file) => file.endsWith(".js"));
+
+    if (cmdconfig.Suggestion.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "suggest.js");
+    }
+
+    if (cmdconfig.Help.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "help.js");
+    }
+
+    if (cmdconfig.Info.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "info.js");
+    }
+
+    if (cmdconfig.OpenTicket.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "ticket.js");
+    }
+
+    if (cmdconfig.CloseTicket.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "close.js");
+    }
+
+    if (cmdconfig.Embed.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "embed.js");
+    }
+
+    if (cmdconfig.Translate.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "translate.js");
+    }
+
+    if (cmdconfig.UserInfo.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "userinfo.js");
+    }
+
+    if (cmdconfig.Ping.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "Ping.js");
+    }
+
+    if (cmdconfig.AddUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "addUser.js");
+    }
+
+    if (cmdconfig.RemoveUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "removeUser.js");
+    }    
+
+    if (cmdconfig.ForceAddUser.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "forceaddUser.js");
+    }   
+
+    if (cmdconfig.Profile.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "profile.js");
+    }    
+
+    if (cmdconfig.Settings.Enabled === false) {
+      tempCommandFiles = tempCommandFiles.filter(item => item !== "settings.js");
+    }    
+
+    const commandFiles = tempCommandFiles;
+    const commands = commandFiles.map((file) => require(`../Commands/${file}`));
+
+    // Load main commands
+    console.log(`\u001b[33m`, "――――――――――――――――――――――――――――――――――――――――――――");
+
+    commands.forEach((cmd) => {
+      console.log(`\u001b[32m`, `[CMD]`, `\u001b[37;1m`, `${cmd.name}`, `\u001b[32;1m`, "Loaded");
+      this.commands.set(cmd.name, cmd);
+    });
+
+    // Load addon commands and events
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Commands ▬▬▬▬▬▬▬");
+
+    if (supportbot.General.Addons.Enabled) {
+      const addonFiles = fs.readdirSync("./Addons").filter((file) => file.endsWith(".js"));
+
+      const addons = addonFiles.map((file) => {
+        const addon = require(`../Addons/${file}`);
+        addon.name = file.split(".")[0];
+        return addon;
+      });
+
+      // Addons
+      console.log("   ");
+      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
+
+      addons.forEach((addon) => {
+        console.log(
+          `\u001b[32m`,
+          `[ADDON]`,
+          `\u001b[37;1m`,
+          `${addon.name}`,
+          `\u001b[32;1m`,
+          "Loaded"
+        );
+
+        if (addon instanceof Command) {
+          this.commands.set(addon.name, addon);
+        }
+
+        if (addon.events && Array.isArray(addon.events)) {
+          addon.events.forEach((event) => {
+            if (event instanceof Event) {
+              this.on(event.event, (...args) => event.run(this, ...args));
+            }
+          });
+        }
+      });
+
+      console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Addons ▬▬▬▬▬▬▬");
+    }
+
+    // Register Slash Commands
+
+    this.once("ready", async () => {
+      await this.guilds.cache.first()?.commands.set(this.commands);
+      console.log(
+        "\u001b[32m",
+        `[SUCCESS]`,
+        `\u001b[37;1m`,
+        `Slash Commands Registered for ${this.guilds.cache.first().name}`
+      );
+    });
+
+    console.log("   ");
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+
+    fs.readdirSync("./Events").filter((file) => file.endsWith(".js")).forEach((file) => {
+      const event = require(`../Events/${file}`);
+      console.log(`\u001b[32m`, `[EVENT]`, `\u001b[37;1m`, `${event.event}`, `\u001b[32;1m`, "Loaded");
+      this.on(event.event, (...args) => event.run(this, ...args));
+    });
+
+    console.log(`\u001b[33m`, "▬▬▬▬▬▬▬ Events ▬▬▬▬▬▬▬");
+    if (process.argv[2] !== "test") {
+      await this.login(token);
+    } else {
+      console.log(
+        `\u001b[31;1m`,
+        "RUNNING IN TEST MODE, IF NOT INTENDED, PLEASE USE npm start"
+      );
+    }
+  }
+}
+
+module.exports = Client;

Structures/Command.js

@@ -0,0 +1,14 @@
+// SupportBot | Emerald Services
+// Command Structure
+
+class Command {
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.permissions = options.permissions || [];
+    this.options = options.options || [];
+    this.run = options.run;
+    this.defaultPermission = true;
+  }
+}
+module.exports = Command;

Structures/Event.js

@@ -0,0 +1,10 @@
+// SupportBot | Emerald Services
+// Event Structure
+class Event {
+  constructor(event, run) {
+    this.event = event;
+    this.run = run;
+  }
+}
+
+module.exports = Event;

Structures/TicketID.js

@@ -0,0 +1,47 @@
+// SupportBot | Emerald Services
+// Ticket ID Structure
+
+const fs = require("fs");
+
+class TicketNumberID {
+  static async pad() {
+    let num = await this.get();
+    let n = num + "";
+    await this.set(num + 1);
+    return n.length >= 4 ? n : new Array(4 - n.length + 1).join("0") + n;
+  }
+
+  static async get() {
+    let ticketnumberID = await JSON.parse(
+      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
+    );
+    if (!ticketnumberID.id) {
+      return this.set(0);
+    } else {
+      return ticketnumberID.id;
+    }
+  }
+
+  static async set(value) {
+    let ticketnumberID = await JSON.parse(
+      fs.readFileSync("./Data/ticket-panel-id.json", "utf8")
+    );
+
+    ticketnumberID.id = value;
+    fs.writeFileSync(
+      "./Data/ticket-panel-id.json",
+      JSON.stringify(ticketnumberID, null, 4),
+      (err) => {
+        if (err) console.error(err);
+      }
+    );
+
+    return value;
+  }
+
+  static async reset() {
+    return await this.set(0);
+  }
+}
+
+module.exports = TicketNumberID;

addons/addon-example.js

@@ -1,20 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Help Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-
-// location for the addons configuration, to keep it simple we generate a settings folder within the addons directory.
-const example = yaml.load(fs.readFileSync('./addons/settings/exampleaddon.yml', 'utf8'));
-
-module.exports = {
-    name: example.ExampleAddonCommand,
-    description: example.ExampleAddonDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages == "true") message.delete();
-        message.channel.send(example.ExampleAddonMessage)
-    }
-};

addons/settings/exampleaddon.yml

@@ -1,9 +0,0 @@
-#
-# SupportBot, Created by Emerald Services
-# Example Addon
-#
-
-ExampleAddonCommand: "exampleaddon"
-ExampleAddonDesc: "This is the default/example addon for SupportBot."
-
-ExampleAddonMessage: "> :white_check_mark: This is the **default** addon for SupportBot. You can download addons from our website, https://emeraldservices.xyz/"

commands/addUser.js

@@ -1,64 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Add User
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.AddUser,
-    description: supportbot.AddUserDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages) message.delete();
-        
-        let SupportStaff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff) || message.guild.roles.cache.find(SupportTeam => SupportTeam.id === supportbot.Staff)
-        let Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin) || message.guild.roles.cache.find(AdminUser => AdminUser.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (message.member.roles.cache.has(SupportStaff.id) || message.member.roles.cache.has(Admins.id)) {
-                if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-                    const Exists = new Discord.MessageEmbed()
-                        .setTitle("No Ticket Found!")
-                        .setDescription(`${supportbot.NoValidTicket}`)
-                        .setColor(supportbot.WarningColour);
-                    message.channel.send({ embeds: [Exists] });
-        
-                    return;
-                }
-        
-                let rUser = message.guild.member(message.mentions.users.first() || message.guild.members.cache.get(args[0]));
-                    const UserNotExist = new Discord.MessageEmbed()
-                        .setTitle("User Not Found!")
-                        .setDescription(`${supportbot.UserNotFound}\n\nTry Again:\`${supportbot.Prefix}${supportbot.AddUser} <user#0000>\``)
-                        .setColor(supportbot.ErrorColour)
-        
-                    if (!rUser) return message.channel.send({ embeds: [UserNotExist] });
-                
-                        message.channel.updateOverwrite(rUser, {
-                            VIEW_CHANNEL: true,
-                            CREATE_INVITE: false,
-                            SEND_MESSAGES: true,
-                            READ_MESSAGES: true
-                        });
-                
-                    const Complete = new Discord.MessageEmbed()
-                        .setTitle("User Added!")
-                        .setDescription(supportbot.AddedUser.replace(/%user%/g, rUser.id))
-                        .setTimestamp()
-                        .setColor(supportbot.EmbedColour)
-                   message.channel.send({ embeds: [Complete] });
-            } else {
-                
-                return message.channel.send({ embeds: [NoPerms] });
-
-            }
-
-    }
-};

commands/announce.js

@@ -1,71 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Announce
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.AnnounceCommand,
-    description: supportbot.AnnounceDesc,
-
-    execute(message, args) {
-	    
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let locateChannel = message.guild.channels.cache.find(AnnouncementChannel => AnnouncementChannel.name === supportbot.AnnouncementChannel) || message.guild.channels.cache.find(AnnouncementChannel => AnnouncementChannel.id === supportbot.AnnouncementChannel)
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.AnnouncementChannel}`)
-            .setColor(supportbot.ErrorColour);
-
-        if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-        let Admins = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${Admins.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(Admins.id)) 
-                return message.channel.send({ embeds: [NoPerms] });
-
-
-            const embed = new Discord.MessageEmbed()
-                .setDescription(`> **${supportbot.AnnouncementStarter}**`)
-	            .setColor(supportbot.EmbedColour)
-            message.channel.send({ embeds: [embed] });
-
-            let announcement = []
-            message.channel.awaitMessages(response => response.content.length > 2, {
-                max: 1,
-                time: 500000,
-                errors: ['time'],
-            }).then((collected) => {
-                announcement.push(collected.map(r => r.content));
-
-                locateChannel.send('@everyone')
-                const AnnouncementEmbed = new Discord.MessageEmbed()
-                    .setTitle(supportbot.AnnouncementTitle)
-                    .setThumbnail(supportbot.AnnouncementIcon)
-                    .setDescription(announcement)
-                    .setColor(supportbot.EmbedColour)
-                    .setFooter(supportbot.EmbedFooter, message.author.displayAvatarURL());
-                
-                locateChannel.send({ embed: AnnouncementEmbed }).then(async function(msg) {
-                    const AnnouncementComplete = new Discord.MessageEmbed()
-                        .setColor(supportbot.SuccessColour)
-                        .setDescription(`:white_check_mark: You have successfully created an announcement. <#${locateChannel.id}>`)
-                    message.channel.send({ embeds: [AnnouncementComplete] })
-                })
-
-            });
-
-    }
-    
-};

commands/ban.js

@@ -1,108 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Say Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.BanUser,
-    description: supportbot.BanDesc,
-
-    execute(message, args, member) {
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(SupportStaff.id)) 
-                return message.channel.send({ embeds: [NoPerms] });
-
-            let locateChannel = message.guild.channels.cache.find(ModLogChannel => ModLogChannel.name === supportbot.ModLogChannel) || message.guild.channels.cache.find(ModLogChannel => ModLogChannel.id === supportbot.ModLogChannel)
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.ModLogChannel}\``)
-            .setColor(supportbot.ErrorColour);
-    
-            if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-            const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
-
-            const embed1 = new Discord.MessageEmbed()
-                .setDescription("> :x: Please provide a reason to ban.\n\n`Try Again!`")
-	            .setColor(supportbot.ErrorColour)
-
-            if (!args[0]) return message.channel.send({
-                embeds: [embed1]
-            });
-
-            const embed2 = new Discord.MessageEmbed()
-                .setDescription("> :detective: **Hmm!** Can\'t seem tp find this user.\n\n`Are they in the server?`")
-	            .setColor(supportbot.EmbedColour)
-
-            if (!user) return message.channel.send({
-                embeds: [embed2]
-            })
-
-            const embed3 = new Discord.MessageEmbed()
-                .setDescription("> :x: **Err No!** Cannot punish this user!\n\n`Reason: Their permissions and or roles are greater than mine.`")
-	            .setColor(supportbot.EmbedColour)
-
-            if(!user.bannable) return message.channel.send({
-                embeds: [embed3]
-            });
-
-            const embed4 = new Discord.MessageEmbed()
-                .setDescription("> :joy: **OML!** Did you really just try to ban yourself!")
-	            .setColor(supportbot.EmbedColour)
-
-            if(user.id === message.author.id) return message.channel.send({
-                embeds: [embed4]
-            });
-
-            let reason = args.slice(1).join(" ");
-
-            if(!reason) reason = 'No Reason Provided.';
-
-            const embed5 = new Discord.MessageEmbed()
-                .setDescription("> :thinking: **Hmm** Something seems to have gone wrong.\n\n`Check your system for errors!`")
-	            .setColor(supportbot.EmbedColour)
-
-                  user.ban({ days: supportbot.DaysBannedFor, reason: `${reason}` }).catch(err => { 
-                    message.channel.send({ embeds: [embed5] })
-                      console.log(err)
-                  })
-
-
-            const successEmbed = new Discord.MessageEmbed()
-                .setDescription(`> :white_check_mark: **OOF!** ${user} has been banned!`)
-                .setColor(supportbot.SuccessColour)
-            message.channel.send({
-                embed: successEmbed
-            })
-
-            const logEmbed = new Discord.MessageEmbed()
-                .setTitle(supportbot.BanTitle)
-                .setThumbnail(supportbot.ModThumbnail)
-                .addField('Banned User:', user)
-                .addField('Staff Member', message.author)
-                .addField('Reason:', reason)
-                .setFooter(supportbot.EmbedFooter)
-                .setColor(supportbot.BanLogColour)
-                .setTimestamp()
-
-                locateChannel.send({ embeds: [logEmbed] })
-    
-
-
-    } 
-    
-};

commands/blacklistUser.js

@@ -1,100 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Blacklist Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.BlacklistUser,
-    description: supportbot.BlacklistDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages) message.delete();
-
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff.name}\``)
-            .setColor(supportbot.WarningColour)
-
-        if (!message.member.roles.cache.has(SupportStaff.id)) {
-            return message.channel.send({ embeds: [NoPerms] });
-        }
-
-        let locateChannel = message.guild.channels.cache.find(ModLogChannel => ModLogChannel.name === supportbot.ModLogChannel) || message.guild.channels.cache.find(ModLogChannel => ModLogChannel.id === supportbot.ModLogChannel)
-
-        const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.ModLogChannel}\``)
-            .setColor(supportbot.ErrorColour);
-    
-        if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-        const embed1 = new Discord.MessageEmbed()
-                .setDescription("> :x: Please mention or write an ID\n\n`Try Again!`")
-	            .setColor(supportbot.ErrorColour)
-
-        if (!args[0]) return message.channel.send({
-                embeds: [embed1]
-        });
-
-        const embed2 = new Discord.MessageEmbed()
-                .setDescription("> :detective: **Hmm!** Can\'t seem tp find this user.\n\n`Are they in the server?`")
-	            .setColor(supportbot.EmbedColour)
-
-        if (!user) return message.channel.send({
-            embeds: [embed2]
-        });
-
-        let role = message.guild.roles.cache.find(role => role.name === supportbot.TicketBlackListRole) || message.guild.roles.cache.find(role => role.id === supportbot.TicketBlackListRole)
-
-        const embed3 = new Discord.MessageEmbed()
-            .setDescription("> :detective: **Hmm!** Can\'t seem to find the blacklist role.\n\n`Did you created it?")
-            .setColor(supportbot.ErrorColour)
-        
-
-        if (!role) return message.channel.send({
-            embeds: [embed3]
-        });
-
-        const embed4 = new Discord.MessageEmbed()
-            .setDescription(`${user} is already blacklisted`)
-            .setColor(supportbot.ErrorColour)
-        
-        if(user.roles.cache.find(role => role.name === supportbot.TicketBlackListRole) || user.roles.cache.find(role => role.id === supportbot.TicketBlackListRole)) {
-            return message.channel.send({
-                embeds: [embed4]
-            })
-        };
-
-        user.roles.add(role);
-
-        const embed5 = new Discord.MessageEmbed()
-            .setDescription(`Blacklisted ${user} successfully from creating a ticket`)
-            .setColor(supportbot.EmbedColour)
-
-        message.channel.send({
-            embeds: [embed5]
-        });
-
-        const logEmbed = new Discord.MessageEmbed()
-                .setTitle(supportbot.BlacklistTitle)
-                .setThumbnail(supportbot.ModThumbnail)
-                .addField('Banned User:', user)
-                .addField('Staff Member', message.author)
-                .setFooter(supportbot.EmbedFooter)
-                .setColor(supportbot.BlacklistColour)
-                .setTimestamp()
-
-        locateChannel.send({ embeds: [logEmbed] });
-
-    }
-
-};

commands/botSay.js

@@ -1,51 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Say Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.BotSay,
-    description: supportbot.BotSayDesc,
-
-    execute(message, args) {
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Staff) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Staff)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(SupportStaff.id)) 
-                return message.channel.send({ embeds: [NoPerms] });
-
-
-            const embed = new Discord.MessageEmbed()
-                .setDescription(`> **What would you like me to say!**`)
-	            .setColor(supportbot.EmbedColour)
-            message.channel.send({ embeds: [embed] });
-
-            let announcement = []
-            message.channel.awaitMessages(response => response.content.length > 2, {
-                max: 1,
-                time: 500000,
-                errors: ['time'],
-            }).then((collected) => {
-                announcement.push(collected.map(r => r.content));
-
-                const AnnouncementEmbed = new Discord.MessageEmbed()
-                    .setDescription(announcement)
-                    .setColor(supportbot.EmbedColour)
-                
-                message.channel.send({ embeds: [AnnouncementEmbed] })
-        })
-
-    } 
-    
-};

commands/close.js

@@ -1,163 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Close Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.CloseTicket,
-    description: supportbot.CloseTicketDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages) message.delete();
-        
-        if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-            const Exists = new Discord.MessageEmbed()
-                .setTitle("No Ticket Found!")
-                .setDescription(`${supportbot.NoValidTicket}`)
-                .setColor(supportbot.WarningColour);
-            message.channel.send({ embed: Exists });
-
-            return;
-
-        }
-
-        if (supportbot.CloseConfirmation) {
-            const CloseTicketRequest = new Discord.MessageEmbed()
-                .setTitle(`**${supportbot.ClosingTicket}**`)
-                .setDescription(`Please confirm by repeating the following word.. \`${supportbot.ClosingConfirmation_Word}\` `)
-                .setColor(supportbot.EmbedColour);
-
-            message.channel.send(CloseTicketRequest).then(m => {
-                message.channel.awaitMessages( response => response.content.toLowerCase() === supportbot.ClosingConfirmation_Word, {
-                    max: 1,
-                    time: 20000,
-                    errors: [ 'time' ],
-
-                    
-                }).then( collected => {
-                    let logChannel = message.guild.channels.cache.find(channel => channel.name === supportbot.TranscriptLog) || message.guild.channels.cache.find(channel => channel.id === supportbot.TranscriptLog)
-                    let user = message.author;
-                    let reason = args.join(" ") || "No Reason Provided.";
-
-                    let name = message.channel.name;
-                    let ticketChannel = message.channel;
-
-                    message.channel.send(`**${supportbot.ClosingTicket}**`)
-
-                    .then(() => {
-                        const logEmbed = new Discord.MessageEmbed()
-                            .setTitle(supportbot.TranscriptTitle)
-                            .setColor(supportbot.EmbedColour)
-                            .setFooter(supportbot.EmbedFooter)
-                            .addField("Closed By", message.author.tag)
-                            .addField("Reason", reason);
-
-                        message.channel.messages.fetch({ limit: 100 }).then( msgs => {
-                            let html = '';
-
-                            msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-                            html += `<strong>Server Name:</strong> ${message.guild.name}<br>`;
-                            html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`;
-                            html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
-
-                            msgs.forEach( msg => {
-                                if ( msg.content ) {
-                                    html += `<strong>User:</strong> ${msg.author.tag}<br>`;
-                                    html += `<strong>Message:</strong> ${msg.content}<br>`;
-                                    html += `-----<br><br>`;
-                                }
-                            });
-
-                            logChannel.send({embeds: [logEmbed]}).catch(err => {
-                                message.reply(err)
-                            })
-
-
-                            let file = new Discord.MessageAttachment( Buffer.from( html ), `${name}.html` )
-                            logChannel.send({embeds: [logEmbed], files: [file]}).catch(err => {
-                                message.reply(err)
-                            })
-
-                            message.channel.delete().catch(error => {
-                                if (error.code !== Discord.Constants.APIErrors.UNKNOWN_CHANNEL) {
-                                    console.error('Failed to delete the message:', error);
-                                }
-                            });
-
-
-                        })
-                    })
-
-                })
-
-            }).catch( () => {
-                interaction.m.edit({content: 'The request to close the ticket has timed out.'}).then(m2 => setTimeout(() => channel.delete(3000)) );
-            });
-
-        }
-
-        if (!supportbot.CloseConfirmation) {
-
-                    let logChannel = message.guild.channels.cache.find(channel => channel.name === supportbot.TranscriptLog) || message.guild.channels.cache.find(channel => channel.id === supportbot.TranscriptLog)
-                    let user = message.author;
-                    let reason = args.join(" ") || "No Reason Provided.";
-
-                    let name = message.channel.name;
-                    let ticketChannel = message.channel;
-
-                    message.channel.send(`**${supportbot.ClosingTicket}**`)
-
-                    .then(() => {
-                        const logEmbed = new Discord.MessageEmbed()
-                            .setTitle(supportbot.TranscriptTitle)
-                            .setColor(supportbot.EmbedColour)
-                            .setFooter(supportbot.EmbedFooter)
-                            .addField("Closed By", message.author.tag)
-                            .addField("Reason", reason);
-
-                        message.channel.messages.fetch({ limit: 100 }).then( msgs => {
-                            let html = '';
-
-                            msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-                            html += `<strong>Server Name:</strong> ${message.guild.name}<br>`;
-                            html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`;
-                            html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
-
-                            msgs.forEach( msg => {
-                                if ( msg.content ) {
-                                    html += `<strong>User:</strong> ${msg.author.tag}<br>`;
-                                    html += `<strong>Message:</strong> ${msg.content}<br>`;
-                                    html += `-----<br><br>`;
-                                }
-                            });
-
-                            logChannel.send({embeds: [logEmbed]}).catch(err => {
-                                message.reply(err)
-                            })
-
-                            let file = new Discord.MessageAttachment( Buffer.from( html ), `${name}.html` )
-                            logChannel.send({embeds: [logEmbed], files: [file]}).catch(err => {
-                                message.reply(err)
-                            })
-
-                            message.channel.delete().catch(error => {
-                                if (error.code !== Discord.Constants.APIErrors.UNKNOWN_CHANNEL) {
-                                    console.error('Failed to delete the message:', error);
-                                }
-                            });
-
-                        })
-
-                    }).catch( () => {
-                        interaction.m.edit({content: 'The request to close the ticket has timed out.'}).then(m2 => setTimeout(() => channel.delete(3000)) );
-                    });
-
-        }
-
-    }
-};

commands/help.js

@@ -1,85 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Help Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.HelpCommand,
-    description: supportbot.HelpDesc,
-
-    
-    execute(message, args) {
-	if (supportbot.DeleteMessages) message.delete();
-
-    let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Staff) || message.guild.roles.cache.find(staffRole => staffRole.id === supportbot.Staff);
-    let AdminStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Admin);
-        
-    if (supportbot.HelpMenu) {
-        let generalCommands = "";
-            generalCommands += `**${supportbot.Prefix}${supportbot.HelpCommand}** ${supportbot.HelpDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.LinksCommand}** ${supportbot.LinksDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.SuggestCommand}** ${supportbot.SuggestionDesc}\n`;
-            generalCommands += `**${supportbot.Prefix}${supportbot.PingCommand}** ${supportbot.PingDesc}\n`;
-        
-        let supportCommands = "";
-            supportCommands += `**${supportbot.Prefix}${supportbot.NewTicket} [reason]** ${supportbot.NewTicketDesc}\n`
-            supportCommands += `**${supportbot.Prefix}${supportbot.CloseTicket} [reason]** ${supportbot.CloseTicketDesc}\n`
-        
-        let staffCommands = "";
-            staffCommands += `**${supportbot.Prefix}${supportbot.AddUser} <user#0000>** ${supportbot.AddUserDesc}\n`
-            staffCommands += `**${supportbot.Prefix}${supportbot.RemoveUser} <user#0000>** ${supportbot.RemoveUserDesc}\n`
-            staffCommands += `**${supportbot.Prefix}${supportbot.BotSay}** ${supportbot.BotSayDesc}\n` 
-            staffCommands += `**${supportbot.Prefix}${supportbot.PurgeMessage}** ${supportbot.PurgeDesc}\n` 
-            staffCommands += `**${supportbot.Prefix}${supportbot.ChatLog}** ${supportbot.ChatLogDesc}\n` 
-	    
-        let adminCommands = "";
-            adminCommands += `**${supportbot.Prefix}${supportbot.AnnounceCommand}** ${supportbot.AnnounceDesc} \`Admin Only\`\n` 
-            adminCommands += `**${supportbot.Prefix}${supportbot.BanUser}** ${supportbot.BanDesc} \`Admin Only\` \n` 
-            adminCommands += `**${supportbot.Prefix}${supportbot.KickUser}** ${supportbot.KickDesc} \`Admin Only\` \n` 
-            adminCommands += `**${supportbot.Prefix}${supportbot.BlacklistUser}** ${supportbot.BlacklistDesc} \`Admin Only\` \n`
-            
-        const HelpEmbed1 = new Discord.MessageEmbed()
-            .setTitle(supportbot.Bot_Name)
-            .setThumbnail(message.author.displayAvatarURL())
-
-            .addFields(
-                { name: '🖥️ General Commands\n', value: `${generalCommands}\n`, inline: false },
-                { name: '🎫 Support Commands\n', value: `${supportCommands}\n`, inline: false },
-            )
-
-            .setColor(supportbot.EmbedColour)
-            .setFooter(supportbot.EmbedFooter, message.author.displayAvatarURL());
-
-            if (message.member.roles.cache.has(SupportStaff.id)) {
-                HelpEmbed1.addFields(
-                    { name: '🔐 Staff Commands\n', value: `${staffCommands}\n`, inline: false },
-                )
-            }
-	    
-            if (message.member.roles.cache.has(AdminStaff.id)) {
-                HelpEmbed1.addFields(
-                    { name: '🔐 Admin Commands\n', value: `${adminCommands}\n`, inline: false },
-                )
-            }
-
-        if (supportbot.SendHelpPage === "dm") {
-            message.author.send({ 
-                embeds: [HelpEmbed1]
-            });
-        }
-
-        if (supportbot.SendHelpPage === "channel") {
-            message.channel.send({ 
-                embeds: [HelpEmbed1]
-            });
-        }
-
-
-    }
-
-    }
-};

commands/kick.js

@@ -1,109 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Say Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.KickUser,
-    description: supportbot.KickDesc,
-
-    execute(message, args, member) {
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Admin) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff.name}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(SupportStaff.id)) 
-                return message.channel.send({ embeds: [NoPerms] });
-
-            let locateChannel = message.guild.channels.cache.find(ModLogChannel => ModLogChannel.name === supportbot.ModLogChannel) || message.guild.channels.cache.find(ModLogChannel => ModLogChannel.id === supportbot.ModLogChannel)
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.ModLogChannel}\``)
-            .setColor(supportbot.ErrorColour);
-    
-            if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-            const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
-
-            const embed1 = new Discord.MessageEmbed()
-                .setDescription("> :x: Please provide a reason to kick.\n\n`Try Again!`")
-	            .setColor(supportbot.ErrorColour)
-
-            if (!args[0]) return message.channel.send({
-                embeds: [embed1]
-            });
-
-            const embed2 = new Discord.MessageEmbed()
-                .setDescription("> :detective: **Hmm!** Can\'t seem tp find this user.\n\n`Are they in the server?`")
-	            .setColor(supportbot.EmbedColour)
-
-            if (!user) return message.channel.send({
-                embeds: [embed2]
-            })
-
-            const embed3 = new Discord.MessageEmbed()
-                .setDescription("> :x: **Err No!** Cannot punish this user!\n\n`Reason: Their permissions and or roles are greater than mine.`")
-	            .setColor(supportbot.EmbedColour)
-
-            if(!user.kickable) return message.channel.send({
-                embeds: [embed3]
-            });
-
-            const embed4 = new Discord.MessageEmbed()
-                .setDescription("> :joy: **OML!** Did you really just try to kick yourself!")
-	            .setColor(supportbot.EmbedColour)
-
-            if(user.id === message.author.id) return message.channel.send({
-                embeds: [embed4]
-            });
-
-            let reason = args.slice(1).join(" ");
-
-            if(!reason) reason = 'No Reason Provided.';
-
-            const embed5 = new Discord.MessageEmbed()
-                .setDescription("> :thinking: **Hmm** Something seems to have gone wrong.\n\n`Check your system for errors!`")
-	            .setColor(supportbot.EmbedColour)
-
-                  user.kick({ reason: `${reason}` }).catch(err => { 
-                    message.channel.send({ embeds: [embed5] })
-                      console.log(err)
-                  })
-
-
-            const successEmbed = new Discord.MessageEmbed()
-                .setDescription(`> :white_check_mark: **OOF!** ${user} has been kicked!`)
-                .setColor(supportbot.SuccessColour)
-
-            message.channel.send({
-                embeds: [successEmbed]
-            })
-
-            const logEmbed = new Discord.MessageEmbed()
-                .setTitle(supportbot.KickTitle)
-                .setThumbnail(supportbot.ModThumbnail)
-                .addField('Kicked User:', user)
-                .addField('Staff Member', message.author)
-                .addField('Reason:', reason)
-                .setFooter(supportbot.EmbedFooter)
-                .setColor(supportbot.KickLogColour)
-                .setTimestamp()
-
-                locateChannel.send({ embeds: [logEmbed] })
-    
-
-
-    } 
-    
-};

commands/links.js

@@ -1,34 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Links Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.LinksCommand,
-    description: supportbot.LinksDesc,
-
-    execute(message, args) {
-        if (supportbot.DeleteMessages) message.delete();
-        
-        const LinksEmbed = new Discord.MessageEmbed()
-            .setColor(supportbot.EmbedColour)
-
-        let botLinks = supportbot.LINKS;
-        
-        let links = '';
-        
-        for ( let name in botLinks ) {
-            links += `[${name}](${botLinks[ name ]})\n`;
-        };
-
-        LinksEmbed.addField(supportbot.LinksTitle, links)
-
-        message.channel.send({ embeds: [LinksEmbed] });
-
-    }
-};

commands/ping.js

@@ -1,25 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Ping Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.PingCommand,
-    description: supportbot.PingDesc,
-
-    execute(message, args) {        
-	if (supportbot.DeleteMessages) message.delete();
-        
-        let ping = Date.now() - message.createdTimestamp + " ms";
-        
-        const PingCommandEmbed = new Discord.MessageEmbed()
-            .setDescription(`🏓 **Pong!** \`${Date.now() - message.createdTimestamp}ms\``)
-            .setColor(supportbot.EmbedColour)
-
-	    message.channel.send({ embeds: [PingCommandEmbed] });
-    }
-};

commands/purge.js

@@ -1,79 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Say Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.PurgeMessage,
-    description: supportbot.PurgeDesc,
-
-    execute(message, args, member) {
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let SupportStaff = message.guild.roles.cache.find(adminRole => adminRole.name === supportbot.Staff) || message.guild.roles.cache.find(adminRole => adminRole.id === supportbot.Staff)
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${SupportStaff}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (!message.member.roles.cache.has(supportbot.Staff)) 
-                return message.channel.send({ embeds: [NoPerms] });
-
-            let locateChannel = message.guild.channels.cache.find(ModLogChannel => ModLogChannel.name === supportbot.ModLogChannel) || message.guild.channels.cache.find(ModLogChannel => ModLogChannel.id === supportbot.ModLogChannel)
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.ModLogChannel}\``)
-            .setColor(supportbot.ErrorColour);
-    
-            if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-            const embed1 = new Discord.MessageEmbed()
-                .setDescription(`> :thinking: **Hmm!** Please enter a valid number of message to purge!\n\n\`${supportbot.Prefix}${supportbot.PurgeMessage} <message count>\` `)
-	            .setColor(supportbot.WarningColour)
-
-            if (!args[0]) return message.channel.send({
-                embeds: [embed1]
-            });
-
-            const messagePrune = parseInt(args[0])
-
-            const embed2 = new Discord.MessageEmbed()
-                .setDescription("> :person_facepalming: **Grr!** Can you count? That ain't a number :joy:")
-	            .setColor(supportbot.ErrorColour)
-
-            if (isNaN(messagePrune)) return message.reply({
-                embeds: [embed2]
-            })
-
-            message.channel.bulkDelete(messagePrune).then(() => {
-
-                const embed3 = new Discord.MessageEmbed()
-                    .setDescription(`> :recycle: \`${args[0]} messages\` **have been purged!** `)
-	                .setColor(supportbot.ErrorColour)
-                message.channel.send({
-                    embeds: [embed3]
-                })
-            })
-
-            const logEmbed = new Discord.MessageEmbed()
-                .setTitle(supportbot.PruneLogTitle)
-                .setThumbnail(supportbot.PruneThumbnail)
-                .addField('Messages Purged', `\`${args[0]} messages\``)
-                .addField('Staff Member', `${message.author}`)
-                .setFooter(supportbot.EmbedFooter)
-                .setColor(supportbot.PruneColour)
-                .setTimestamp()
-
-                locateChannel.send({ embeds: [logEmbed] })
-    
-
-
-    } 
-    
-};

commands/removeUser.js

@@ -1,62 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Remove User
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.RemoveUser,
-    description: supportbot.RemoveUserDesc,
-
-    execute(message, args) {        
-        if (supportbot.DeleteMessages) message.delete();
-        
-        let SupportStaff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff) || message.guild.roles.cache.find(SupportTeam => SupportTeam.id === supportbot.Staff)
-        let Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin) || message.guild.roles.cache.find(AdminUser => AdminUser.id === supportbot.Admin)
-
-        const NoPerms = new Discord.MessageEmbed()
-            .setTitle("Invalid Permissions!")
-            .setDescription(`${supportbot.IncorrectPerms}\n\nRole Required: \`${supportbot.Staff}\` or \`${supportbot.Admin}\``)
-            .setColor(supportbot.WarningColour)
-
-            if (message.member.roles.cache.has(SupportStaff.id) || message.member.roles.cache.has(Admins.id)) {
-                if (!message.channel.name.startsWith( `${supportbot.TicketChannel}-` )) {
-                    const Exists = new Discord.MessageEmbed()
-                        .setTitle("No Ticket Found!")
-                        .setDescription(`${supportbot.NoValidTicket}`)
-                        .setColor(supportbot.WarningColour);
-                    message.channel.send({ embeds: [Exists] });
-        
-                    return;
-                }
-        
-                let rUser = message.guild.member(message.mentions.users.first() || message.guild.members.cache.get(args[0]));
-                    const UserNotExist = new Discord.MessageEmbed()
-                        .setTitle("User Not Found!")
-                        .setDescription(`${supportbot.UserNotFound}\n\nTry Again:\`${supportbot.Prefix}${supportbot.RemoveUser} <user#0000>\``)
-                        .setColor(supportbot.ErrorColour)
-        
-                    if (!rUser) return message.channel.send({ embeds: [UserNotExist] });
-                
-                        message.channel.updateOverwrite(rUser, {
-                            VIEW_CHANNEL: false,
-                            CREATE_INVITE: false,
-                            SEND_MESSAGES: false,
-                            READ_MESSAGES: false
-                        });
-                
-                    const Complete = new Discord.MessageEmbed()
-                        .setTitle("User Removed!")
-                        .setDescription(supportbot.RemovedUser.replace(/%user%/g, rUser.id))
-                        .setTimestamp()
-                        .setColor(supportbot.EmbedColour)
-                   message.channel.send({ embeds: [Complete] });
-            } else {
-                return message.channel.send({ embeds: [NoPerms] });
-            }
-
-    }
-};

commands/suggest.js

@@ -1,70 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Suggest Command
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = {
-    name: supportbot.SuggestCommand,
-    description: supportbot.SuggestionDesc,
-
-    execute(message, args) {
-	if (supportbot.DeleteMessages) message.delete();
-	    
-        let locateChannel = message.guild.channels.cache.find(SuggestionChannel => SuggestionChannel.name === supportbot.SuggestionChannel) || message.guild.channels.cache.find(SuggestionChannel => SuggestionChannel.id === supportbot.SuggestionChannel)
-
-        const errornochannel = new Discord.MessageEmbed()
-            .setTitle("Invalid Channel")
-            .setDescription(`${supportbot.InvalidChannel}\n\nChannel Required: \`${supportbot.SuggestionChannel}\``)
-            .setColor(supportbot.ErrorColour);
-
-        if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-
-        const embed = new Discord.MessageEmbed()
-            .setDescription(`> **${supportbot.SuggestionStarter}**`)
-	        .setColor(supportbot.EmbedColour)
-        message.channel.send({ embeds: [embed] });
-
-        let suggestion = []
-        message.channel.awaitMessages(response => response.content.length > 2, {
-            max: 1,
-            time: 500000,
-            errors: ['time'],
-        }).then((collected) => {
-            suggestion.push(collected.map(r => r.content));
-
-            const SuggestionMessage = new Discord.MessageEmbed()
-                .setColor(supportbot.EmbedColour)
-                .setFooter(supportbot.EmbedFooter)
-
-                .addField(supportbot.SuggestionTitle, suggestion, true)
-                .addField("From", `<@${message.author.id}>`, true)
-
-                if (supportbot.SuggestionMessage_Icon === "BOT") {
-                    SuggestionMessage.setThumbnail(bot.user.displayAvatarURL())
-                }
-        
-                if (supportbot.SuggestionMessage_Icon === "USER") {
-                    SuggestionMessage.setThumbnail(message.author.displayAvatarURL())
-                }
-
-                if (supportbot.SuggestionMessage_Icon === "CUSTOM") {
-                    SuggestionMessage.setThumbnail(supportbot.SuggestionIcon_URL)
-                }
-
-            locateChannel.send({ embeds: [SuggestionMessage] }).then(async function(msg) {
-                msg.react(supportbot.SuggestReact_1).then(() => msg.react(supportbot.SuggestReact_2));
-            });
-
-            const SuggestionComplete = new Discord.MessageEmbed()
-                .setColor(supportbot.SuccessColour)
-                .setDescription(`:white_check_mark: Your suggestion has been successfully created. <#${locateChannel.id}>`)
-            message.channel.send({ embeds: [SuggestionComplete] })
-
-        });
-    
-    }
-};

commands/ticket.js

@@ -1,242 +0,0 @@
-// SupportBot, Created by Emerald Services
-// Ticket Command
-
-const Discord = require("discord.js");
-const { MessageButton, MessageActionRow, Permissions } = require("discord.js");
-
-const fs = require("fs")
-const yaml = require('js-yaml');
-
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const TicketNumberID = require('../utils/TicketNumber.js');
-
-async function asyncForEach(array, callback) {
-  for (let index = 0; index < array.length; index++) {
-      await callback(array[index], index, array);
-  }
-}
-module.exports = {
-    name: supportbot.NewTicket,
-    description: supportbot.NewTicketDesc,
-
-    async execute(message, args) {
-      if (message.channel.name !== supportbot.ReactionChannel) {
-        if (supportbot.DeleteMessages) message.delete();
-      }
-
-      let reactionUser = message.guild.members.cache.get(message.author.id)
-
-      if (reactionUser.roles.cache.find(role => role.name === supportbot.TicketBlackListRole) || reactionUser.roles.cache.find(role => role.id === supportbot.TicketBlackListRole)) {
-            return message.channel.send({content:`<@${message.author.id}> ${supportbot.TicketBlackListMessage}`}).then(msg => {
-                setTimeout(() => msg.delete(), 3500)
-            })
-        }
-
-      // Ticket ID
-      let ticketNumberID = TicketNumberID.pad(message.guild.id);
-
-      // Ticket Subject
-      const TicketSubject = args || supportbot.NoTicketSubject;
-
-      const TicketExists = new Discord.MessageEmbed()
-        .setTitle("Ticket Exists!")
-        .setDescription(`${supportbot.TicketExists}`)
-        .setColor(supportbot.WarningColour)
-
-      if (message.guild.channels.cache.find(ticketChannel => ticketChannel.name === `${supportbot.TicketChannel}-${ticketNumberID}`)) {
-        return message.channel.send({ embeds: [TicketExists] });
-      }
-      const Staff = message.guild.roles.cache.find(SupportTeam => SupportTeam.name === supportbot.Staff) || message.guild.roles.cache.find(SupportTeam => SupportTeam.id === supportbot.Staff)
-      const Admins = message.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin) ||  message.guild.roles.cache.find(AdminUser => AdminUser.id === supportbot.Admin)
-      const DeptRole1 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_1}`) || message.guild.roles.cache.find(DepartmentRole => DepartmentRole.id === `${supportbot.DepartmentRole_1}`)
-      const DeptRole2 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_2}`) || message.guild.roles.cache.find(DepartmentRole => DepartmentRole.id === `${supportbot.DepartmentRole_2}`)
-      const DeptRole3 = message.guild.roles.cache.find(DepartmentRole => DepartmentRole.name === `${supportbot.DepartmentRole_3}`) || message.guild.roles.cache.find(DepartmentRole => DepartmentRole.id === `${supportbot.DepartmentRole_3}`)
-      const Author = message.author
-      const Everyone = message.guild.id
-      const ticketChannel = await message.guild.channels.create(`${supportbot.TicketChannel}-${ticketNumberID}`, {
-        type: "GUILD_TEXT",
-      })
-
-      if (message.channel.name === supportbot.ReactionChannel || message.channel.id === supportbot.ReactionChannel) {
-        const CreatedTicket = new Discord.MessageEmbed()
-            .setDescription(supportbot.TicketCreatedAlert.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, ticketChannel.id).replace(/%ticketusername%/g, message.author.username))
-            .setColor(supportbot.EmbedColour)
-        message.channel.send({embeds: [CreatedTicket]}).then(msg => {
-          setTimeout(() => msg.delete(), 5000)
-        })
-      } else {
-        const CreatedTicket = new Discord.MessageEmbed()
-            .setDescription(supportbot.TicketCreatedAlert.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, ticketChannel.id).replace(/%ticketusername%/g, message.author.username))
-            .setColor(supportbot.EmbedColour)
-        message.channel.send({embeds: [CreatedTicket]}).then(msg => setTimeout(() => msg.delete(), 5000));
-      }
-      let AllowArr = [Staff, Staff, Admins, Author]
-      await asyncForEach(AllowArr, (index) => {
-        ticketChannel.permissionOverwrites.create(index, {VIEW_CHANNEL: true})
-      })
-
-      let DenyArr = [Everyone]
-      await asyncForEach(DenyArr, (index) => {
-        ticketChannel.permissionOverwrites.create(index, {VIEW_CHANNEL: false})
-      })
-
-      let TicketCategory = message.guild.channels.cache.find(category => category.name === supportbot.TicketCategory) || message.guild.channels.cache.find(category => category.id === supportbot.TicketCategory)
-      if(TicketCategory) {
-        ticketChannel.setParent(TicketCategory.id)
-      }
-
-      if (supportbot.AllowTicketMentions) {
-        ticketChannel.send({content:`${message.author}`})
-      }
-
-      const TicketMessage = new Discord.MessageEmbed()
-          .setTitle(supportbot.Ticket_Title.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, ticketChannel.id).replace(/%ticketusername%/g, message.author.username))
-          .setDescription(supportbot.TicketMessage.replace(/%ticketauthor%/g, message.author.id).replace(/%ticketid%/g, ticketChannel.id).replace(/%ticketusername%/g, message.author.username))
-          .setColor(supportbot.EmbedColour)
-
-      if (supportbot.TicketSubject === "embed") {
-
-        if (TicketSubject != 'No Reason Provided.') {
-          TicketMessage.addFields({ name: 'Reason', value: TicketSubject })
-        }
-        
-      }
-
-      if (supportbot.TicketSubject === "description") {
-
-        if (TicketSubject != 'No Reason Provided.') {
-          ticketChannel.setTopic(`Reason: ${TicketSubject}  -  User ID: ${message.author.id}  -  Ticket: ${ticketChannel.name}`)
-        }
-        
-      }
-
-      if (supportbot.TicketDepartments) {
-        TicketMessage.addFields({ name: 'Departments', value: ` **${supportbot.DepartmentTitle_1}**\n **${supportbot.DepartmentTitle_2}**\n **${supportbot.DepartmentTitle_3}**` })
-      }
-      const CloseButton = new MessageButton()
-        .setCustomId('ticketclose')
-        .setLabel('Close')
-        .setStyle(supportbot.TicketCloseColour)
-        .setEmoji(supportbot.TicketCloseEmoji)
-
-      const LockButton = new MessageButton()
-        .setCustomId('ticketlock')
-        .setLabel('Lock')
-        .setStyle(supportbot.TicketLockColour)
-        .setEmoji(supportbot.TicketLockEmoji)
-
-      const row2 = new MessageActionRow()
-        .addComponents(CloseButton, LockButton)
-
-      if(supportbot.TicketDepartments) {
-
-        let DenyArr = [DeptRole1, DeptRole2, DeptRole3]
-        await asyncForEach(DenyArr, (index) => {
-          ticketChannel.permissionOverwrites.create(index, {VIEW_CHANNEL: false})
-        })
-        const Department1Button = new MessageButton()
-          .setCustomId('Department1')
-          .setLabel(`${supportbot.DepartmentTitle_1}`)
-          .setStyle(supportbot.TicketDept1Colour)
-          .setEmoji(supportbot.TicketDept1Emoji)
-
-        const Department2Button = new MessageButton()
-          .setCustomId('Department2')
-          .setLabel(`${supportbot.DepartmentTitle_2}`)
-          .setStyle(supportbot.TicketDept2Colour)
-          .setEmoji(supportbot.TicketDept2Emoji)
-
-        const Department3Button = new MessageButton()
-          .setCustomId('Department3')
-          .setLabel(`${supportbot.DepartmentTitle_3}`)
-          .setStyle(supportbot.TicketDept3Colour)
-          .setEmoji(supportbot.TicketDept3Emoji)
-
-        const row = new MessageActionRow()
-          .addComponents(Department1Button, Department2Button, Department3Button)
-
-        const m = await ticketChannel.send({embeds: [TicketMessage], components: [row]})
-
-        const filter = i => {
-          i.deferUpdate();
-          return i.user.id === message.author.id;
-        };
-        const collector = m.createMessageComponentCollector({ filter, max: 1, componentType: 'BUTTON', time: 60000 });
-
-        collector.on('collect',async (i) => {
-          
-          if(i.customId === 'Department1') {
-
-            ticketChannel.permissionOverwrites.edit(DeptRole1, {
-              VIEW_CHANNEL: true,
-              READ_MESSAGE_HISTORY: true,
-              SEND_MESSAGES: true,
-            })
-
-            if(!supportbot.AllowStaff) {
-              ticketChannel.permissionOverwrites.edit(Staff, { VIEW_CHANNEL: false, READ_MESSAGE_HISTORY: false, SEND_MESSAGES: false })
-            }
-
-            const Department1 = new Discord.MessageEmbed()
-                  .setDescription(`> Thank for reaching out to the **${supportbot.DepartmentTitle_1} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-            ticketChannel.send({ embeds: [Department1] });
-
-            if (supportbot.AllowTicketMentions) {
-              ticketChannel.send({content: `@here`})
-            }
-          }
-          i.message.edit({embeds: [TicketMessage], components: [row2]})
-
-          if(i.customId === 'Department2') {
-
-            ticketChannel.permissionOverwrites.edit(DeptRole2, {
-              VIEW_CHANNEL: true,
-              READ_MESSAGE_HISTORY: true,
-              SEND_MESSAGES: true,
-            })
-
-            if(!supportbot.AllowStaff) {
-              ticketChannel.permissionOverwrites.edit(Staff, { VIEW_CHANNEL: false, READ_MESSAGE_HISTORY: false, SEND_MESSAGES: false })
-            }
-
-
-            const Department2 = new Discord.MessageEmbed()
-                  .setDescription(`> Thank for reaching out to the **${supportbot.DepartmentTitle_2} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-                ticketChannel.send({ embeds: [Department2] });
-
-            if (supportbot.AllowTicketMentions) {
-              ticketChannel.send({content: `@here`})
-            }
-
-            i.message.edit({embeds: [TicketMessage], components: [row2]})
-          }
-          if(i.customId === 'Department3') {
-
-            ticketChannel.permissionOverwrites.edit(DeptRole3, {
-              VIEW_CHANNEL: true,
-              READ_MESSAGE_HISTORY: true,
-              SEND_MESSAGES: true,
-            })
-
-            if(!supportbot.AllowStaff) {
-              ticketChannel.permissionOverwrites.edit(Staff, { VIEW_CHANNEL: false, READ_MESSAGE_HISTORY: false, SEND_MESSAGES: false })
-            }
-
-            const Department3 = new Discord.MessageEmbed()
-                  .setDescription(`> Thank for reaching out to the **${supportbot.DepartmentTitle_3} Department**. Please provide us information regarding your query.`)
-                  .setColor(supportbot.EmbedColour)
-                ticketChannel.send({ embeds: [Department3] });
-
-            if (supportbot.AllowTicketMentions) {
-              ticketChannel.send({content: `@here`})
-            }
-            i.message.edit({embeds: [TicketMessage], components: [row2]})
-          }
-        })
-      } else {
-        ticketChannel.send({embeds: [TicketMessage], components: [row2]})
-      }
-    }   
-}

commands/transcript.js

@@ -1,60 +0,0 @@
-
-// SupportBot, Created by Emerald Services
-// Announce
-const Discord = require("discord.js");
-const fs = require("fs");
-const yaml = require('js-yaml');
-const { execute } = require("./help");
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-module.exports = {
-    name: supportbot.ChatLog,
-    description: supportbot.ChatLogDesc,
-    execute(message, args) {
-        if (supportbot.DeleteMessages) message.delete();
-        let name = message.channel.name;
-    
-        message.channel.messages.fetch({ limit: 100 }).then( msgs => {
-            let html = '';
-    
-            msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-            html += `<strong>--- Channel Transcript ---</strong><br>`;
-            html += `<strong>Server Name:</strong> ${message.guild.name}<br>`;
-            html += `<strong>Channel:</strong> ${name}<br>`;
-            html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`;
-    
-            msgs.forEach( msg => {
-                if ( msg.content ) {
-                    html += `<strong>User:</strong> ${msg.author.tag}<br>`;
-                    html += `<strong>Message:</strong> ${msg.content}<br>`;
-                    html += `-----<br><br>`;
-                }
-            });
-    
-            const TranscriptSavedEmbed = new Discord.MessageEmbed()
-              .setDescription(supportbot.ChatLogSavedMessage)
-              .setColor(supportbot.SuccessColour)
-            message.channel.send({embeds: [TranscriptSavedEmbed]})
-            const errornochannel = new Discord.MessageEmbed()
-                .setTitle("SupportBot Error!")
-                .setDescription(`:x: **Error!** Channel not Found, This command cannot be executed proberbly as their is no channel within this server.\nThis is configurable via **supportbot-config.yml**\n\nChannel Required: \`${supportbot.ChatLogChannel}\`\n\nError Code: \`SB-03\``)
-                .setColor(supportbot.ErrorColour);
-  
-            const ChatLogs = new Discord.MessageEmbed()
-                .setTitle(supportbot.ChatLog_Title)
-                .setThumbnail(supportbot.ChatLog_Thumbnail)
-                .addFields(
-                    { name: 'Channel', value: `<#${message.channel.id}>` },
-                    { name: 'User', value: `<@${message.author.id}>` },
-                )
-                .setColor(supportbot.EmbedColour)
-                .setFooter(supportbot.EmbedFooter)
-            let locateChannel = message.guild.channels.cache.find(LocateChannel => LocateChannel.name === supportbot.ChatLogChannel) || message.guild.channels.cache.find(LocateChannel => LocateChannel.id === supportbot.ChatLogChannel)
-  
-            if(!locateChannel) return message.channel.send({ embeds: [errornochannel] });
-            
-            let file = new Discord.MessageAttachment( Buffer.from( html ), `${name}.html` )
-            locateChannel.send({embeds: [ChatLogs], files: [file]})
-    
-        })
-    }
-}

events/guildMemberAdd.js

@@ -1,58 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, member) => {
-
-  if (supportbot.SystemMessages) {
-    const SystemChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.UserJoined_Channel) || member.guild.channels.cache.get(supportbot.UserJoined_Channel)
-    
-    if (!SystemChannel) return;
-    
-    console.log(`[${supportbot.Bot_Name}]: ${member.user.username} has joined ${member.guild.name}!`)
-    console.log(supportbot.AutoRole_Role)
-    
-    const role = member.guild.roles.cache.find(role => role.name === supportbot.AutoRole_Role) || member.guild.roles.cache.find(role => role.id === supportbot.AutoRole_Role)
-    
-    member.roles.add(role).catch(console.error);
-    
-    if (supportbot.SystemMessage_Type === "embed") {
-        
-      const GuildAddMember = new Discord.MessageEmbed()
-        .setTitle(supportbot.Welcome_Title)
-        .setDescription(supportbot.WelcomeMessage.replace(/%member%/g, `<@!${member.user.id}>`).replace(/%guildname%/g, member.guild.name))
-        .setColor(supportbot.EmbedColour)
-
-        if (supportbot.SystemMessage_Icon === "BOT") {
-            GuildAddMember.setThumbnail(bot.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "USER") {
-            GuildAddMember.setThumbnail(member.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "CUSTOM") {
-          SuggestionMessage.setThumbnail(supportbot.SystemMessageIcon_URL)
-      }
-
-
-        if (supportbot.SystemMessage_EmbedFooter) {
-            GuildAddMember.setFooter(supportbot.EmbedFooter)
-        }
-
-    SystemChannel.send({ embeds: [GuildAddMember] });
-        
-    }
-
-    if (supportbot.SystemMessage_Type === "normal") {
-        SystemChannel.send({content: supportbot.WelcomeMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name)})
-
-    }
-
-  }
-};

events/guildMemberRemove.js

@@ -1,51 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, member) => {
-
-  if (supportbot.SystemMessages) {
-    const SystemChannel = member.guild.channels.cache.find(channel => channel.name === supportbot.UserDeparted_Channel) || member.guild.channels.cache.get(supportbot.UserDeparted_Channel)
-    
-    if (!SystemChannel) return;
-    
-    console.log(`\u001b[31m.`, `[${supportbot.Bot_Name}]: ${member.user.username} has left ${member.guild.name}!`)
-
-    if (supportbot.UserDeparted_Type === "embed") {
-      const GuildRemoveMember = new Discord.MessageEmbed()
-        .setTitle(supportbot.Departed_Title)
-        .setDescription(supportbot.DepartedMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name))
-        .setColor(supportbot.EmbedColour)
-
-        if (supportbot.SystemMessage_Icon === "BOT") {
-          GuildRemoveMember.setThumbnail(bot.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "USER") {
-          GuildRemoveMember.setThumbnail(member.user.displayAvatarURL())
-        }
-
-        if (supportbot.SystemMessage_Icon === "CUSTOM") {
-          SuggestionMessage.setThumbnail(supportbot.SystemMessageIcon_URL)
-      }
-
-        if (supportbot.SystemMessage_EmbedFooter) {
-          GuildRemoveMember.setFooter(supportbot.EmbedFooter)
-        }
-
-    SystemChannel.send({ embeds: [GuildRemoveMember] });
-        
-    }
-
-    if (supportbot.SystemMessage_Type === "normal") {
-        SystemChannel.send({content: supportbot.DepartedMessage.replace(/%member%/g, member.user.username).replace(/%guildname%/g, member.guild.name)})
-
-    }
-
-  }
-};

events/interactionCreate.js

@@ -1,128 +0,0 @@
-// SupportBot Interaction Event
-// SupportBot Created by Emerald Services
-
-const fs = require("fs");
-const { MessageEmbed, MessageAttachment, Permissions, MessageButton, MessageActionRow } = require("discord.js");
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, interaction, args) => {
-
-	if (interaction.isCommand()) return;
-
-    if(interaction.isButton()) {
-        if(interaction.customId === 'openticket') {
-            interaction.message.fetch()
-            interaction.deferUpdate()
-            let message = {
-                guild: bot.guilds.cache.get(interaction.message.guildId),
-                author: bot.users.cache.get(interaction.user.id),
-                content: "N/A",
-                channel: bot.channels.cache.get(interaction.message.channelId)
-            }
-            try {
-                const cmd = bot.commands.get(supportbot.NewTicket);
-                if(!cmd) return;
-                cmd.execute(message, message.content)
-            }
-            catch (error){
-               console.error(error) 
-            }
-        }
-        if(interaction.customId === 'ticketclose') {
-            if(interaction.channel.name.startsWith(`${supportbot.TicketChannel}-`)) {
-                interaction.message.fetch()
-                interaction.deferUpdate()
-                const DeleteTicketEmbed = new MessageEmbed()
-                    .setDescription(supportbot.TicketDeleteMessage)
-                    .setColor(supportbot.EmbedColour)
-                interaction.channel.send({embeds: [DeleteTicketEmbed]})
-
-                let logChannel = interaction.guild.channels.cache.find(channel => channel.name === supportbot.TranscriptLog) || interaction.guild.channels.cache.find(channel => channel.id === supportbot.TranscriptLog)
-
-                let user = interaction.user
-                let name = interaction.channel.name;
-                let ticketChannel = interaction.channel
-                let reason = "No Reason Provided."
-
-                interaction.channel.send({content: `**${supportbot.ClosingTicket}**`})
-                .then(() => {
-                    const logEmbed = new MessageEmbed()
-                        .setTitle(supportbot.TranscriptTitle)
-                        .setColor(supportbot.EmbedColour)
-                        .setFooter(supportbot.EmbedFooter)
-                        .addField("Closed By", user.username)
-                        .addField("Reason", reason)
-
-                    interaction.channel.messages.fetch({limit: 100}).then(msgs => {
-                        let html = ''
-
-                        msgs = msgs.sort( ( a, b ) => a.createdTimestamp - b.createdTimestamp );
-                        html += `<strong>Server Name:</strong> ${interaction.guild.name}<br>`
-                        html += `<strong>Ticket:</strong> ${ticketChannel.name}<br>`
-                        html += `<strong>Message:</strong> ${msgs.size} Messages<br><br><br>`
-
-
-                        msgs.forEach(msg => {
-                            if(msg.content) {
-                                html += `<strong>User:</strong> ${msg.author.tag}<br>`;
-                                html += `<strong>Message:</strong> ${msg.content}<br>`;
-                                html += `-----<br><br>`;
-                            }
-                        })
-
-                        const TranscriptSavedEmbed = new MessageEmbed()
-                            .setDescription(supportbot.TranscriptSavedMessage)
-                            .setColor(supportbot.SuccessColour)
-                        interaction.channel.send({embeds: [TranscriptSavedEmbed]})
-
-                        let file = new MessageAttachment( Buffer.from( html ), `${name}.html` )
-                        logChannel.send({embeds: [logEmbed], files: [file]})
-
-                        setTimeout(() => interaction.channel.delete(), supportbot.TicketDeleteTime)
-
-                    })
-                })
-            }
-        }
-        if(interaction.customId === 'ticketlock') {
-            if(interaction.channel.name.startsWith(`${supportbot.TicketChannel}`)) {
-                interaction.message.fetch()
-                interaction.deferUpdate()
-                let Admin = interaction.guild.roles.cache.find(AdminUser => AdminUser.name === supportbot.Admin) ||  interaction.guild.roles.cache.find(AdminUser => AdminUser.id === supportbot.Admin)
-                let all = interaction.channel.permissionOverwrites.cache
-
-                let parent = interaction.guild.channels.cache.find(c => c.name === `${supportbot.LockTicketCategory}`) || interaction.guild.channels.cache.find(c => c.id === `${supportbot.LockTicketCategory}`)
-                if(parent) {
-                    interaction.channel.setParent(parent.id)
-                }
-
-                all.forEach(perm => {
-                    interaction.channel.permissionOverwrites.delete(perm.id)
-                
-                })
-                interaction.channel.permissionOverwrites.create(Admin.id, {VIEW_CHANNEL: true})
-
-                interaction.channel.permissionOverwrites.create(interaction.guild.id, {VIEW_CHANNEL: false})
-
-
-                const ticketDeleteButton = new MessageButton()
-                    .setCustomId('ticketclose')
-                    .setLabel('Close')
-                    .setStyle(supportbot.TicketDeleteColour)
-                    .setEmoji(supportbot.TicketDeleteEmoji)
-
-                const row = new MessageActionRow()
-                    .addComponents(ticketDeleteButton)
-                const ArchiveEmbed = new MessageEmbed()
-                    .setTitle("Archived")
-                    .setDescription(`Archived ${interaction.channel.name}`)
-                    .setColor(`${supportbot.SuccessColour}`)
-
-                interaction.channel.send({embeds: [ArchiveEmbed]})
-                interaction.message.edit({components: [row]})
-            }
-        }
-    }
-
-}

events/messageCreate.js

@@ -1,24 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Message Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-module.exports = async (bot, message) => {
-	if(message.author.bot) return;
-  	if(message.channel.type === "dm") return;
-  	if (message.content.indexOf(supportbot.Prefix) !== 0) return;
-
-  	let messageArray = message.content.split(" ");
-  	const args = message.content.slice(supportbot.Prefix.length).trim().split(/ +/g);
-  	const command = args.shift().toLowerCase();
-    
-    console.log(`\u001b[32m`, `[${supportbot.Bot_Name}]`, `\u001b[36m`, `${message.author.tag}`, `\u001b[33m`, `has executed the command`, `\u001b[36m`,`${supportbot.Prefix}${command}`)
-
-  	const cmd = bot.commands.get(command);
-  	if(!cmd) return;
-  	cmd.execute(message, args);
-};

events/messageReactionAdd.js

@@ -1,36 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Message Reaction Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const tickets = yaml.load(fs.readFileSync('./storage/ticketreaction.yml', 'utf8'));
-
-module.exports = async (client, reaction, user) => {
-
-    let message = {
-        guild: reaction.message.channel.guild,
-        author: user,
-        content: "N/A",
-        channel: reaction.message.channel
-    }
-
-    if (supportbot.ReactionTickets) {
-        if (reaction.message.id === tickets.ReactionMessage_ID) {
-            if (reaction.emoji.name == supportbot.ReactionEmoji || reaction.emoji.id == supportbot.ReactionEmoji) {
-                await reaction.users.remove(user.id)
-
-            	try {
-            	    const cmd = client.commands.get(supportbot.NewTicket);
-            	    if(!cmd) return;
-            	    
-            	    cmd.execute(message, message.content);
-            	} catch (error) {
-            	    console.error(error);
-            	}
-            }
-        }
-    }
-};

events/raw.js

@@ -1,26 +0,0 @@
-const Discord = require("discord.js");
-const fs = require("fs");
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-
-
-
-module.exports = async (bot, message, packet) => {
-    if (!['MESSAGE_REACTION_ADD', 'MESSAGE_REACTION_REMOVE'].includes(packet.t)) return;
-
-    const channel = bot.channels.cache.get(packet.d.channel_id);
-    if (channel.messages.has(packet.d.message_id)) return;
-
-    channel.messages.fetch(packet.d.message_id).then(message => {
-        const emoji = packet.d.emoji.id ? `${packet.d.emoji.name}:${packet.d.emoji.id}` : packet.d.emoji.name;
-        const reaction = message.reactions.get(emoji);
-        if (reaction) reaction.users.set(packet.d.user_id, bot.users.get(packet.d.user_id));
-        if (packet.t === 'MESSAGE_REACTION_ADD') {
-            bot.emit('messageReactionAdd', reaction, bot.users.get(packet.d.user_id));
-        }
-        if (packet.t === 'MESSAGE_REACTION_REMOVE') {
-            bot.emit('messageReactionRemove', reaction, bot.users.get(packet.d.user_id));
-        }
-    });
-}

events/ready.js

@@ -1,92 +0,0 @@
-// SupportBot 6.0, Created by Emerald Services
-// Ready Event
-
-const Discord = require("discord.js");
-const fs = require("fs");
-const { MessageActionRow, MessageButton } = require('discord.js');
-
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
-const tickets = yaml.load(fs.readFileSync('./storage/ticketreaction.yml', 'utf8'));
-
-  
-module.exports = async bot => {
-    bot.user.setActivity(supportbot.BotActivity, {
-        type: supportbot.ActivityType, 
-        url: supportbot.StreamingURL  
-    });
-    
-    console.log(`\u001b[32m`, `┏━━━┓╋╋╋╋╋╋╋╋╋╋╋╋╋┏┓┏━━┓╋╋╋┏┓`)
-    console.log(`\u001b[32m`, `┃┏━┓┃╋╋╋╋╋╋╋╋╋╋╋╋┏┛┗┫┏┓┃╋╋┏┛┗┓`)
-    console.log(`\u001b[32m`, `┃┗━━┳┓┏┳━━┳━━┳━━┳┻┓┏┫┗┛┗┳━┻┓┏┛`)
-    console.log(`\u001b[32m`, `┗━━┓┃┃┃┃┏┓┃┏┓┃┏┓┃┏┫┃┃┏━┓┃┏┓┃┃`)
-    console.log(`\u001b[32m`, `┃┗━┛┃┗┛┃┗┛┃┗┛┃┗┛┃┃┃┗┫┗━┛┃┗┛┃┗┓`)
-    console.log(`\u001b[32m`, `┗━━━┻━━┫┏━┫┏━┻━━┻┛┗━┻━━━┻━━┻━┛`)
-    console.log(`\u001b[32m`, `┗╋╋╋╋╋╋╋┃┃╋┃┃`)
-    console.log(`\u001b[32m`, `╋╋╋╋╋╋╋┗┛╋┗┛`)
-    console.log(`    `)
-    console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`)
-    console.log(`    `)
-    console.log(`\u001b[33m`, `${supportbot.Bot_Name} v${supportbot.SupportBot_Version}`, `\u001b[36m`, `Connected to Discord`)
-    console.log(`\u001b[33m`, `Documentation:`, `\u001b[36m`, `https://supportbot.emeraldsrv.dev`)
-    console.log(`\u001b[33m`, `Discord:`, `\u001b[36m`, `https://emeraldsrv.dev/discord`)
-    console.log(`\u001b[33m`, `Hosting:`, `\u001b[36m`, `https://emeraldsrv.dev/hosting`)
-    console.log(`    `)
-    console.log(`\u001b[37m`, `SupportBot proudly created by Emerald Services`)
-    console.log(`    `)
-    console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`)
-    
-
-    
-    if (supportbot.ReactionTickets) {
-        let chan1 = bot.channels.cache.find(channel => channel.name === supportbot.ReactionChannel)
-
-        if (!chan1) {
-            console.log('\u001b[33m', "[WARN] Ticket reaction panel is not setup, You can do so via the configuration file!")
-            return false;
-        }
-
-        chan1.messages.fetch(tickets.ReactionMessage_ID).catch(async r => {
-            let embed = new Discord.MessageEmbed()
-                .setTitle(supportbot.ReactionMessage.replace(/%reaction_emoji%/g, supportbot.ReactionEmoji))
-                .setColor(supportbot.SuccessColour)
-                .setFooter(supportbot.EmbedFooter);
-            
-            if (supportbot.ReactionPanel_Description) {
-                embed.setDescription(supportbot.ReactionDescription)
-            }
-            
-            if (supportbot.ReactionPanel_Thumbnail) {
-                embed.setThumbnail(supportbot.ReactionThumbnail)
-            }
-
-            if (supportbot.ReactionPanel_Image) {
-                embed.setImage(supportbot.ReactionImage)
-            }
-
-            let button = new MessageButton()
-                .setLabel('Open Ticket')
-                .setCustomId('openticket')
-                .setStyle('PRIMARY')
-
-            let row = new MessageActionRow()
-                .addComponents(button)
-
-            
-            await chan1.send({ 
-                embeds: [embed],
-                components: [row]
-            }).then(r => {
-                let data = {
-                    "ReactionMessage_ID": `${r.id}`
-                }
-                let yamlStr = yaml.dump(data);
-                fs.writeFileSync('./storage/ticketreaction.yml', yamlStr, 'utf8');
-                
-            }).catch(e => {
-                console.log("Raw"+e)
-            })
-        })
-    }
-
-};

index.js

@@ -8,105 +8,37 @@
 //           Installed with MIT License
 //
 //           Discord Support: https://emeraldsrv.dev/discord
-
+//           Community Resources: https://emeraldsrv.dev/resources
-// const Discord = require("discord.js");
-const { Client, Intents, Collection } = require("discord.js");
 
 const fs = require("fs");
 
-const bot = new Client({
+const yaml = require("js-yaml");
-    intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MESSAGES]
+const supportbot = yaml.load(
+  fs.readFileSync("./Configs/supportbot.yml", "utf8")
+);
+
+const Client = require("./Structures/Client.js");
+const client = new Client({
+  intents: ['Guilds', 'GuildMembers', 'GuildMessages']
 });
 
-const { REST } = require('@discordjs/rest');
+client.start(supportbot.General.Token);
 
-bot.commands = new Collection();
 
-const yaml = require('js-yaml');
-const supportbot = yaml.load(fs.readFileSync('./supportbot-config.yml', 'utf8'));
 
-const { promisify } = require("util");
-const readdir = promisify(require("fs").readdir);
 
-String.prototype.toProperCase = function () {
-    return this.replace(
-        /([^\W_]+[^\s-]*) */g,
-        (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
-    );
-};
 
-const init = async () => {
-    const evtFiles = await readdir("./events/");
 
-        console.info(`\u001b[36m`, `➢ SupportBot Events`);
-        console.info(`	`);
 
-    evtFiles.forEach((file, i) => {
-        const eventName = file.split(".")[0];
-        const event = require(`./events/${file}`);
-        console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `#${i + 1} Event Loaded: ${eventName.toProperCase()} `);
 
-        bot.on(eventName, event.bind(null, bot));
-        delete require.cache[require.resolve(`./events/${file}`)];
-    });
 
-    console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `Successfully loaded ${evtFiles.length} events.`);
-    console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`)
-    console.log(`	`)
-};
 
-init();
 
-fs.readdir("./commands/", async (err, files) => {
 
-        console.info(`\u001b[36m`, `➢ SupportBot Commands`);
-        console.info(`	`);
 
-    if (err) console.info(err, "error");
 
-    let jsfiles = files.filter((f) => f.split(".").pop() === "js");
 
-    if (jsfiles.length <= 0) {
-        console.log(`[${supportbot.Bot_Name}]: No commands found. Try to Re-download the resource`);
-        return;
-    }
 
-    jsfiles.forEach((f, i) => {
-        let props = require(`./commands/${f}`);
 
-        console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `#${i + 1} Command Loaded: ${props.name.toProperCase()}`);
-        bot.commands.set(props.name, props);
-    });
 
-    console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `Loaded ${jsfiles.length} commands!`);
-    console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`)
-    console.log(`	`)
-});
 
-fs.readdir("./addons/", (err, files) => {
-    
-        console.info(`\u001b[36m`, `➢ SupportBot Addons`);
-        console.info(`	`);
-    
-    if (err) console.info(err, "error");
-    
-    let jsfiles = files.filter((f) => f.split(".").pop() === "js");
-
-    if (jsfiles.length <= 0) {
-        console.log(`[${supportbot.Bot_Name}]: No addons found. You can download addons from https://emeraldsrv.dev`);
-        return;
-    }
-  
-    jsfiles.forEach((f, i) => {
-        let props = require(`./addons/${f}`);
-        
-        console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `#${i + 1} Addon Loaded: ${props.name.toProperCase()}`);
-        bot.commands.set(props.name, props);
-    });
-
-    console.info(`\u001b[32m`, `[${supportbot.Bot_Name}]:`, `\u001b[36m`, `Loaded ${jsfiles.length} addons!`);
-    console.log(`\u001b[31m`, `――――――――――――――――――――――――――――――――――――――――――――`)
-    console.log(`	`)
-});
-
-bot.login(supportbot.Token);

lang/README.md

@@ -1,8 +0,0 @@
-SupportBot Language Compatibility
-
-In order to switch languages simple remove the current existig configuration file and replace it with one of the files here renamnig the file to "supportbot-config.yml" from (for example) "supportbot-config_es.yml" to home directory of SupportBot.
-
--> Delete the existing supportbot-config.yml file
--> Download the new file for whatever language
--> Upload the file to SupportBot and rename it to supportbot-config.yml
--> Job Done, restart the bot :wink:

lang/SupportBot_ENG.yml

@@ -1,310 +0,0 @@
-#      ___                            _    ___        _   
-#     / __> _ _  ___  ___  ___  _ _ _| |_ | . > ___ _| |_ 
-#     \__ \| | || . \| . \/ . \| '_> | |  | . \/ . \ | |  
-#     <___/`___||  _/|  _/\___/|_|   |_|  |___/\___/ |_|  
-#                |_|  |_|                                  
-#
-#           SupportBot created by Emerald Services
-#           Installed with MIT License
-#
-#           Discord Support: https://emeraldsrv.dev/discord
-
-SupportBot_Version: "7.1 pre-1"
-
-# -------------------------
-#   General Configuration
-# -------------------------
-
-Token: "BOT_TOKEN_HERE"
-Prefix: "!!"
-Bot_Name: "SupportBot"
-
-DeleteMessages: true
-# Should the bot delete command messages after executed?
-
-# -------------------------
-#  Activity Configuration
-# -------------------------
-
-BotActivity: "-help | SupportBot"
-
-StreamingURL: "https://www.twitch.tv/YOUR_TWITCH_NAME"
-# Set The ActivityType to "STREAMING" for a streaming status!
-
-ActivityType: "PLAYING"
-# Activity status can either be PLAYING, WATCHING, LISTENING or STREAMING.
-
-# -------------------------
-#  Embed Configuration
-# -------------------------
-
-EmbedColour: "#f74343"
-EmbedFooter: "SupportBot | The #1 Supportive Discord Bot"
-
-ErrorColour: "#d12519"
-SuccessColour: "#04b545"
-WarningColour: "#fca117" 
-
-# -------------------------
-#  Help Configuration
-# -------------------------
-
-HelpMenu: true # Do not change!
-SendHelpPage: "channel" # Set to channel or dm
-
-# -------------------------
-#  Role Configuration
-# -------------------------
-
-AutoRole: true
-AutoRole_Role: "Member"
-LockdownRole: "@everyone"
-
-Staff: "Staff"
-Admin: "Admin"
-TicketBlackListRole: "Blacklisted"
-
-# -------------------------
-#  Tickets Configuration
-# -------------------------
-
-# --- General Config ---
-#     --- Start ---
-
-TicketCategory: "▬▬ TICKETS ▬▬"
-TicketChannel: "ticket"
-
-TicketLog: "ticket-logs"
-TranscriptLog: "transcripts"
-
-TranscriptTitle: "Ticket Transcript"
-TicketBlackListMessage: "You are not allowed to open a ticket"
-
-TicketSubject: "description"
-# "description" will displays the ticket reason within the channel description
-# "embed" will displays the ticket reason within the ticket embed
-
-AllowTicketMentions: true
-# Set to true to allow the ticket to mention the author and the support team.
-# Set to false to dis-allow mentions within tickets.
-
-# --- Panel Config ---
-#   --- Start ---
-
-ReactionChannel: "create-ticket"
-ReactionEmoji: "📩" 
-# For cusomt emojis: <:emoji_name:EMOJI_ID>
-
-ReactionTickets: true
-ReactionMessage: "React with %reaction_emoji% to create a Support Ticket!"
-
-ReactionPanel_Description: true
-ReactionDescription: "Create a support ticket to contact a member of staff."
-
-ReactionPanel_Thumbnail: true
-ReactionThumbnail: "https://hotemoji.com/images/dl/5/ticket-emoji-by-twitter.png"
-
-ReactionPanel_Image: true
-ReactionImage: "https://wallpapercave.com/wp/wp4462546.jpg"
-
-# --- Creation Config ---
-#      --- Start ---
-
-# Available Placeholders:
-
-# %ticketusername% - User who created the ticket.
-# <@%ticketauthor%> - Tags the user who created the ticket.
-# <#%ticketid%> - Mentions the ticket channel.
-
-
-Ticket_Title: "Server Support | %ticketusername%"
-TicketMessage: "Hello <@%ticketauthor%>, Thank you for creating a support ticket\nPlease wait patiently whilst a member of our team reaches out to you."
-
-Ticket_Thumbnail: "https://images.emojiterra.com/google/android-pie/512px/1f39f.png"
-NoTicketSubject: "No Reason Provided!"
-
-TicketCreatedAlert: ":ticket: Your support ticket has been created: <#%ticketid%>"
-
-AddedUser: "👍 <@%user%> has been added to this ticket"
-RemovedUser: "👍 <@%user%> has been removed from this ticket"
-
-
-TicketLockReaction: "🔒"
-TicketDeleteReaction: "⛔"
-
-TranscriptSavedMessage: "📝 **Transcript Saved!**"
-TicketLockMessage: "❌ **Ticket Locked!**"
-TicketDeleteMessage: "⚠ **Ticket Deleting!**" # Tickets deleting after 5 seconds by default.
-TicketDeleteTime: 5000 # Time must be set in miliseconds.
-
-# --- Closing Config ---
-#    --- Start ---
-
-ClosingTicket: ":warning: You have requested to close your support ticket."
-ClosingConfirmation_Word: "confirm"
-CloseConfirmation: true
-
-# --- Departments Config ---
-#     --- Start ---
-
-TicketDepartments: true
-
-AllowStaff: true
-# If set to true users with the "Staff" role will not be able to view tickets 
-# without a valid department role set below.
-
-# Set to false to allow "Staff" to see tickets whether its a department for them or not.
-
-DepartmentEmoji_1: "🙋"
-DepartmentEmoji_2: "💸"
-DepartmentEmoji_3: "📗"
-# Ticket emojis, the emojis are what users will need to react with inorder to proceed furthur if departments are enabled.
-
-DepartmentTitle_1: "Support"
-DepartmentTitle_2: "Billing"
-DepartmentTitle_3: "Other"
-# Ticket department title, This is the title for a ticket department to help users know what is available.
-
-DepartmentRole_1: "Support"
-DepartmentRole_2: "Admin"
-DepartmentRole_3: "Support"
-# Ticket roles are the roles that will be able to gain access to tickets depending on what department has been choosen. 
-
-# --------------------------------
-#  System Messages Configuration
-# --------------------------------
-
-# Available Placeholders:
-# %guildname% - This displays the name of the discord server.
-
-SystemMessages: true
-SystemMessage_EmbedFooter: false
-
-SystemMessage_Channel: "system-messages"
-SystemMessage_Type: "embed"
-# There are 2 types of how you can send system messages, 'normal' or 'embed'
-
-SystemMessage_Icon: "USER"
-# USER - This will display the user's icon of who joins.
-# BOT - This will display the bot's icon when a someone joins.
-
-Welcome_Title: "User Joined!"
-WelcomeMessage: "Hello %member%, Welcome to %guildname%!"
-# %member% define the user who joined and %guildnamne% defines the server name.
-
-Leave_Title: "User Left!"
-LeaveMessage: "Goodbye %member%, Thank you for visting %guildname%!"
-# %member% define the user who left and %guildnamne% defines the server name.
-
-# -------------------------
-#  Links Configuration
-# -------------------------
-
-LinksTitle: "Server Links"
-
-LINKS:
-  "Website": "https://www.example.com"
-  "Store": "https://store.example.com"
-  "Discord": "https://discord.gg/example"
-# "Twitter": "https://twitter.com/example"
-# "Add More": "Just follow this format!"
-
-# --------------------------
-#  Suggestion Configuration
-# --------------------------
-
-SuggestionChannel: "suggestions"
-SuggestionTitle: "Suggestion"
-
-SuggestionStarter: "What would you like to suggest?"
-SuggestReact_1: 👍
-SuggestReact_2: 👎
-
-# ----------------------------
-#  Announcement Configuration
-# ----------------------------
-
-AnnouncementChannel: "announcements"
-AnnouncementTitle: "Servername Announcement"
-AnnouncementIcon: "https://i.imgur.com/HbkZyB7.png"
-
-AnnouncementStarter: "What would you like to announce?"
-
-# --------------------------
-#  Moderation Configuration
-# --------------------------
-
-BanTitle: "User Banned!"
-DaysBannedFor: 7
-BanLogColour: "#D911B4"
-
-KickTitle: "User Kicked!"
-KickLogColour: "#D9B111"
-
-ModThumbnail: "https://i.imgur.com/l6P3DF6.png"
-ModLogChannel: "mod-logs"
-
-PruneLogTitle: "Bulk Delete"
-PruneThumbnail: "https://i.imgur.com/OAgW2vR.png"
-PruneColour: "#1BA30C"
-
-BlacklistTitle: "Blacklisted User"
-BlacklistColour: "#000000"
-
-# --------------------------
-#  Command Configuration
-# --------------------------
-
-# --- User Commands ---
-
-HelpCommand: "help"
-LinksCommand: "links"
-PingCommand: "ping"
-SuggestCommand: "suggest"
-
-# --- Ticket Commands ---
-
-NewTicket: "ticket"
-CloseTicket: "close"
-AddUser: "add"
-RemoveUser: "remove"
-RenameTicket: "rename"
-
-# --- Staff/Admin Commands ---
-
-BotSay: "say"
-PurgeMessage: "purge"
-
-AnnounceCommand: "announce"
-BanUser: "ban"
-KickUser: "kick"
-BlacklistUser: "blacklist"
-
-# --------------------------
-#  Messages Configuration
-# --------------------------
-
-# --- Command Messages ---
-
-NewTicketDesc: "Create a new support ticket"
-AnnounceDesc: "Create a server announcement"
-CloseTicketDesc: "Close your support ticket"
-LinksDesc: "View some important links"
-PingDesc: "Get the bot's latency"
-HelpDesc: "Get a list of all the commands"
-RemoveUserDesc: "Remove a user from a support ticket"
-AddUserDesc: "Add a user to a support ticket"
-SuggestionDesc: "Create a server suggestion"
-BotSayDesc: "Say something with the bot"
-BanDesc: "Ban a member from this server."
-KickDesc: "Kick a member from this server."
-PurgeDesc: "Purge messages from the chat."
-BlacklistDesc: "Decline a member to open a ticket"
-
-# Error / Warning Messages
-
-IncorrectPerms: ":x: **Err!** You do not have the correct permissions to use this command."
-InvalidChannel: ":x: **Err!** Channel not found. Please create it!"
-UserNotFound: ":x: **Err!** This user doesn't exist, Are they in this server?"
-NoValidTicket: ":warning: You cannot execute this command here. This command is used when closing a ticket."
-TicketExists: ":warning: This ticket cannot be opened, It already exists!"

node_modules/.bin/acorn

@@ -1 +0,0 @@
-../acorn/bin/acorn

node_modules/.bin/escodegen

@@ -1 +0,0 @@
-../escodegen/bin/escodegen.js

node_modules/.bin/esgenerate

@@ -1 +0,0 @@
-../escodegen/bin/esgenerate.js

node_modules/.bin/esparse

@@ -1 +0,0 @@
-../esprima/bin/esparse.js

node_modules/.bin/esvalidate

@@ -1 +0,0 @@
-../esprima/bin/esvalidate.js

node_modules/.bin/js-yaml

@@ -1 +0,0 @@
-../js-yaml/bin/js-yaml.js

node_modules/.package-lock.json

@@ -1,889 +0,0 @@
-{
-  "name": "supportbot",
-  "version": "7.1",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "node_modules/@discordjs/builders": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-0.5.0.tgz",
-      "integrity": "sha512-HP5y4Rqw68o61Qv4qM5tVmDbWi4mdTFftqIOGRo33SNPpLJ1Ga3KEIR2ibKofkmsoQhEpLmopD1AZDs3cKpHuw==",
-      "dependencies": {
-        "@sindresorhus/is": "^4.0.1",
-        "discord-api-types": "^0.22.0",
-        "ow": "^0.27.0",
-        "ts-mixer": "^6.0.0",
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": ">=14.0.0",
-        "npm": ">=7.0.0"
-      }
-    },
-    "node_modules/@discordjs/builders/node_modules/discord-api-types": {
-      "version": "0.22.0",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
-      "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg==",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@discordjs/collection": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.2.1.tgz",
-      "integrity": "sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog==",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@discordjs/form-data": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/@discordjs/form-data/-/form-data-3.0.1.tgz",
-      "integrity": "sha512-ZfFsbgEXW71Rw/6EtBdrP5VxBJy4dthyC0tpQKGKmYFImlmmrykO14Za+BiIVduwjte0jXEBlhSKf0MWbFp9Eg==",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/@discordjs/rest": {
-      "version": "0.1.0-canary.0",
-      "resolved": "https://registry.npmjs.org/@discordjs/rest/-/rest-0.1.0-canary.0.tgz",
-      "integrity": "sha512-d+s//ISYVV+e0w/926wMEeO7vju+Pn11x1JM4tcmVMCHSDgpi6pnFCNAXF1TEdnDcy7xf9tq5cf2pQkb/7ySTQ==",
-      "dependencies": {
-        "@discordjs/collection": "^0.1.6",
-        "@sapphire/async-queue": "^1.1.4",
-        "@sapphire/snowflake": "^1.3.5",
-        "abort-controller": "^3.0.0",
-        "discord-api-types": "^0.18.1",
-        "form-data": "^4.0.0",
-        "node-fetch": "^2.6.1",
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": ">=16.0.0"
-      }
-    },
-    "node_modules/@discordjs/rest/node_modules/@discordjs/collection": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.1.6.tgz",
-      "integrity": "sha512-utRNxnd9kSS2qhyivo9lMlt5qgAUasH2gb7BEOn6p0efFh24gjGomHzWKMAPn2hEReOPQZCJaRKoURwRotKucQ=="
-    },
-    "node_modules/@discordjs/rest/node_modules/discord-api-types": {
-      "version": "0.18.1",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.18.1.tgz",
-      "integrity": "sha512-hNC38R9ZF4uaujaZQtQfm5CdQO58uhdkoHQAVvMfIL0LgOSZeW575W8H6upngQOuoxWd8tiRII3LLJm9zuQKYg==",
-      "deprecated": "No longer supported. Install the latest release (0.20.2)",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@discordjs/rest/node_modules/form-data": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
-      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/@sapphire/async-queue": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.1.4.tgz",
-      "integrity": "sha512-fFrlF/uWpGOX5djw5Mu2Hnnrunao75WGey0sP0J3jnhmrJ5TAPzHYOmytD5iN/+pMxS+f+u/gezqHa9tPhRHEA==",
-      "engines": {
-        "node": ">=14",
-        "npm": ">=6"
-      }
-    },
-    "node_modules/@sapphire/snowflake": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/@sapphire/snowflake/-/snowflake-1.3.6.tgz",
-      "integrity": "sha512-QnzuLp+p9D7agynVub/zqlDVriDza9y3STArBhNiNBUgIX8+GL5FpQxstRfw1jDr5jkZUjcuKYAHxjIuXKdJAg==",
-      "deprecated": "This version has been automatically deprecated by @favware/npm-deprecate. Please use a newer version.",
-      "engines": {
-        "node": ">=12",
-        "npm": ">=6"
-      }
-    },
-    "node_modules/@sindresorhus/is": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.0.1.tgz",
-      "integrity": "sha512-Qm9hBEBu18wt1PO2flE7LPb30BHMQt1eQgbV76YntdNk73XZGpn3izvGTYxbGgzXKgbCjiia0uxTd3aTNQrY/g==",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sindresorhus/is?sponsor=1"
-      }
-    },
-    "node_modules/@tootallnate/once": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz",
-      "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==",
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/@types/node": {
-      "version": "16.7.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.7.1.tgz",
-      "integrity": "sha512-ncRdc45SoYJ2H4eWU9ReDfp3vtFqDYhjOsKlFFUDEn8V1Bgr2RjYal8YT5byfadWIRluhPFU6JiDOl0H6Sl87A=="
-    },
-    "node_modules/@types/ws": {
-      "version": "7.4.7",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-7.4.7.tgz",
-      "integrity": "sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
-    "node_modules/abab": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.5.tgz",
-      "integrity": "sha512-9IK9EadsbHo6jLWIpxpR6pL0sazTXV6+SQv25ZB+F7Bj9mJNaOc4nCRabwd5M/JwmUa8idz6Eci6eKfJryPs6Q=="
-    },
-    "node_modules/abort-controller": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
-      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
-      "dependencies": {
-        "event-target-shim": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6.5"
-      }
-    },
-    "node_modules/acorn": {
-      "version": "8.4.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.4.1.tgz",
-      "integrity": "sha512-asabaBSkEKosYKMITunzX177CXxQ4Q8BSSzMTKD+FefUhipQC70gfW5SiUDhYQ3vk8G+81HqQk7Fv9OXwwn9KA==",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-globals": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz",
-      "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==",
-      "dependencies": {
-        "acorn": "^7.1.1",
-        "acorn-walk": "^7.1.1"
-      }
-    },
-    "node_modules/acorn-globals/node_modules/acorn": {
-      "version": "7.4.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
-      "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-walk": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz",
-      "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/agent-base": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
-      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
-      "dependencies": {
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 6.0.0"
-      }
-    },
-    "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
-    },
-    "node_modules/asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
-    },
-    "node_modules/browser-process-hrtime": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz",
-      "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow=="
-    },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/combined-stream": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "dependencies": {
-        "delayed-stream": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/cssom": {
-      "version": "0.4.4",
-      "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz",
-      "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw=="
-    },
-    "node_modules/cssstyle": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz",
-      "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==",
-      "dependencies": {
-        "cssom": "~0.3.6"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cssstyle/node_modules/cssom": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz",
-      "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg=="
-    },
-    "node_modules/data-urls": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz",
-      "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==",
-      "dependencies": {
-        "abab": "^2.0.3",
-        "whatwg-mimetype": "^2.3.0",
-        "whatwg-url": "^8.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
-      "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
-      "dependencies": {
-        "ms": "2.1.2"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/decimal.js": {
-      "version": "10.3.1",
-      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.3.1.tgz",
-      "integrity": "sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ=="
-    },
-    "node_modules/deep-is": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
-      "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ="
-    },
-    "node_modules/delayed-stream": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
-      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/discord-api-types": {
-      "version": "0.23.1",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.23.1.tgz",
-      "integrity": "sha512-igWmn+45mzXRWNEPU25I/pr8MwxHb767wAr51oy3VRLRcTlp5ADBbrBR0lq3SA1Rfw3MtM4TQu1xo3kxscfVdQ==",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/discord.js": {
-      "version": "13.1.0",
-      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-13.1.0.tgz",
-      "integrity": "sha512-gxO4CXKdHpqA+WKG+f5RNnd3srTDj5uFJHgOathksDE90YNq/Qijkd2WlMgTTMS6AJoEnHxI7G9eDQHCuZ+xDA==",
-      "dependencies": {
-        "@discordjs/builders": "^0.5.0",
-        "@discordjs/collection": "^0.2.1",
-        "@discordjs/form-data": "^3.0.1",
-        "@sapphire/async-queue": "^1.1.4",
-        "@types/ws": "^7.4.7",
-        "discord-api-types": "^0.22.0",
-        "node-fetch": "^2.6.1",
-        "ws": "^7.5.1"
-      },
-      "engines": {
-        "node": ">=16.6.0",
-        "npm": ">=7.0.0"
-      }
-    },
-    "node_modules/discord.js/node_modules/discord-api-types": {
-      "version": "0.22.0",
-      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
-      "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg==",
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/domexception": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz",
-      "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==",
-      "dependencies": {
-        "webidl-conversions": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/domexception/node_modules/webidl-conversions": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz",
-      "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/dot-prop": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
-      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
-      "dependencies": {
-        "is-obj": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/escodegen": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.0.0.tgz",
-      "integrity": "sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==",
-      "dependencies": {
-        "esprima": "^4.0.1",
-        "estraverse": "^5.2.0",
-        "esutils": "^2.0.2",
-        "optionator": "^0.8.1"
-      },
-      "bin": {
-        "escodegen": "bin/escodegen.js",
-        "esgenerate": "bin/esgenerate.js"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "optionalDependencies": {
-        "source-map": "~0.6.1"
-      }
-    },
-    "node_modules/esprima": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
-      "bin": {
-        "esparse": "bin/esparse.js",
-        "esvalidate": "bin/esvalidate.js"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/estraverse": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz",
-      "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/esutils": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/event-target-shim": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
-      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/fast-levenshtein": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc="
-    },
-    "node_modules/form-data": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.1.tgz",
-      "integrity": "sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/html-encoding-sniffer": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz",
-      "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==",
-      "dependencies": {
-        "whatwg-encoding": "^1.0.5"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/http-proxy-agent": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz",
-      "integrity": "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==",
-      "dependencies": {
-        "@tootallnate/once": "1",
-        "agent-base": "6",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/https-proxy-agent": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.0.tgz",
-      "integrity": "sha512-EkYm5BcKUGiduxzSt3Eppko+PiNWNEpa4ySk9vTC6wDsQJW9rHSa+UhGNJoRYp7bz6Ht1eaRIa6QaJqO5rCFbA==",
-      "dependencies": {
-        "agent-base": "6",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-obj": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
-      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-potential-custom-element-name": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
-      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ=="
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/jsdom": {
-      "version": "16.7.0",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.7.0.tgz",
-      "integrity": "sha512-u9Smc2G1USStM+s/x1ru5Sxrl6mPYCbByG1U/hUmqaVsm4tbNyS7CicOSRyuGQYZhTu0h84qkZZQ/I+dzizSVw==",
-      "dependencies": {
-        "abab": "^2.0.5",
-        "acorn": "^8.2.4",
-        "acorn-globals": "^6.0.0",
-        "cssom": "^0.4.4",
-        "cssstyle": "^2.3.0",
-        "data-urls": "^2.0.0",
-        "decimal.js": "^10.2.1",
-        "domexception": "^2.0.1",
-        "escodegen": "^2.0.0",
-        "form-data": "^3.0.0",
-        "html-encoding-sniffer": "^2.0.1",
-        "http-proxy-agent": "^4.0.1",
-        "https-proxy-agent": "^5.0.0",
-        "is-potential-custom-element-name": "^1.0.1",
-        "nwsapi": "^2.2.0",
-        "parse5": "6.0.1",
-        "saxes": "^5.0.1",
-        "symbol-tree": "^3.2.4",
-        "tough-cookie": "^4.0.0",
-        "w3c-hr-time": "^1.0.2",
-        "w3c-xmlserializer": "^2.0.0",
-        "webidl-conversions": "^6.1.0",
-        "whatwg-encoding": "^1.0.5",
-        "whatwg-mimetype": "^2.3.0",
-        "whatwg-url": "^8.5.0",
-        "ws": "^7.4.6",
-        "xml-name-validator": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "peerDependencies": {
-        "canvas": "^2.5.0"
-      },
-      "peerDependenciesMeta": {
-        "canvas": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/levn": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
-      "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=",
-      "dependencies": {
-        "prelude-ls": "~1.1.2",
-        "type-check": "~0.3.2"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-    },
-    "node_modules/lodash.isequal": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
-      "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
-    },
-    "node_modules/mime-db": {
-      "version": "1.48.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.48.0.tgz",
-      "integrity": "sha512-FM3QwxV+TnZYQ2aRqhlKBMHxk10lTbMt3bBkMAp54ddrNeVSfcQYOOKuGuy3Ddrm38I04If834fOUSq1yzslJQ==",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "2.1.31",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.31.tgz",
-      "integrity": "sha512-XGZnNzm3QvgKxa8dpzyhFTHmpP3l5YNusmne07VUOXxou9CqUqYa/HBy124RqtVh/O2pECas/MOcsDgpilPOPg==",
-      "dependencies": {
-        "mime-db": "1.48.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
-    },
-    "node_modules/node-fetch": {
-      "version": "2.6.1",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.1.tgz",
-      "integrity": "sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==",
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      }
-    },
-    "node_modules/nwsapi": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.0.tgz",
-      "integrity": "sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ=="
-    },
-    "node_modules/optionator": {
-      "version": "0.8.3",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
-      "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==",
-      "dependencies": {
-        "deep-is": "~0.1.3",
-        "fast-levenshtein": "~2.0.6",
-        "levn": "~0.3.0",
-        "prelude-ls": "~1.1.2",
-        "type-check": "~0.3.2",
-        "word-wrap": "~1.2.3"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/ow": {
-      "version": "0.27.0",
-      "resolved": "https://registry.npmjs.org/ow/-/ow-0.27.0.tgz",
-      "integrity": "sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==",
-      "dependencies": {
-        "@sindresorhus/is": "^4.0.1",
-        "callsites": "^3.1.0",
-        "dot-prop": "^6.0.1",
-        "lodash.isequal": "^4.5.0",
-        "type-fest": "^1.2.1",
-        "vali-date": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/parse5": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
-      "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="
-    },
-    "node_modules/prelude-ls": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
-      "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=",
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/psl": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
-      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ=="
-    },
-    "node_modules/punycode": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
-      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
-    },
-    "node_modules/saxes": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz",
-      "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==",
-      "dependencies": {
-        "xmlchars": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-      "optional": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/symbol-tree": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
-      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw=="
-    },
-    "node_modules/tough-cookie": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.0.0.tgz",
-      "integrity": "sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==",
-      "dependencies": {
-        "psl": "^1.1.33",
-        "punycode": "^2.1.1",
-        "universalify": "^0.1.2"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.1.0.tgz",
-      "integrity": "sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw==",
-      "dependencies": {
-        "punycode": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ts-mixer": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.0.tgz",
-      "integrity": "sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ=="
-    },
-    "node_modules/tslib": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
-      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
-    },
-    "node_modules/type-check": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
-      "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=",
-      "dependencies": {
-        "prelude-ls": "~1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.8.0"
-      }
-    },
-    "node_modules/type-fest": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
-      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/universalify": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
-      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
-      "engines": {
-        "node": ">= 4.0.0"
-      }
-    },
-    "node_modules/vali-date": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
-      "integrity": "sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY=",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/w3c-hr-time": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz",
-      "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==",
-      "dependencies": {
-        "browser-process-hrtime": "^1.0.0"
-      }
-    },
-    "node_modules/w3c-xmlserializer": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz",
-      "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==",
-      "dependencies": {
-        "xml-name-validator": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz",
-      "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==",
-      "engines": {
-        "node": ">=10.4"
-      }
-    },
-    "node_modules/whatwg-encoding": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz",
-      "integrity": "sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw==",
-      "dependencies": {
-        "iconv-lite": "0.4.24"
-      }
-    },
-    "node_modules/whatwg-mimetype": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz",
-      "integrity": "sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g=="
-    },
-    "node_modules/whatwg-url": {
-      "version": "8.7.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.7.0.tgz",
-      "integrity": "sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg==",
-      "dependencies": {
-        "lodash": "^4.7.0",
-        "tr46": "^2.1.0",
-        "webidl-conversions": "^6.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/word-wrap": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
-      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/ws": {
-      "version": "7.5.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.1.tgz",
-      "integrity": "sha512-2c6faOUH/nhoQN6abwMloF7Iyl0ZS2E9HGtsiLrWn0zOOMWlhtDmdf/uihDt6jnuCxgtwGBNy6Onsoy2s2O2Ow==",
-      "engines": {
-        "node": ">=8.3.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": "^5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/xml-name-validator": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz",
-      "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw=="
-    },
-    "node_modules/xmlchars": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
-      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw=="
-    }
-  }
-}

node_modules/@discordjs/builders/LICENSE

@@ -1,190 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   Copyright 2021 Vlad Frangu
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

node_modules/@discordjs/builders/README.md

@@ -1,33 +0,0 @@
-<div align="center">
-	<br />
-	<p>
-		<a href="https://discord.js.org"><img src="https://discord.js.org/static/logo.svg" width="546" alt="discord.js" /></a>
-	</p>
-	<br />
-		<p>
-		<a href="https://discord.gg/djs"><img src="https://img.shields.io/discord/222078108977594368?color=5865F2&logo=discord&logoColor=white" alt="Discord server" /></a>
-		<a href="https://github.com/discordjs/builders/actions"><img src="https://github.com/discordjs/builders/workflows/Tests/badge.svg" alt="Test status" /></a>
-		<a href="https://github.com/discordjs/builders/actions"><img src="https://github.com/discordjs/builders/workflows/Lint/badge.svg" alt="Lint status" /></a>
-		<a href="https://codecov.io/gh/discordjs/builders"><img src="https://codecov.io/gh/discordjs/builders/branch/main/graph/badge.svg" alt="Code coverage" /></a>
-	</p>
-</div>
-
-## Installation
-
-Install with [npm](https://www.npmjs.com/) / [yarn](https://yarnpkg.com) / [pnpm](https://pnpm.js.org/):
-
-```sh
-npm install @discordjs/builders
-yarn add @discordjs/builders
-pnpm add @discordjs/builders
-```
-
-## Contribution
-
-See [Contributing Guide](https://github.com/discordjs/builders/blob/main/.github/CONTRIBUTING.md).
-
-## Examples
-
-Here are some examples for the builders and utilities you can find in this package:
-
-- [Slash Command Builders](./docs/examples/Slash%20Command%20Builders.md)

node_modules/@discordjs/builders/dist/index.d.ts

@@ -1,12 +0,0 @@
-export * from './messages/formatters';
-export * as SlashCommandAssertions from './interactions/slashCommands/Assertions';
-export * from './interactions/slashCommands/SlashCommandBuilder';
-export * from './interactions/slashCommands/SlashCommandSubcommands';
-export * from './interactions/slashCommands/options/boolean';
-export * from './interactions/slashCommands/options/channel';
-export * from './interactions/slashCommands/options/integer';
-export * from './interactions/slashCommands/options/mentionable';
-export * from './interactions/slashCommands/options/role';
-export * from './interactions/slashCommands/options/string';
-export * from './interactions/slashCommands/options/user';
-//# sourceMappingURL=index.d.ts.map

node_modules/@discordjs/builders/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"/","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AAEtC,OAAO,KAAK,sBAAsB,MAAM,yCAAyC,CAAC;AAClF,cAAc,kDAAkD,CAAC;AACjE,cAAc,sDAAsD,CAAC;AACrE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,kDAAkD,CAAC;AACjE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,2CAA2C,CAAC"}

node_modules/@discordjs/builders/dist/index.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlashCommandAssertions = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./messages/formatters"), exports);
-exports.SlashCommandAssertions = tslib_1.__importStar(require("./interactions/slashCommands/Assertions"));
-tslib_1.__exportStar(require("./interactions/slashCommands/SlashCommandBuilder"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/SlashCommandSubcommands"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/boolean"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/channel"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/integer"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/mentionable"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/role"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/string"), exports);
-tslib_1.__exportStar(require("./interactions/slashCommands/options/user"), exports);
-//# sourceMappingURL=index.js.map

node_modules/@discordjs/builders/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"/","sources":["index.ts"],"names":[],"mappings":";;;;AAAA,gEAAsC;AAEtC,0GAAkF;AAClF,2FAAiE;AACjE,+FAAqE;AACrE,uFAA6D;AAC7D,uFAA6D;AAC7D,uFAA6D;AAC7D,2FAAiE;AACjE,oFAA0D;AAC1D,sFAA4D;AAC5D,oFAA0D","sourcesContent":["export * from './messages/formatters';\n\nexport * as SlashCommandAssertions from './interactions/slashCommands/Assertions';\nexport * from './interactions/slashCommands/SlashCommandBuilder';\nexport * from './interactions/slashCommands/SlashCommandSubcommands';\nexport * from './interactions/slashCommands/options/boolean';\nexport * from './interactions/slashCommands/options/channel';\nexport * from './interactions/slashCommands/options/integer';\nexport * from './interactions/slashCommands/options/mentionable';\nexport * from './interactions/slashCommands/options/role';\nexport * from './interactions/slashCommands/options/string';\nexport * from './interactions/slashCommands/options/user';\n"]}

node_modules/@discordjs/builders/dist/index.mjs

@@ -1,33 +0,0 @@
-import mod from "./index.js";
-
-export default mod;
-export const Faces = mod.Faces;
-export const SlashCommandAssertions = mod.SlashCommandAssertions;
-export const SlashCommandBooleanOption = mod.SlashCommandBooleanOption;
-export const SlashCommandBuilder = mod.SlashCommandBuilder;
-export const SlashCommandChannelOption = mod.SlashCommandChannelOption;
-export const SlashCommandIntegerOption = mod.SlashCommandIntegerOption;
-export const SlashCommandMentionableOption = mod.SlashCommandMentionableOption;
-export const SlashCommandRoleOption = mod.SlashCommandRoleOption;
-export const SlashCommandStringOption = mod.SlashCommandStringOption;
-export const SlashCommandSubcommandBuilder = mod.SlashCommandSubcommandBuilder;
-export const SlashCommandSubcommandGroupBuilder = mod.SlashCommandSubcommandGroupBuilder;
-export const SlashCommandUserOption = mod.SlashCommandUserOption;
-export const TimestampStyles = mod.TimestampStyles;
-export const blockQuote = mod.blockQuote;
-export const bold = mod.bold;
-export const channelMention = mod.channelMention;
-export const codeBlock = mod.codeBlock;
-export const formatEmoji = mod.formatEmoji;
-export const hideLinkEmbed = mod.hideLinkEmbed;
-export const hyperlink = mod.hyperlink;
-export const inlineCode = mod.inlineCode;
-export const italic = mod.italic;
-export const memberNicknameMention = mod.memberNicknameMention;
-export const quote = mod.quote;
-export const roleMention = mod.roleMention;
-export const spoiler = mod.spoiler;
-export const strikethrough = mod.strikethrough;
-export const time = mod.time;
-export const underscore = mod.underscore;
-export const userMention = mod.userMention;

node_modules/@discordjs/builders/dist/interactions/slashCommands/Assertions.d.ts

@@ -1,11 +0,0 @@
-import type { APIApplicationCommandOptionChoice } from 'discord-api-types/v9';
-import type { SlashCommandOptionBase } from './mixins/CommandOptionBase';
-import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
-import type { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
-export declare function validateRequiredParameters(name: string, description: string, options: ToAPIApplicationCommandOptions[]): void;
-export declare function validateName(name: unknown): asserts name is string;
-export declare function validateDescription(description: unknown): asserts description is string;
-export declare function validateMaxOptionsLength(options: unknown): asserts options is ToAPIApplicationCommandOptions[];
-export declare function validateMaxChoicesLength(choices: APIApplicationCommandOptionChoice[]): void;
-export declare function assertReturnOfBuilder<T extends SlashCommandOptionBase | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder>(input: unknown, ExpectedInstanceOf: new () => T): asserts input is T;
-//# sourceMappingURL=Assertions.d.ts.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/Assertions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Assertions.d.ts","sourceRoot":"/","sources":["interactions/slashCommands/Assertions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,sBAAsB,CAAC;AAE9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,6BAA6B,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAEnH,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,8BAA8B,EAAE,QAUzC;AAUD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,IAAI,MAAM,CAElE;AAID,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,IAAI,MAAM,CAEvF;AAID,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,8BAA8B,EAAE,CAE9G;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,iCAAiC,EAAE,QAEpF;AAED,wBAAgB,qBAAqB,CACpC,CAAC,SAAS,sBAAsB,GAAG,6BAA6B,GAAG,kCAAkC,EACpG,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,CAuBrE"}

node_modules/@discordjs/builders/dist/interactions/slashCommands/Assertions.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertReturnOfBuilder = exports.validateMaxChoicesLength = exports.validateMaxOptionsLength = exports.validateDescription = exports.validateName = exports.validateRequiredParameters = void 0;
-const tslib_1 = require("tslib");
-const is_1 = tslib_1.__importDefault(require("@sindresorhus/is"));
-const ow_1 = tslib_1.__importDefault(require("ow"));
-function validateRequiredParameters(name, description, options) {
-    // Assert name matches all conditions
-    validateName(name);
-    // Assert description conditions
-    validateDescription(description);
-    // Assert options conditions
-    validateMaxOptionsLength(options);
-}
-exports.validateRequiredParameters = validateRequiredParameters;
-const namePredicate = ow_1.default.string.lowercase
-    .minLength(1)
-    .maxLength(32)
-    .addValidator({
-    message: (value, label) => `Expected ${label} to match "^[\\p{L}\\p{N}_-]+$", got ${value} instead`,
-    validator: (value) => /^[\p{L}\p{N}_-]+$/u.test(value),
-});
-function validateName(name) {
-    ow_1.default(name, 'name', namePredicate);
-}
-exports.validateName = validateName;
-const descriptionPredicate = ow_1.default.string.minLength(1).maxLength(100);
-function validateDescription(description) {
-    ow_1.default(description, 'description', descriptionPredicate);
-}
-exports.validateDescription = validateDescription;
-const maxArrayLengthPredicate = ow_1.default.array.maxLength(25);
-function validateMaxOptionsLength(options) {
-    ow_1.default(options, 'options', maxArrayLengthPredicate);
-}
-exports.validateMaxOptionsLength = validateMaxOptionsLength;
-function validateMaxChoicesLength(choices) {
-    ow_1.default(choices, 'choices', maxArrayLengthPredicate);
-}
-exports.validateMaxChoicesLength = validateMaxChoicesLength;
-function assertReturnOfBuilder(input, ExpectedInstanceOf) {
-    const instanceName = ExpectedInstanceOf.name;
-    if (is_1.default.nullOrUndefined(input)) {
-        throw new TypeError(`Expected to receive a ${instanceName} builder, got ${input === null ? 'null' : 'undefined'} instead.`);
-    }
-    if (is_1.default.primitive(input)) {
-        throw new TypeError(`Expected to receive a ${instanceName} builder, got a primitive (${typeof input}) instead.`);
-    }
-    if (!(input instanceof ExpectedInstanceOf)) {
-        const casted = input;
-        const constructorName = is_1.default.function_(input) ? input.name : casted.constructor.name;
-        const stringTag = Reflect.get(casted, Symbol.toStringTag);
-        const fullResultName = stringTag ? `${constructorName} [${stringTag}]` : constructorName;
-        throw new TypeError(`Expected to receive a ${instanceName} builder, got ${fullResultName} instead.`);
-    }
-}
-exports.assertReturnOfBuilder = assertReturnOfBuilder;
-//# sourceMappingURL=Assertions.js.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/Assertions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Assertions.js","sourceRoot":"/","sources":["interactions/slashCommands/Assertions.ts"],"names":[],"mappings":";;;;AAAA,kEAAkC;AAElC,oDAAoB;AAKpB,SAAgB,0BAA0B,CACzC,IAAY,EACZ,WAAmB,EACnB,OAAyC;IAEzC,qCAAqC;IACrC,YAAY,CAAC,IAAI,CAAC,CAAC;IAEnB,gCAAgC;IAChC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAEjC,4BAA4B;IAC5B,wBAAwB,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAbD,gEAaC;AAED,MAAM,aAAa,GAAG,YAAE,CAAC,MAAM,CAAC,SAAS;KACvC,SAAS,CAAC,CAAC,CAAC;KACZ,SAAS,CAAC,EAAE,CAAC;KACb,YAAY,CAAC;IACb,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,YAAY,KAAM,wCAAwC,KAAK,UAAU;IACpG,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC;CACtD,CAAC,CAAC;AAEJ,SAAgB,YAAY,CAAC,IAAa;IACzC,YAAE,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;AACjC,CAAC;AAFD,oCAEC;AAED,MAAM,oBAAoB,GAAG,YAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;AAEnE,SAAgB,mBAAmB,CAAC,WAAoB;IACvD,YAAE,CAAC,WAAW,EAAE,aAAa,EAAE,oBAAoB,CAAC,CAAC;AACtD,CAAC;AAFD,kDAEC;AAED,MAAM,uBAAuB,GAAG,YAAE,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;AAEvD,SAAgB,wBAAwB,CAAC,OAAgB;IACxD,YAAE,CAAC,OAAO,EAAE,SAAS,EAAE,uBAAuB,CAAC,CAAC;AACjD,CAAC;AAFD,4DAEC;AAED,SAAgB,wBAAwB,CAAC,OAA4C;IACpF,YAAE,CAAC,OAAO,EAAE,SAAS,EAAE,uBAAuB,CAAC,CAAC;AACjD,CAAC;AAFD,4DAEC;AAED,SAAgB,qBAAqB,CAEnC,KAAc,EAAE,kBAA+B;IAChD,MAAM,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC;IAE7C,IAAI,YAAE,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE;QAC9B,MAAM,IAAI,SAAS,CAClB,yBAAyB,YAAY,iBAAiB,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,WAAW,CACtG,CAAC;KACF;IAED,IAAI,YAAE,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;QACxB,MAAM,IAAI,SAAS,CAAC,yBAAyB,YAAY,8BAA8B,OAAO,KAAK,YAAY,CAAC,CAAC;KACjH;IAED,IAAI,CAAC,CAAC,KAAK,YAAY,kBAAkB,CAAC,EAAE;QAC3C,MAAM,MAAM,GAAG,KAAqC,CAAC;QAErD,MAAM,eAAe,GAAG,YAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC;QACnF,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,CAAuB,CAAC;QAEhF,MAAM,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,eAAe,KAAK,SAAS,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC;QAEzF,MAAM,IAAI,SAAS,CAAC,yBAAyB,YAAY,iBAAiB,cAAc,WAAW,CAAC,CAAC;KACrG;AACF,CAAC;AAzBD,sDAyBC","sourcesContent":["import is from '@sindresorhus/is';\nimport type { APIApplicationCommandOptionChoice } from 'discord-api-types/v9';\nimport ow from 'ow';\nimport type { SlashCommandOptionBase } from './mixins/CommandOptionBase';\nimport type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';\nimport type { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';\n\nexport function validateRequiredParameters(\n\tname: string,\n\tdescription: string,\n\toptions: ToAPIApplicationCommandOptions[],\n) {\n\t// Assert name matches all conditions\n\tvalidateName(name);\n\n\t// Assert description conditions\n\tvalidateDescription(description);\n\n\t// Assert options conditions\n\tvalidateMaxOptionsLength(options);\n}\n\nconst namePredicate = ow.string.lowercase\n\t.minLength(1)\n\t.maxLength(32)\n\t.addValidator({\n\t\tmessage: (value, label) => `Expected ${label!} to match \"^[\\\\p{L}\\\\p{N}_-]+$\", got ${value} instead`,\n\t\tvalidator: (value) => /^[\\p{L}\\p{N}_-]+$/u.test(value),\n\t});\n\nexport function validateName(name: unknown): asserts name is string {\n\tow(name, 'name', namePredicate);\n}\n\nconst descriptionPredicate = ow.string.minLength(1).maxLength(100);\n\nexport function validateDescription(description: unknown): asserts description is string {\n\tow(description, 'description', descriptionPredicate);\n}\n\nconst maxArrayLengthPredicate = ow.array.maxLength(25);\n\nexport function validateMaxOptionsLength(options: unknown): asserts options is ToAPIApplicationCommandOptions[] {\n\tow(options, 'options', maxArrayLengthPredicate);\n}\n\nexport function validateMaxChoicesLength(choices: APIApplicationCommandOptionChoice[]) {\n\tow(choices, 'choices', maxArrayLengthPredicate);\n}\n\nexport function assertReturnOfBuilder<\n\tT extends SlashCommandOptionBase | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder,\n>(input: unknown, ExpectedInstanceOf: new () => T): asserts input is T {\n\tconst instanceName = ExpectedInstanceOf.name;\n\n\tif (is.nullOrUndefined(input)) {\n\t\tthrow new TypeError(\n\t\t\t`Expected to receive a ${instanceName} builder, got ${input === null ? 'null' : 'undefined'} instead.`,\n\t\t);\n\t}\n\n\tif (is.primitive(input)) {\n\t\tthrow new TypeError(`Expected to receive a ${instanceName} builder, got a primitive (${typeof input}) instead.`);\n\t}\n\n\tif (!(input instanceof ExpectedInstanceOf)) {\n\t\tconst casted = input as Record<PropertyKey, unknown>;\n\n\t\tconst constructorName = is.function_(input) ? input.name : casted.constructor.name;\n\t\tconst stringTag = Reflect.get(casted, Symbol.toStringTag) as string | undefined;\n\n\t\tconst fullResultName = stringTag ? `${constructorName} [${stringTag}]` : constructorName;\n\n\t\tthrow new TypeError(`Expected to receive a ${instanceName} builder, got ${fullResultName} instead.`);\n\t}\n}\n"]}

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandBuilder.d.ts

@@ -1,50 +0,0 @@
-import type { APIApplicationCommandOption } from 'discord-api-types/v9';
-import { SharedNameAndDescription } from './mixins/NameAndDescription';
-import { SharedSlashCommandOptions } from './mixins/CommandOptions';
-import { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
-export declare class SlashCommandBuilder {
-    /**
-     * The name of this slash command
-     */
-    readonly name: string;
-    /**
-     * The description of this slash command
-     */
-    readonly description: string;
-    /**
-     * The options of this slash command
-     */
-    readonly options: ToAPIApplicationCommandOptions[];
-    /**
-     * Returns the final data that should be sent to Discord.
-     *
-     * **Note:** Calling this function will validate required properties based on their conditions.
-     */
-    toJSON(): {
-        name: string;
-        description: string;
-        options: APIApplicationCommandOption[];
-    };
-    /**
-     * Adds a new subcommand group to this command
-     * @param input A function that returns a subcommand group builder, or an already built builder
-     */
-    addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandGroupsOnlyBuilder;
-    /**
-     * Adds a new subcommand to this command
-     * @param input A function that returns a subcommand builder, or an already built builder
-     */
-    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
-}
-export interface SlashCommandBuilder extends SharedNameAndDescription, SharedSlashCommandOptions {
-}
-export interface SlashCommandSubcommandsOnlyBuilder extends SharedNameAndDescription, Pick<SlashCommandBuilder, 'toJSON' | 'addSubcommand'> {
-}
-export interface SlashCommandSubcommandGroupsOnlyBuilder extends SharedNameAndDescription, Pick<SlashCommandBuilder, 'toJSON' | 'addSubcommandGroup'> {
-}
-export interface SlashCommandOptionsOnlyBuilder extends SharedNameAndDescription, SharedSlashCommandOptions, Pick<SlashCommandBuilder, 'toJSON'> {
-}
-export interface ToAPIApplicationCommandOptions {
-    toJSON(): APIApplicationCommandOption;
-}
-//# sourceMappingURL=SlashCommandBuilder.d.ts.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SlashCommandBuilder.d.ts","sourceRoot":"/","sources":["interactions/slashCommands/SlashCommandBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAGxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,6BAA6B,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAE9G,qBACa,mBAAmB;IAC/B;;OAEG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAc;IAE1C;;OAEG;IACH,SAAgB,WAAW,EAAE,MAAM,CAAc;IAEjD;;OAEG;IACH,SAAgB,OAAO,EAAE,8BAA8B,EAAE,CAAM;IAE/D;;;;OAIG;IACI,MAAM;;;;;IASb;;;OAGG;IACI,kBAAkB,CACxB,KAAK,EACF,kCAAkC,GAClC,CAAC,CAAC,eAAe,EAAE,kCAAkC,KAAK,kCAAkC,CAAC,GAC9F,uCAAuC;IAqB1C;;;OAGG;IACI,aAAa,CACnB,KAAK,EACF,6BAA6B,GAC7B,CAAC,CAAC,eAAe,EAAE,6BAA6B,KAAK,6BAA6B,CAAC,GACpF,kCAAkC;CAqBrC;AAED,MAAM,WAAW,mBAAoB,SAAQ,wBAAwB,EAAE,yBAAyB;CAAG;AAEnG,MAAM,WAAW,kCAChB,SAAQ,wBAAwB,EAC/B,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,eAAe,CAAC;CAAG;AAE1D,MAAM,WAAW,uCAChB,SAAQ,wBAAwB,EAC/B,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,oBAAoB,CAAC;CAAG;AAE/D,MAAM,WAAW,8BAChB,SAAQ,wBAAwB,EAC/B,yBAAyB,EACzB,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC;CAAG;AAExC,MAAM,WAAW,8BAA8B;IAC9C,MAAM,IAAI,2BAA2B,CAAC;CACtC"}

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandBuilder.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlashCommandBuilder = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const Assertions_1 = require("./Assertions");
-const NameAndDescription_1 = require("./mixins/NameAndDescription");
-const CommandOptions_1 = require("./mixins/CommandOptions");
-const SlashCommandSubcommands_1 = require("./SlashCommandSubcommands");
-let SlashCommandBuilder = class SlashCommandBuilder {
-    constructor() {
-        /**
-         * The name of this slash command
-         */
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The description of this slash command
-         */
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The options of this slash command
-         */
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    /**
-     * Returns the final data that should be sent to Discord.
-     *
-     * **Note:** Calling this function will validate required properties based on their conditions.
-     */
-    toJSON() {
-        Assertions_1.validateRequiredParameters(this.name, this.description, this.options);
-        return {
-            name: this.name,
-            description: this.description,
-            options: this.options.map((option) => option.toJSON()),
-        };
-    }
-    /**
-     * Adds a new subcommand group to this command
-     * @param input A function that returns a subcommand group builder, or an already built builder
-     */
-    addSubcommandGroup(input) {
-        const { options } = this;
-        // First, assert options conditions - we cannot have more than 25 options
-        Assertions_1.validateMaxOptionsLength(options);
-        // Make sure there is no subcommand at the root level - if there is, throw
-        const hasSubcommands = options.some((item) => item instanceof SlashCommandSubcommands_1.SlashCommandSubcommandBuilder);
-        if (hasSubcommands)
-            throw new RangeError(`You cannot mix subcommands and subcommand groups at the root level.`);
-        // Get the final result
-        const result = typeof input === 'function' ? input(new SlashCommandSubcommands_1.SlashCommandSubcommandGroupBuilder()) : input;
-        Assertions_1.assertReturnOfBuilder(result, SlashCommandSubcommands_1.SlashCommandSubcommandGroupBuilder);
-        // Push it
-        options.push(result);
-        return this;
-    }
-    /**
-     * Adds a new subcommand to this command
-     * @param input A function that returns a subcommand builder, or an already built builder
-     */
-    addSubcommand(input) {
-        const { options } = this;
-        // First, assert options conditions - we cannot have more than 25 options
-        Assertions_1.validateMaxOptionsLength(options);
-        // Make sure there is no subcommand at the root level - if there is, throw
-        const hasSubcommandGroups = options.some((item) => item instanceof SlashCommandSubcommands_1.SlashCommandSubcommandGroupBuilder);
-        if (hasSubcommandGroups)
-            throw new RangeError(`You cannot mix subcommands and subcommand groups at the root level.`);
-        // Get the final result
-        const result = typeof input === 'function' ? input(new SlashCommandSubcommands_1.SlashCommandSubcommandBuilder()) : input;
-        Assertions_1.assertReturnOfBuilder(result, SlashCommandSubcommands_1.SlashCommandSubcommandBuilder);
-        // Push it
-        options.push(result);
-        return this;
-    }
-};
-SlashCommandBuilder = tslib_1.__decorate([
-    ts_mixer_1.mix(CommandOptions_1.SharedSlashCommandOptions, NameAndDescription_1.SharedNameAndDescription)
-], SlashCommandBuilder);
-exports.SlashCommandBuilder = SlashCommandBuilder;
-//# sourceMappingURL=SlashCommandBuilder.js.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SlashCommandBuilder.js","sourceRoot":"/","sources":["interactions/slashCommands/SlashCommandBuilder.ts"],"names":[],"mappings":";;;;AACA,uCAA+B;AAC/B,6CAA2G;AAC3G,oEAAuE;AACvE,4DAAoE;AACpE,uEAA8G;AAG9G,IAAa,mBAAmB,GAAhC,MAAa,mBAAmB;IAAhC;QACC;;WAEG;QACH;;;;mBAA+B,SAAU;WAAC;QAE1C;;WAEG;QACH;;;;mBAAsC,SAAU;WAAC;QAEjD;;WAEG;QACH;;;;mBAA4D,EAAE;WAAC;IA0EhE,CAAC;IAxEA;;;;OAIG;IACI,MAAM;QACZ,uCAA0B,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACtE,OAAO;YACN,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;SACtD,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,kBAAkB,CACxB,KAEgG;QAEhG,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QAEzB,yEAAyE;QACzE,qCAAwB,CAAC,OAAO,CAAC,CAAC;QAElC,0EAA0E;QAC1E,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,YAAY,uDAA6B,CAAC,CAAC;QAC7F,IAAI,cAAc;YAAE,MAAM,IAAI,UAAU,CAAC,qEAAqE,CAAC,CAAC;QAEhH,uBAAuB;QACvB,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,4DAAkC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAErG,kCAAqB,CAAC,MAAM,EAAE,4DAAkC,CAAC,CAAC;QAElE,UAAU;QACV,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAErB,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;OAGG;IACI,aAAa,CACnB,KAEsF;QAEtF,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QAEzB,yEAAyE;QACzE,qCAAwB,CAAC,OAAO,CAAC,CAAC;QAElC,0EAA0E;QAC1E,MAAM,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,YAAY,4DAAkC,CAAC,CAAC;QACvG,IAAI,mBAAmB;YACtB,MAAM,IAAI,UAAU,CAAC,qEAAqE,CAAC,CAAC;QAE7F,uBAAuB;QACvB,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,uDAA6B,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAEhG,kCAAqB,CAAC,MAAM,EAAE,uDAA6B,CAAC,CAAC;QAE7D,UAAU;QACV,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAErB,OAAO,IAAI,CAAC;IACb,CAAC;CACD,CAAA;AAxFY,mBAAmB;IAD/B,cAAG,CAAC,0CAAyB,EAAE,6CAAwB,CAAC;GAC5C,mBAAmB,CAwF/B;AAxFY,kDAAmB","sourcesContent":["import type { APIApplicationCommandOption } from 'discord-api-types/v9';\nimport { mix } from 'ts-mixer';\nimport { assertReturnOfBuilder, validateMaxOptionsLength, validateRequiredParameters } from './Assertions';\nimport { SharedNameAndDescription } from './mixins/NameAndDescription';\nimport { SharedSlashCommandOptions } from './mixins/CommandOptions';\nimport { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';\n\n@mix(SharedSlashCommandOptions, SharedNameAndDescription)\nexport class SlashCommandBuilder {\n\t/**\n\t * The name of this slash command\n\t */\n\tpublic readonly name: string = undefined!;\n\n\t/**\n\t * The description of this slash command\n\t */\n\tpublic readonly description: string = undefined!;\n\n\t/**\n\t * The options of this slash command\n\t */\n\tpublic readonly options: ToAPIApplicationCommandOptions[] = [];\n\n\t/**\n\t * Returns the final data that should be sent to Discord.\n\t *\n\t * **Note:** Calling this function will validate required properties based on their conditions.\n\t */\n\tpublic toJSON() {\n\t\tvalidateRequiredParameters(this.name, this.description, this.options);\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tdescription: this.description,\n\t\t\toptions: this.options.map((option) => option.toJSON()),\n\t\t};\n\t}\n\n\t/**\n\t * Adds a new subcommand group to this command\n\t * @param input A function that returns a subcommand group builder, or an already built builder\n\t */\n\tpublic addSubcommandGroup(\n\t\tinput:\n\t\t\t| SlashCommandSubcommandGroupBuilder\n\t\t\t| ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder),\n\t): SlashCommandSubcommandGroupsOnlyBuilder {\n\t\tconst { options } = this;\n\n\t\t// First, assert options conditions - we cannot have more than 25 options\n\t\tvalidateMaxOptionsLength(options);\n\n\t\t// Make sure there is no subcommand at the root level - if there is, throw\n\t\tconst hasSubcommands = options.some((item) => item instanceof SlashCommandSubcommandBuilder);\n\t\tif (hasSubcommands) throw new RangeError(`You cannot mix subcommands and subcommand groups at the root level.`);\n\n\t\t// Get the final result\n\t\tconst result = typeof input === 'function' ? input(new SlashCommandSubcommandGroupBuilder()) : input;\n\n\t\tassertReturnOfBuilder(result, SlashCommandSubcommandGroupBuilder);\n\n\t\t// Push it\n\t\toptions.push(result);\n\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds a new subcommand to this command\n\t * @param input A function that returns a subcommand builder, or an already built builder\n\t */\n\tpublic addSubcommand(\n\t\tinput:\n\t\t\t| SlashCommandSubcommandBuilder\n\t\t\t| ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder),\n\t): SlashCommandSubcommandsOnlyBuilder {\n\t\tconst { options } = this;\n\n\t\t// First, assert options conditions - we cannot have more than 25 options\n\t\tvalidateMaxOptionsLength(options);\n\n\t\t// Make sure there is no subcommand at the root level - if there is, throw\n\t\tconst hasSubcommandGroups = options.some((item) => itLine truncated

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandSubcommands.d.ts

@@ -1,64 +0,0 @@
-import { ApplicationCommandOptionType } from 'discord-api-types/v9';
-import { SharedSlashCommandOptions } from './mixins/CommandOptions';
-import { SharedNameAndDescription } from './mixins/NameAndDescription';
-import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
-/**
- * Represents a folder for subcommands
- *
- * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
- */
-export declare class SlashCommandSubcommandGroupBuilder implements ToAPIApplicationCommandOptions {
-    /**
-     * The name of this subcommand group
-     */
-    readonly name: string;
-    /**
-     * The description of this subcommand group
-     */
-    readonly description: string;
-    /**
-     * The subcommands part of this subcommand group
-     */
-    readonly options: ToAPIApplicationCommandOptions[];
-    /**
-     * Adds a new subcommand to this group
-     * @param input A function that returns a subcommand builder, or an already built builder
-     */
-    addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): this;
-    toJSON(): {
-        type: ApplicationCommandOptionType;
-        name: string;
-        description: string;
-        options: import("discord-api-types/v9").APIApplicationCommandOption[];
-    };
-}
-export interface SlashCommandSubcommandGroupBuilder extends SharedNameAndDescription {
-}
-/**
- * Represents a subcommand
- *
- * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
- */
-export declare class SlashCommandSubcommandBuilder implements ToAPIApplicationCommandOptions {
-    /**
-     * The name of this subcommand
-     */
-    readonly name: string;
-    /**
-     * The description of this subcommand
-     */
-    readonly description: string;
-    /**
-     * The options of this subcommand
-     */
-    readonly options: ToAPIApplicationCommandOptions[];
-    toJSON(): {
-        type: ApplicationCommandOptionType;
-        name: string;
-        description: string;
-        options: import("discord-api-types/v9").APIApplicationCommandOption[];
-    };
-}
-export interface SlashCommandSubcommandBuilder extends SharedNameAndDescription, SharedSlashCommandOptions<false> {
-}
-//# sourceMappingURL=SlashCommandSubcommands.d.ts.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandSubcommands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SlashCommandSubcommands.d.ts","sourceRoot":"/","sources":["interactions/slashCommands/SlashCommandSubcommands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AAGpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAE5E;;;;GAIG;AACH,qBACa,kCAAmC,YAAW,8BAA8B;IACxF;;OAEG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAc;IAE1C;;OAEG;IACH,SAAgB,WAAW,EAAE,MAAM,CAAc;IAEjD;;OAEG;IACH,SAAgB,OAAO,EAAE,8BAA8B,EAAE,CAAM;IAE/D;;;OAGG;IACI,aAAa,CACnB,KAAK,EACF,6BAA6B,GAC7B,CAAC,CAAC,eAAe,EAAE,6BAA6B,KAAK,6BAA6B,CAAC;IAkBhF,MAAM;;;;;;CASb;AAED,MAAM,WAAW,kCAAmC,SAAQ,wBAAwB;CAAG;AAEvF;;;;GAIG;AACH,qBACa,6BAA8B,YAAW,8BAA8B;IACnF;;OAEG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAc;IAE1C;;OAEG;IACH,SAAgB,WAAW,EAAE,MAAM,CAAc;IAEjD;;OAEG;IACH,SAAgB,OAAO,EAAE,8BAA8B,EAAE,CAAM;IAExD,MAAM;;;;;;CASb;AAED,MAAM,WAAW,6BAA8B,SAAQ,wBAAwB,EAAE,yBAAyB,CAAC,KAAK,CAAC;CAAG"}

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandSubcommands.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlashCommandSubcommandBuilder = exports.SlashCommandSubcommandGroupBuilder = void 0;
-const tslib_1 = require("tslib");
-require("discord-api-types/v9");
-const ts_mixer_1 = require("ts-mixer");
-const Assertions_1 = require("./Assertions");
-const CommandOptions_1 = require("./mixins/CommandOptions");
-const NameAndDescription_1 = require("./mixins/NameAndDescription");
-/**
- * Represents a folder for subcommands
- *
- * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
- */
-let SlashCommandSubcommandGroupBuilder = class SlashCommandSubcommandGroupBuilder {
-    constructor() {
-        /**
-         * The name of this subcommand group
-         */
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The description of this subcommand group
-         */
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The subcommands part of this subcommand group
-         */
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    /**
-     * Adds a new subcommand to this group
-     * @param input A function that returns a subcommand builder, or an already built builder
-     */
-    addSubcommand(input) {
-        const { options } = this;
-        // First, assert options conditions - we cannot have more than 25 options
-        Assertions_1.validateMaxOptionsLength(options);
-        // Get the final result
-        const result = typeof input === 'function' ? input(new SlashCommandSubcommandBuilder()) : input;
-        Assertions_1.assertReturnOfBuilder(result, SlashCommandSubcommandBuilder);
-        // Push it
-        options.push(result);
-        return this;
-    }
-    toJSON() {
-        Assertions_1.validateRequiredParameters(this.name, this.description, this.options);
-        return {
-            type: 2 /* SubcommandGroup */,
-            name: this.name,
-            description: this.description,
-            options: this.options.map((option) => option.toJSON()),
-        };
-    }
-};
-SlashCommandSubcommandGroupBuilder = tslib_1.__decorate([
-    ts_mixer_1.mix(NameAndDescription_1.SharedNameAndDescription)
-], SlashCommandSubcommandGroupBuilder);
-exports.SlashCommandSubcommandGroupBuilder = SlashCommandSubcommandGroupBuilder;
-/**
- * Represents a subcommand
- *
- * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
- */
-let SlashCommandSubcommandBuilder = class SlashCommandSubcommandBuilder {
-    constructor() {
-        /**
-         * The name of this subcommand
-         */
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The description of this subcommand
-         */
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        /**
-         * The options of this subcommand
-         */
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    toJSON() {
-        Assertions_1.validateRequiredParameters(this.name, this.description, this.options);
-        return {
-            type: 1 /* Subcommand */,
-            name: this.name,
-            description: this.description,
-            options: this.options.map((option) => option.toJSON()),
-        };
-    }
-};
-SlashCommandSubcommandBuilder = tslib_1.__decorate([
-    ts_mixer_1.mix(NameAndDescription_1.SharedNameAndDescription, CommandOptions_1.SharedSlashCommandOptions)
-], SlashCommandSubcommandBuilder);
-exports.SlashCommandSubcommandBuilder = SlashCommandSubcommandBuilder;
-//# sourceMappingURL=SlashCommandSubcommands.js.map

node_modules/@discordjs/builders/dist/interactions/slashCommands/SlashCommandSubcommands.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SlashCommandSubcommands.js","sourceRoot":"/","sources":["interactions/slashCommands/SlashCommandSubcommands.ts"],"names":[],"mappings":";;;;AAAA,gCAAoE;AACpE,uCAA+B;AAC/B,6CAA2G;AAC3G,4DAAoE;AACpE,oEAAuE;AAGvE;;;;GAIG;AAEH,IAAa,kCAAkC,GAA/C,MAAa,kCAAkC;IAA/C;QACC;;WAEG;QACH;;;;mBAA+B,SAAU;WAAC;QAE1C;;WAEG;QACH;;;;mBAAsC,SAAU;WAAC;QAEjD;;WAEG;QACH;;;;mBAA4D,EAAE;WAAC;IAoChE,CAAC;IAlCA;;;OAGG;IACI,aAAa,CACnB,KAEsF;QAEtF,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QAEzB,yEAAyE;QACzE,qCAAwB,CAAC,OAAO,CAAC,CAAC;QAElC,uBAAuB;QACvB,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,6BAA6B,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAEhG,kCAAqB,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;QAE7D,UAAU;QACV,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAErB,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,MAAM;QACZ,uCAA0B,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACtE,OAAO;YACN,IAAI,yBAA8C;YAClD,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;SACtD,CAAC;IACH,CAAC;CACD,CAAA;AAlDY,kCAAkC;IAD9C,cAAG,CAAC,6CAAwB,CAAC;GACjB,kCAAkC,CAkD9C;AAlDY,gFAAkC;AAsD/C;;;;GAIG;AAEH,IAAa,6BAA6B,GAA1C,MAAa,6BAA6B;IAA1C;QACC;;WAEG;QACH;;;;mBAA+B,SAAU;WAAC;QAE1C;;WAEG;QACH;;;;mBAAsC,SAAU;WAAC;QAEjD;;WAEG;QACH;;;;mBAA4D,EAAE;WAAC;IAWhE,CAAC;IATO,MAAM;QACZ,uCAA0B,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACtE,OAAO;YACN,IAAI,oBAAyC;YAC7C,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;SACtD,CAAC;IACH,CAAC;CACD,CAAA;AAzBY,6BAA6B;IADzC,cAAG,CAAC,6CAAwB,EAAE,0CAAyB,CAAC;GAC5C,6BAA6B,CAyBzC;AAzBY,sEAA6B","sourcesContent":["import { ApplicationCommandOptionType } from 'discord-api-types/v9';\nimport { mix } from 'ts-mixer';\nimport { assertReturnOfBuilder, validateMaxOptionsLength, validateRequiredParameters } from './Assertions';\nimport { SharedSlashCommandOptions } from './mixins/CommandOptions';\nimport { SharedNameAndDescription } from './mixins/NameAndDescription';\nimport type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';\n\n/**\n * Represents a folder for subcommands\n *\n * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups\n */\n@mix(SharedNameAndDescription)\nexport class SlashCommandSubcommandGroupBuilder implements ToAPIApplicationCommandOptions {\n\t/**\n\t * The name of this subcommand group\n\t */\n\tpublic readonly name: string = undefined!;\n\n\t/**\n\t * The description of this subcommand group\n\t */\n\tpublic readonly description: string = undefined!;\n\n\t/**\n\t * The subcommands part of this subcommand group\n\t */\n\tpublic readonly options: ToAPIApplicationCommandOptions[] = [];\n\n\t/**\n\t * Adds a new subcommand to this group\n\t * @param input A function that returns a subcommand builder, or an already built builder\n\t */\n\tpublic addSubcommand(\n\t\tinput:\n\t\t\t| SlashCommandSubcommandBuilder\n\t\t\t| ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder),\n\t) {\n\t\tconst { options } = this;\n\n\t\t// First, assert options conditions - we cannot have more than 25 options\n\t\tvalidateMaxOptionsLength(options);\n\n\t\t// Get the final result\n\t\tconst result = typeof input === 'function' ? input(new SlashCommandSubcommandBuilder()) : input;\n\n\t\tassertReturnOfBuilder(result, SlashCommandSubcommandBuilder);\n\n\t\t// Push it\n\t\toptions.push(result);\n\n\t\treturn this;\n\t}\n\n\tpublic toJSON() {\n\t\tvalidateRequiredParameters(this.name, this.description, this.options);\n\t\treturn {\n\t\t\ttype: ApplicationCommandOptionType.SubcommandGroup,\n\t\t\tname: this.name,\n\t\t\tdescription: this.description,\n\t\t\toptions: this.options.map((option) => option.toJSON()),\n\t\t};\n\t}\n}\n\nexport interface SlashCommandSubcommandGroupBuilder extends SharedNameAndDescription {}\n\n/**\n * Represents a subcommand\n *\n * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups\n */\n@mix(SharedNameAndDescription, SharedSlashCommandOptions)\nexport class SlashCommandSubcommandBuilder implements ToAPIApplicationCommandOptions {\n\t/**\n\t * The name of this subcommand\n\t */\n\tpublic readonly name: string = undefined!;\n\n\t/**\n\t * The description of this subcommand\n\t */\n\tpublic readonly description: string = undefined!;\n\n\t/**\n\t * The options of this subcommand\n\t */\n\tpublic readonly options: ToAPIApplicationCommandOptions[] = [];\n\n\tpublic toJSON() {\n\t\tvalidateRequiredParameters(this.name, this.description, this.options);\n\t\treturn {\n\t\t\ttype: ApplicationCommandOptionType.Subcommand,\n\t\t\tname: this.name,\n\t\t\tdescription: this.description,\n\t\t\toptions: this.options.map((option) => option.toJSON()),\n\t\t};\n\t}\n}\n\nexport interface SlashCommandSubcommandBuilLine truncated