interaction: {
        type: ApplicationCommandType.ChatInput,
        description: 'Show a list of commands',
        options: [
            {
                name: 'command',
                description: 'The command to get help for',
                type: ApplicationCommandOptionType.String,
                required: false,
            },
            {
                name: 'type',
                description: 'The type of command to get help for (slash, user, message) - defaults to slash',
                type: ApplicationCommandOptionType.String,
                choices: [
                    {name: 'slash', value: 'chat'},
                    {name: 'user', value: 'user'},
                    {name: 'message', value: 'message'},
                ],
                required: false,

            }
        ],
    },

    interaction: {
        type: ApplicationCommandType.ChatInput,
        description: 'Show a list of commands',
        options: [
            {
                name: 'command',
                description: 'The command to get help for',
                type: ApplicationCommandOptionType.String,
                required: false,
            },
            {
                name: 'type',
                description: 'The type of command to get help for (slash, user, message) - defaults to slash',
                type: ApplicationCommandOptionType.String,
                choices: [
                    {name: 'slash', value: 'chat'},
                    {name: 'user', value: 'user'},
                    {name: 'message', value: 'message'},
                ],
                required: false,

            }
        ],
    },

export async function getInteractionsOfType<
  TType extends keyof BackendInteractionType
>(type: TType): Promise<Record<string, BackendInteractionType[TType]>> {
  const interactionTypeDir = path.join(interactionsDir, type);
  console.log(
    `Processing ${type} commands...\nDirectory: ${interactionTypeDir}`
  );

  try {
    await fs.access(interactionTypeDir);
  } catch (e) {
    if (e instanceof Error && "code" in e && e.code === "ENOENT") {
      console.log(`No ${type} commands found.`);
      return {};
    } else throw e;
  }

  const files = (await fs.readdir(interactionTypeDir, { withFileTypes: true }))
    .map((file) =>
      file.isFile()
        ? file.name.endsWith(extension) && file.name
        : file.isDirectory() && file.name
    )
    .filter((file) => file) as string[];
  const interactions = await Promise.all(
    files.map((file) => getSingleInteraction(type, file))
  );

  const interactionsObj: Record<string, BackendInteractionType[TType]> = {};
  for (const interaction of interactions)
    interactionsObj[interaction.interaction.name] = interaction;

  return interactionsObj;
}

export async function getInteractionsOfType<
  TType extends keyof BackendInteractionType
>(type: TType): Promise<Record<string, BackendInteractionType[TType]>> {
  const interactionTypeDir = path.join(interactionsDir, type);
  console.log(
    `Processing ${type} commands...\nDirectory: ${interactionTypeDir}`
  );

  try {
    await fs.access(interactionTypeDir);
  } catch (e) {
    if (e instanceof Error && "code" in e && e.code === "ENOENT") {
      console.log(`No ${type} commands found.`);
      return {};
    } else throw e;
  }

  const files = (await fs.readdir(interactionTypeDir, { withFileTypes: true }))
    .map((file) =>
      file.isFile()
        ? file.name.endsWith(extension) && file.name
        : file.isDirectory() && file.name
    )
    .filter((file) => file) as string[];
  const interactions = await Promise.all(
    files.map((file) => getSingleInteraction(type, file))
  );

  const interactionsObj: Record<string, BackendInteractionType[TType]> = {};
  for (const interaction of interactions)
    interactionsObj[interaction.interaction.name] = interaction;

  return interactionsObj;
}

export async function getAllInteractions() {
  const [chat, user, message] = await Promise.all([
    getInteractionsOfType("chat"),
    getInteractionsOfType("user"),
    getInteractionsOfType("message"),
  ]);

  return { chat, user, message };
}

const thisFile = fileURLToPath(import.meta.url);
const interactionsDir = path.dirname(thisFile);
const extension = path.extname(thisFile);

export async function getAllInteractions() {
  const [chat, user, message] = await Promise.all([
    getInteractionsOfType("chat"),
    getInteractionsOfType("user"),
    getInteractionsOfType("message"),
  ]);

  return { chat, user, message };
}

const thisFile = fileURLToPath(import.meta.url);
const interactionsDir = path.dirname(thisFile);
const extension = path.extname(thisFile);

async function sendInteraction(interaction: Interaction) {
    const isChat = interaction.isChatInputCommand();
    const isUser = interaction.isUserContextMenuCommand();
    const isMessage = interaction.isMessageContextMenuCommand();

    const isCommand = isChat || isUser || isMessage;

    if (!isCommand) return; // Don't handle these types of interactions here

    const command = isChat    ? interactionsObj.chat[interaction.commandName]
                  : isUser    ? interactionsObj.user[interaction.commandName]
                  : isMessage ? interactionsObj.message[interaction.commandName]
                  :             null;
    try {
        if (command)
            await command.execute(interaction as any); // Cast to `any` here because TypeScript can't figure out the correct parameter type for `execute`
        else {
            console.warn(new Error("Unbound Interaction"), { interaction });
            await interaction[
                 interaction.deferred ? "editReply"
                : interaction.replied ? "followUp"
                :                       "reply"
            ]({
                content: `ERROR: Unbound interaction (we can't seem to find code to handle what you asked for!)`,
                ephemeral: true,
                files: [{
                    attachment: Buffer.from(stringifyJson(interaction, 4)),
                    name: "interaction.json",
                }],
            });
        }
    } catch (error) {
        await catchInteractionErrors(error, interaction);
    }
}

client.on("interactionCreate", sendInteraction);

async function sendInteraction(interaction: Interaction) {
    const isChat = interaction.isChatInputCommand();
    const isUser = interaction.isUserContextMenuCommand();
    const isMessage = interaction.isMessageContextMenuCommand();

    const isCommand = isChat || isUser || isMessage;

    if (!isCommand) return; // Don't handle these types of interactions here

    const command = isChat    ? interactionsObj.chat[interaction.commandName]
                  : isUser    ? interactionsObj.user[interaction.commandName]
                  : isMessage ? interactionsObj.message[interaction.commandName]
                  :             null;
    try {
        if (command)
            await command.execute(interaction as any); // Cast to `any` here because TypeScript can't figure out the correct parameter type for `execute`
        else {
            console.warn(new Error("Unbound Interaction"), { interaction });
            await interaction[
                 interaction.deferred ? "editReply"
                : interaction.replied ? "followUp"
                :                       "reply"
            ]({
                content: `ERROR: Unbound interaction (we can't seem to find code to handle what you asked for!)`,
                ephemeral: true,
                files: [{
                    attachment: Buffer.from(stringifyJson(interaction, 4)),
                    name: "interaction.json",
                }],
            });
        }
    } catch (error) {
        await catchInteractionErrors(error, interaction);
    }
}

client.on("interactionCreate", sendInteraction);

const interactionsObj = await interactions;
const interactionsToSet = await rawInteractions;

if (interactionsToSet.global)
    client.application?.commands.set(interactionsToSet.global);

if (interactionsToSet.guilds)
    for (const guild in interactionsToSet.guilds){
        console.log(`Setting guild ${guild} commands...`);
        client.guilds.fetch(guild)
            .then((g) =>   g.commands.set(interactionsToSet.guilds[guild]!)   )
            .catch((e) => console.error(`Error while setting guild ${guild} commands`, e));
    }

const interactionsObj = await interactions;
const interactionsToSet = await rawInteractions;

if (interactionsToSet.global)
    client.application?.commands.set(interactionsToSet.global);

if (interactionsToSet.guilds)
    for (const guild in interactionsToSet.guilds){
        console.log(`Setting guild ${guild} commands...`);
        client.guilds.fetch(guild)
            .then((g) =>   g.commands.set(interactionsToSet.guilds[guild]!)   )
            .catch((e) => console.error(`Error while setting guild ${guild} commands`, e));
    }

interaction: {
    type: ApplicationCommandOptionType.Subcommand,
    description: "Create a poll.",
    options: [
        {
            name: "question",
            description: "poll question",
            type: ApplicationCommandOptionType.String,
            required: true,
        },
//removed the other options for brevity
    ] as NonNullable<InteractionDefinition<ApplicationCommandSubCommandData, true>["interaction"]["options"]>,
},

interaction: {
    type: ApplicationCommandOptionType.Subcommand,
    description: "Create a poll.",
    options: [
        {
            name: "question",
            description: "poll question",
            type: ApplicationCommandOptionType.String,
            required: true,
        },
//removed the other options for brevity
    ] as NonNullable<InteractionDefinition<ApplicationCommandSubCommandData, true>["interaction"]["options"]>,
},