npm init
npm install discord.js
npm install typescript
npm install @types/node
npm install ts-node --save-dev
npx tsc --init

npm install dotenv
npm install mysql2

DISCCORD_BOT_TOKEN=<YOUR_TOKEN>
CLIENT_ID=<YOUR_ID>
GUILD_ID=<YOUR_ID>

declare module 'process' {
    global {
      namespace NodeJS {
        interface ProcessEnv {
          DISCORD_BOT_TOKEN: string;
          CLIENT_ID: string;
          GUILD_ID: string;
        }
      }
    }
  }

"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "compile": "tsc -p .",
    "start": "node build/index.js",
    "deploy": "npm run compile && node build/deploy-commands.js",
    "all": "npm run compile && npm run deploy && npm run start"
  },

"outDir": "./build",

import * as fs from "node:fs";
import * as path from "node:path";
import { 
	ActivityType,
    Client,
    Collection,
    Events, 
    GatewayIntentBits,
} from "discord.js";
import type { CommandInteraction } from "discord.js";
import "dotenv/config";

const client: Client = new Client({intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
]});

// clientがreadyのときに一度だけ実行
client.once(Events.ClientReady, c =>{
    console.log(`Ready! Logged in as ${c.user.tag}`);
});

client.login(process.env.DISCORD_BOT_TOKEN);

client.on("ready", ()=>{
	console.log("ready...");
	client.user?.setActivity("my life", { type: ActivityType.Playing });
})

import { SlashCommandBuilder } from "discord.js";
import type { CommandInteraction } from "discord.js";

export const data = new SlashCommandBuilder()
    .setName("ping")
    .setDescription("Replies with Pong!")

export async function execute(interaction: CommandInteraction){
    await interaction.reply({content:"Pong!", ephemeral:true});
}

import { REST, Routes } from 'discord.js';
import "dotenv/config";
import * as fs from "node:fs";
import * as path from "node:path";


const commands: string[] = [];
// Grab all the command folders from the commands directory you created earlier
const foldersPath = path.join(__dirname, 'commands');
const commandFolders = fs.readdirSync(foldersPath);

for (const folder of commandFolders) {
	// Grab all the command files from the commands directory you created earlier
	const commandsPath = path.join(foldersPath, folder);
	const commandFiles = fs.readdirSync(commandsPath).filter((file) => file.endsWith('.js'));
	// Grab the SlashCommandBuilder#toJSON() output of each command's data for deployment
	for (const file of commandFiles) {
		const filePath = path.join(commandsPath, file);
		const command = require(filePath);
		if ('data' in command && 'execute' in command) {
			commands.push(command.data.toJSON());
		} else {
			console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
		}
	}
}

// Construct and prepare an instance of the REST module
const rest = new REST().setToken(process.env.DISCORD_BOT_TOKEN);

// and deploy your commands!
(async () => {
	try {
		console.log(`Started refreshing ${commands.length} application (/) commands.`);

		// The put method is used to fully refresh all commands in the guild with the current set
		const data = await rest.put(
			Routes.applicationGuildCommands(process.env.CLIENT_ID, process.env.GUILD_ID),
			{ body: commands },
		);

		console.log(`Successfully reloaded ${commands.length} application (/) commands.`);
	} catch (error) {
		// And of course, make sure you catch and log any errors!
		console.error(error);
	}
})();

import "dotenv/config";

process.env.DISCORD_BOT_TOKEN

const commands: string[] = [];

npm run deploy

client.commands = new Collection();

import { Client } from "discord.js";
import type { Collection } from "discord.js";

declare module "discord.js" {
    interface Client {
        commands: Collection<
            string,
            (interaction : CommandInteraction) => Promise<void>
        >;
    }
}

client.commands = new Collection<
	string,
	(interaction: CommandInteraction) => Promise<void>
>();

const foldersPath = path.join(__dirname, 'commands');
const commandFolders = fs.readdirSync(foldersPath);

for(const folder of commandFolders){ // folders に関するループ
	const commandPath = path.join(foldersPath, folder);
	const commandFiles = fs.readdirSync(commandPath).filter(file => file.endsWith(".js"));
	for(const file of commandFiles){ // files に関するループ
		const filePath = path.join(commandPath, file);
		(async () => {
			const command = await import(filePath);

			// Set a new item in the Collection with the key as the command name and the value as the exported module
			// 取ってきたファイルからdataとexecuteがエクスポートされていればコレクションに追加
			if("data" in command && "execute" in command){
				client.commands.set(command.data.name, command.execute);
			}else{
				console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
			}
		})();
	}	
}

client.on(Events.InteractionCreate, async (interaction) => {
	if (!interaction.isChatInputCommand()) {
	  return;
	}
  
	const command = interaction.client.commands.get(interaction.commandName);
  
	if (!command) {
	  console.error(`No command matching ${interaction.commandName} was found.`);
	  return;
	}
  
	try {
	  await command(interaction);
	} catch (error) {
	  console.error(error);
  
	  if (interaction.replied || interaction.deferred) {
		await interaction.followUp({
		  content: "There was an error while executing this command!",
		  ephemeral: true,
		});
	  } else {
		await interaction.reply({
		  content: "There was an error while executing this command!",
		  ephemeral: true,
		});
	  }
	}
});

npm run compile

npm run deploy

npm run start

ready...

/ping

Pong!

modalSubmitInteraction.fields.getTextInputValue("eventTitleInput")

export async function execute(commandInteraction: CommandInteraction){
    const modal = new ModalBuilder()
        .setTitle("Event")
        .setCustomId("event")

    const eventTitleInput = new TextInputBuilder()
        .setCustomId("eventTitleInput")
        .setLabel("Event title")
        .setRequired(true)
        .setStyle(TextInputStyle.Short)

    const eventDeadlineInput = new TextInputBuilder()
        .setCustomId("eventDeadlineInput")
        .setLabel("Event deadline")
        .setRequired(true)
        .setStyle(TextInputStyle.Short)

    const eventTitleActionRow = new ActionRowBuilder<ModalActionRowComponentBuilder>().addComponents(eventTitleInput);
    const eventDeadlineActionRow = new ActionRowBuilder<ModalActionRowComponentBuilder>().addComponents(eventDeadlineInput);

    modal.addComponents(eventTitleActionRow, eventDeadlineActionRow);

    await commandInteraction.showModal(modal);

    commandInteraction.awaitModalSubmit({time: 60_000})
        .then(modalSubmitInteraction => {
            registerEvents(commandInteraction, modalSubmitInteraction);
            modalSubmitInteraction.reply({
            content: `Event title: ${modalSubmitInteraction.fields.getTextInputValue("eventTitleInput")}, Event deadline: ${modalSubmitInteraction.fields.getTextInputValue("eventDeadlineInput")}`,
            ephemeral:true
            });
        })
        .catch(err => console.log('No modal submit interaction was collected'));

}