i am trying to create a simple ticketbot for discord, but i ran into an issue that i cannot seem to fix, i have tried several different approaches and adding a deferReply aswell, but whenever the button to create a ticket is clicked, i get the “interaction has failed” error.
I also added error handling to check if there might be another issue related to permission, but there is no console output at all, so i am really unsure on what the error is.

If anyone knows of a way to fix this I would greatly appreciate it.
Below is my code

const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, PermissionsBitField } = require('discord.js');
const { translate } = require('../locales/en.json');

class TicketManager {
    constructor(client) {
        this.client = client;
        this.setupInteractionHandler();
    }

    setupInteractionHandler() {
        this.client.on('interactionCreate', async interaction => {
            if (!interaction.isButton()) return;

            switch (interaction.customId.split('_')[0]) {
                case 'create_ticket':
                    await this.handleTicketCreation(interaction).catch(error => {
                        console.error('Error handling ticket creation:', error);
                        interaction.followUp({ content: translate("ERROR_CREATING_TICKET"), ephemeral: true }).catch(console.error);
                    });
                    break;
                case 'close_ticket':
                    await this.handleTicketClosure(interaction).catch(error => {
                        console.error('Error handling ticket closure:', error);
                        interaction.followUp({ content: translate("ERROR_CLOSING_TICKET"), ephemeral: true }).catch(console.error);
                    });
                    break;
            }
        });
    }

    async handleTicketCreation(interaction) {
        await interaction.deferReply({ ephemeral: true });

        try {
            const supportCategory = interaction.guild.channels.cache.find(c => c.type === ChannelType.GuildCategory && c.name.toLowerCase() === "support");
            if (!supportCategory) {
                console.error('Support category does not exist');
                return interaction.editReply({ content: translate("SUPPORT_CATEGORY_MISSING") });
            }

            if (!interaction.guild.me.permissions.has(PermissionsBitField.Flags.ManageChannels)) {
                console.error('Missing permission to manage channels');
                return interaction.editReply({ content: translate("MISSING_MANAGE_CHANNELS_PERMISSION") });
            }

            const ticketChannel = await interaction.guild.channels.create({
                name: `ticket-${interaction.user.username.toLowerCase()}-${Date.now()}`,
                type: ChannelType.GuildText,
                parent: supportCategory.id,
                permissionOverwrites: this.getPermissionOverwrites(interaction)
            });

            const closeTicketButton = new ButtonBuilder()
                .setCustomId(`close_ticket_${ticketChannel.id}`)
                .setLabel(translate("CLOSE_TICKET"))
                .setStyle(ButtonStyle.Danger);

            const row = new ActionRowBuilder().addComponents(closeTicketButton);
            const embed = new EmbedBuilder()
                .setColor(0x00AE86)
                .setTitle(translate("TICKET_CREATED_TITLE"))
                .setDescription(translate("TICKET_CREATED_DESCRIPTION", { user: interaction.user.username }))
                .setFooter({ text: translate("USER_ID_LABEL") + `: ${interaction.user.id}` });

            await ticketChannel.send({ content: interaction.user.toString(), embeds: , components: [row] });
            await interaction.editReply({ content: translate("TICKET_CREATED_REPLY") });
        } catch (error) {
            console.error('Failed to create ticket:', error);
            throw error;
        }
    }

    async handleTicketClosure(interaction) {
        try {
            if (!interaction.guild.me.permissions.has(PermissionsBitField.Flags.ManageChannels)) {
                console.error('Missing permission to manage channels');
                throw new Error(translate("MISSING_MANAGE_CHANNELS_PERMISSION"));
            }

            const ticketChannel = interaction.channel;
            await ticketChannel.delete();
        } catch (error) {
            console.error('Failed to close ticket:', error);
            throw error;
        }
    }

    getPermissionOverwrites(interaction) {
        return [
            {
                id: interaction.guild.id,
                deny: [PermissionsBitField.Flags.ViewChannel]
            },
            {
                id: interaction.user.id,
                allow: [PermissionsBitField.Flags.ViewChannel, PermissionsBitField.Flags.SendMessages]
            },
            {
                id: interaction.guild.roles.cache.find(r => r.name === "Administrator").id,
                allow: [PermissionsBitField.Flags.ViewChannel, PermissionsBitField.Flags.ManageMessages]
            }
        ];
    }
}

module.exports = TicketManager;