DISCORD_TOKEN=your_discord_bot_token
MONGO_STRING=your_mongodb_connection_string
DATABASE_NAME=your_database_name
DEVELOPER_ID=your_discord_user_id
NODE_ENV=development | production

yarn install

yarn build

// For development
yarn dev

// For production
yarn start

import { SlashCommandBuilder, ChatInputCommandInteraction } from 'discord.js';
import { Command } from '../../../interfaces';
import { logger } from '../../util':

const command: Command = {
    data: new SlashCommandBuilder()
        .setName('test')
        .setDescription('Test command')
        .setDefaultMemberPermissions(0), // Can only be used in a server
    async execute(interaction: ChatInputCommandInteraction) {
        return await interaction.reply('Test command executed!');
    }
};

module.exports = command;

import { ActionRowBuilder, ButtonBuilder, ChatInputCommandInteraction, SlashCommandSubcommandBuilder } from 'discord.js';
import { buttons } from '../../../components';
import { Command } from '../../../interfaces';

const command: Command = {
    parent: 'test',
    data: new SlashCommandSubcommandBuilder()
        .setName('button')
        .setDescription('Test button'),
    async execute(interaction: ChatInputCommandInteraction, client) {
        // Return if the interaction wasn't used in a guild.
        if (!interaction.guild) {
            return await interaction.reply({ content: 'This command can only be used in a server.', ephemeral: true });
        }

        const row = new ActionRowBuilder<ButtonBuilder>().addComponents(await buttons.TestButton.build(client));

        return await interaction.reply({ content: 'Test Button', components: [row] });
    }
};

module.exports = command;

import { MessageBuilder } from '../../interfaces';
import { Client } from '../../interfaces/Client';

export const WelcomeMessage: MessageBuilder = {
    embeds: [], // Array of embeds to include
    components: [], // Array of action rows with components
    
    // Build function that returns the final message options
    async build(client: Client, username: string) {
        return {
            embeds: [
                {
                    title: `Welcome ${username}!`,
                    description: 'Thanks for joining our server!',
                    color: 0x00ff00
                }
            ],
            components: [
                // Add your components here
            ]
        };
    }
};

import { WelcomeMessage } from '../../messages';

// In your command
const message = await WelcomeMessage.build(client, interaction.user.username);
await interaction.reply(message);

{
    id: string; // Unique ID for this component. (EX: 'role-selector')
    permissions?: bigint[]; // Permission Bits required to interact with this component
    multi_select?: boolean; // [SELECT MENU ONLY] Toggle Multi Select
    developer?: boolean; // Developer only
    execute(
        interaction: ComponentInteraction, // Interaction object
        client: Client, // Bot client
        data?: { [key: string]: any }, // Any data parsed from the components unique ID
        guild?: discord.Guild, // Guild the component is in
        response?: discord.Collection<string, discord.TextInputComponent>, // [MODAL ONLY] Values entered into Text Inputs
        selected?: discord.APISelectMenuOption | discord.APISelectMenuOption[] // [SELECT MENU ONLY] Menu items selected
    ): void;
    build(client: Client, ...args: any): Promise<discord.ComponentBuilder>; // Any code and arguments needed to build the component.
}

import { ButtonBuilder, ButtonStyle, PermissionFlagsBits } from 'discord.js';
import { ButtonComponent  } from '../../interfaces/MessageComponent';

// Example button component that requires certain permissions to use
export const MessageComponent: ButtonComponent = {
    id: 'test-button',
    type: ComponentTypes.Button,
    // User needs ManageEvents and ManageRoles permissions
    permissions: [PermissionFlagsBits.ManageEvents, PermissionFlagsBits.ManageRoles],
    
    async build(client, boolean) {
        return new ButtonBuilder()
            .setCustomId(await client.getCustomID('test-button', testJSON))
            .setLabel('Test Button')
            .setStyle(ButtonStyle.Primary);
    },

    // Handles the button click
    execute(
        interaction,
        _client
    ) {
        interaction.reply({
            content: `You pressed the test button!`,
            ephemeral: true
        });
    }
};

export default MessageComponent;

const modal_data = {
    type:    "modal",
    id:      "mod_history",
    userId:  "123456789012345678",
    page:    2,
    filters: {
        sort:     "recent", 
        category: "moderation",
        tags:     ["bans", "kicks", "mutes"],
        priority: "high",
        resolved: false
    },
};

const button_id = await client.getCustomID('open-history', modal_data);
 //console.log(button_id) => open-history[ᯡࠫ䅜Ā匰ᜨאỠጢణㄠ㑀আ䆅栯倢恠材⠤炯ࠢ巉你䦃ࠨ怩䀹䀥䀵䀭䀽䀣䀳䀡䁄≬獈డ暑爛瀣ᠲ挡浡ᑕ͐ጔ〣ಀǹ々壬㇁䧂⩔ຎѰ໬ね⧜;∠ɐ恚丐öɻʜ㤥䲊〥氁∈ș䠲ᔦ䊹䎁㋠ǘ悘竸瘠⿃⠠]

import { StringSelectMenuBuilder } from 'discord.js';
import { SelectMenuComponent } from '../../interfaces';

export const TestSelect: SelectMenuComponent = {
    customId: 'test-select',
    multi_select: false,
    build: async (client) => {
        return new StringSelectMenuBuilder()
            .setCustomId('test-select')
            .setPlaceholder('Select an option')
            .addOptions([
                { label: 'Option 1', value: '1' },
                { label: 'Option 2', value: '2' }
            ]);
    },
    execute: async (interaction, _client, selected) => {
        // Reply to the interaction with the selected option's label
        interaction.reply({ content: `You selected ${selected.label}`, ephemeral: true });
    }
};

import { ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle } from 'discord.js';
import { ModalComponent, ComponentTypes } from '../../interfaces/MessageComponent';
import { logger } from '../../util';

export const MessageComponent: ModalComponent = {
    id: 'test-modal',
    async build(_client) {
        const row = new ActionRowBuilder<TextInputBuilder>().addComponents(
            new TextInputBuilder().setCustomId('test-modal-input').setPlaceholder('Test Input').setStyle(TextInputStyle.Short).setLabel('Test Input')
        );
        return new ModalBuilder().setTitle('Test Modal').setCustomId('test-modal').setComponents([row]);
    },

    async execute(interaction, _client, fields) {
        logger.info(
            '\n' + new (require('ascii-table'))().setHeading('Field', 'Response').addRow('test-modal-input', fields.get('test-modal-input')?.value).toString()
        );

        // Reply to the interaction with the response.
        interaction.reply({ content: `This is a test modal! You said: ${fields.get('test-modal-input')?.value}`, ephemeral: true });
    }
};

export default MessageComponent;

import { TestButton } from './buttons/TestButton';
import { TestSelect } from './selectMenus/TestSelect';
import { TestModal } from './modals/TestModal';

export const components = {
    buttons: {
        TestButton
    },
    selectMenus: {
        TestSelect
    },
    modals: {
        TestModal
    }
};

import buttons from '../components/';

const row = new ActionRowBuilder().addComponents(button);

const message = {
    components: [row]
}

import mongoose from 'mongoose';

// TypeScript interface for MongoDB documents - includes all fields and Mongoose methods
export interface ExampleModel extends mongoose.Document {
    document_id: number;
    string: string;
    number: number;
    boolean: boolean;
    object: ExampleObject;
}

// Example interface for nested object structure.
export interface ExampleObject {
    string: string;
    number: number;
    boolean: boolean;
}

// Mongoose schema defines document structure and validation rules. Note this does not use traditional typings, thus the need to be manually outlined.
const ExampleSchema = new mongoose.Schema({
    document_id: Number,
    string: String,
    number: Number,
    boolean: Boolean,
    object: {
        string: String,
        number: Number,
        boolean: Boolean
    }
});

// Creates Mongoose model with TypeScript type safety
export const ExampleModel = mongoose.model<ExampleModel>('ExampleSchema', ExampleSchema);

import mongoose from 'mongoose';
import { config } from '../config';
import { ExampleModel } from './schemas/Example'; // Imported Model

...

export const example: Model = {
    // Function used to retrieve documents, and create a new one if it is not found.
    get: async (document_id: string) =>
        (await ExampleModel.findOne({ document_id: document_id })) ||
        (await ExampleModel.create({
            document_id: document_id
            // Add any default values here
        })),
    update: async(document_id: string, data: ExampleModel) {
        await GuildSettings.updateOne({ document_id: document_id }, settings);
    }
    model: ExampleModel
};

export const database = {
    modReports,
    userProfiles,
    example
    // Add models here
};

### Events
Events are handled in the `events/` directory. Each event is a TypeScript module that exports an event object.

Example event structure:
```typescript
import { Event } from '../../interfaces';

export const event: Event = {
    name: 'eventName',
    once: true,
    execute: async (client) => {
        // Event handling logic
    }
};

import { logger } from '../util';

logger.info('Your log message');
logger.error('Error message');
logger.warn('Warning message');
logger.debug('Debug message');