meocord 1.2.1 → 1.2.2

package/dist/esm/util/meocord-config-loader.util.js

@@ -0,0 +1,48 @@
+import path from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { createJiti } from 'jiti';
+import { fixJSON } from './json.util.js';
+
+/**
+ * Loads the MeoCord configuration file (meocord.config.ts) directly at runtime
+ * using jiti, without a separate compilation step.
+ *
+ * @returns {MeoCordConfig | undefined} The loaded configuration object, or undefined if loading fails.
+ */ function loadMeoCordConfig() {
+    const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
+    if (!existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        // Read user's tsconfig.json to extract path aliases for jiti
+        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+        const aliases = {};
+        if (existsSync(tsConfigPath)) {
+            const tsConfig = JSON.parse(fixJSON(readFileSync(tsConfigPath, 'utf-8')));
+            const paths = tsConfig?.compilerOptions?.paths;
+            if (paths) {
+                for (const [key, values] of Object.entries(paths)){
+                    // Convert TS path alias format "@src/*" -> ["./src/*"] to jiti alias format
+                    const aliasKey = key.replace('/*', '');
+                    const aliasValue = path.resolve(process.cwd(), values[0].replace('/*', ''));
+                    aliases[aliasKey] = aliasValue;
+                }
+            }
+        }
+        const jiti = createJiti(import.meta.url, {
+            interopDefault: true,
+            alias: aliases,
+            moduleCache: false
+        });
+        return jiti(configPath);
+    } catch (error) {
+        if (error instanceof Error) {
+            console.error(`[MeoCord] Failed to load config: ${error.message}`);
+        } else {
+            console.error(`[MeoCord] Failed to load config: Unknown error`);
+        }
+        return undefined;
+    }
+}
+
+export { loadMeoCordConfig };

package/dist/esm/util/tsconfig.util.js

@@ -0,0 +1,83 @@
+import path from 'path';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { tmpdir } from 'os';
+import { fixJSON } from './json.util.js';
+
+const logger = new Logger();
+/**
+ * Prepares and modifies the project's `tsconfig.json` file for usage with tools like Webpack.
+ * - Verifies the existence of `tsconfig.json`.
+ * - Fixes invalid JSON if necessary by correcting formatting issues like comments or trailing commas.
+ * - Updates paths in `compilerOptions` and other sections to absolute paths.
+ * - Removes the `noEmit` option if present in `compilerOptions`.
+ * - Writes the modified `tsconfig.json` to a temporary location.
+ *
+ * @returns {string} The absolute path to the generated temporary `tsconfig.json`.
+ * @throws {Error} When `tsconfig.json` is missing or cannot be fixed/parsing fails.
+ */ function prepareModifiedTsConfig() {
+    const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+    // Ensure tsconfig.json exists
+    if (!existsSync(tsConfigPath)) {
+        throw new Error(`tsconfig.json not found in: ${process.cwd()}`);
+    }
+    const tsConfigContent = readFileSync(tsConfigPath, 'utf-8');
+    let parsedConfig;
+    try {
+        parsedConfig = JSON.parse(tsConfigContent);
+    } catch (error) {
+        logger.warn('Invalid JSON detected in tsconfig.json!', error);
+        logger.log('Attempting to fix JSON...');
+        try {
+            const fixedContent = fixJSON(tsConfigContent);
+            parsedConfig = JSON.parse(fixedContent);
+            writeFileSync(tsConfigPath, fixedContent, 'utf-8');
+            logger.info('Fixed and updated tsconfig.json successfully.');
+        } catch (fixError) {
+            throw new Error(`Failed to parse tsconfig.json, even after attempting to fix: ${fixError instanceof Error ? fixError.message : fixError}`);
+        }
+    }
+    // Process compilerOptions
+    if (parsedConfig?.compilerOptions) {
+        const pathOptions = [
+            'outDir',
+            'rootDir',
+            'baseUrl',
+            'tsBuildInfoFile'
+        ];
+        // Convert relative paths to absolute paths in `compilerOptions`
+        pathOptions.forEach((option)=>{
+            if (parsedConfig.compilerOptions[option]) {
+                parsedConfig.compilerOptions[option] = path.resolve(process.cwd(), parsedConfig.compilerOptions[option]);
+            }
+        });
+        const additionalKeys = [
+            'include',
+            'exclude',
+            'typeRoots'
+        ];
+        // Convert relative paths to absolute paths in additional keys
+        additionalKeys.forEach((key)=>{
+            if (parsedConfig[key]) {
+                parsedConfig[key] = parsedConfig[key].map((p)=>path.resolve(process.cwd(), p));
+            }
+        });
+        // Resolve path mappings in `paths` if present
+        if (parsedConfig.compilerOptions.paths) {
+            Object.keys(parsedConfig.compilerOptions.paths).forEach((alias)=>{
+                parsedConfig.compilerOptions.paths[alias] = parsedConfig.compilerOptions.paths[alias].map((p)=>path.resolve(process.cwd(), p));
+            });
+        }
+        // Remove `noEmit` option if it exists
+        if ('noEmit' in parsedConfig.compilerOptions) {
+            delete parsedConfig.compilerOptions.noEmit;
+        }
+    }
+    // Write the modified configuration to a temporary location for usage
+    const tempTsConfigPath = path.resolve(path.join(tmpdir(), 'modified-tsconfig.json'));
+    writeFileSync(tempTsConfigPath, JSON.stringify(parsedConfig, null, 2));
+    return tempTsConfigPath;
+}
+
+export { prepareModifiedTsConfig };

package/dist/{util → esm/util}/wait.util.js

@@ -14,4 +14,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */export default function wait(a){return new Promise(function(b){return setTimeout(b,a)})}
+ */ function wait(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+
+export { wait as default };

package/dist/{common/logger.d.ts → types/common/index.d.ts}

@@ -1,3 +1,5 @@
+import { ColorResolvable } from 'discord.js';
+
 /**
  * MeoCord Framework
  * Copyright (C) 2025 Ukasyah Rahmatullah Zada
@@ -15,7 +17,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-export declare class Logger {
+declare class Logger {
     private context?;
     private readonly colorMap;
     constructor(context?: string | undefined);
@@ -28,3 +30,30 @@ export declare class Logger {
     private formatMessage;
     private logWithContext;
 }
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare class Theme {
+    static successColor: ColorResolvable;
+    static infoColor: ColorResolvable;
+    static errorColor: ColorResolvable;
+    static warningColor: ColorResolvable;
+}
+
+export { Logger, Theme };

package/dist/{core/meocord.app.d.ts → types/core/index.d.ts}

@@ -1,3 +1,6 @@
+import { ServiceIdentifier } from 'inversify';
+import { Client, ActivityOptions } from 'discord.js';
+
 /**
  * MeoCord Framework
  * Copyright (C) 2025 Ukasyah Rahmatullah Zada
@@ -15,8 +18,8 @@
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import { type ActivityOptions, Client } from 'discord.js';
-export declare class MeoCordApp {
+
+declare class MeoCordApp {
     private readonly controllers;
     private readonly discordClient;
     private discordToken;
@@ -34,3 +37,28 @@ export declare class MeoCordApp {
     private handleReaction;
     private gracefulShutdown;
 }
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare class MeoCordFactory {
+    private static logger;
+    static create(target: ServiceIdentifier): MeoCordApp;
+}
+
+export { MeoCordFactory };

package/dist/types/decorator/index.d.ts

@@ -0,0 +1,425 @@
+import { CommandType } from '../enum/index.js';
+import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, ModalSubmitInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
+import { ReactionHandlerOptions, GuardInterface } from '../interface/index.js';
+import { ServiceIdentifier, Container } from 'inversify';
+import 'webpack';
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * `@Service()` decorator to mark a class as a service that can be injected into controllers or used as standalone services.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * class MyService {
+ *   constructor(private anotherService: AnotherService) {}
+ *
+ *   doSomething() {
+ *     this.anotherService.alsoDoSomething()
+ *     console.log('Hello, World!')
+ *   }
+ * }
+ * ```
+ * @returns A decorator function to apply to the class.
+ */
+declare function Service<T>(): (target: new (...args: any[]) => T) => void;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Base interface for a command builder.
+ */
+interface CommandBuilderBase<T extends CommandType.SLASH | CommandType.CONTEXT_MENU = CommandType.SLASH | CommandType.CONTEXT_MENU> {
+    /**
+     * Builds the command structure using the specified command name.
+     *
+     * @param commandName - The name of the command.
+     * @returns A SlashCommandBuilder or ContextMenuCommandBuilder instance.
+     */
+    build: (commandName: string) => T extends CommandType.SLASH ? SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder : T extends CommandType.CONTEXT_MENU ? ContextMenuCommandBuilder : never;
+}
+type CommandBuilderConstructor<T extends CommandType.SLASH | CommandType.CONTEXT_MENU> = new () => CommandBuilderBase<T>;
+/**
+ * Command metadata describing a registered command method.
+ */
+interface CommandMetadata<T extends string = string> {
+    methodName: string;
+    builder: ReturnType<CommandBuilderBase['build']> | undefined;
+    type: CommandType;
+    regex?: RegExp;
+    dynamicParams?: T[];
+}
+type CommandInteractionType<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType> = T extends CommandType.BUTTON ? ButtonInteraction : T extends CommandType.SELECT_MENU ? StringSelectMenuInteraction : T extends CommandBuilderConstructor<CommandType.SLASH> ? ChatInputCommandInteraction : T extends CommandBuilderConstructor<CommandType.CONTEXT_MENU> ? UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction : T extends CommandType.MODAL_SUBMIT ? ModalSubmitInteraction : never;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * This decorator is used to mark a class as a Discord command builder that later can be registered on the `@Command` decorator.
+ * It defines the command type using metadata and dynamically makes the class injectable if it isn't already.
+ *
+ * @example
+ * ```typescript
+ * @CommandBuilder(CommandType.SLASH)
+ * export class MySlashCommand implements CommandBuilderBase {
+ *   build(commandName: string): SlashCommandBuilder {
+ *     return new SlashCommandBuilder().setName(commandName).setDescription('A sample slash command')
+ *   }
+ * }
+ *```
+ *
+ * @param commandType - The type of the command, specified from the `CommandType` enum.
+ * @returns A decorator function that makes the target class injectable
+ *          and assigns the `commandType` metadata.
+ */
+declare function CommandBuilder<T extends CommandType.SLASH | CommandType.CONTEXT_MENU>(commandType: T): (target: new () => CommandBuilderBase<T>) => void;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Decorator to register message handlers in the controller.
+ *
+ * @param keyword - An optional keyword to filter messages this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @MessageHandler('hello')
+ * async handleHelloMessage(message: Message) {
+ *   await message.reply('Hello! How can I help you?');
+ * }
+ *
+ * @MessageHandler()
+ * async handleAnyMessage(message: Message) {
+ *   console.log(`Received a message: ${message.content}`);
+ * }
+ * ```
+ */
+declare function MessageHandler<T extends OmitPartialGroupDMChannel<Message<boolean>>, R extends void | Promise<void>>(keyword?: string): (target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(message: T) => R>) => void;
+/**
+ * Decorator to register reaction handlers in the controller.
+ *
+ * @param emoji - Optional emoji name to filter reactions this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @ReactionHandler('👍')
+ * async handleThumbsUpReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with 👍`);
+ * }
+ *
+ * @ReactionHandler()
+ * async handleAnyReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with ${reaction.emoji.name}`);
+ * }
+ * ```
+ */
+declare function ReactionHandler<T extends MessageReaction | PartialMessageReaction, R extends void | Promise<void>>(emoji?: string): (target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(reaction: T, options: ReactionHandlerOptions) => R> | TypedPropertyDescriptor<(reaction: T) => R>) => void;
+/**
+ * Retrieves reaction handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of reaction handler metadata objects.
+ */
+declare function getReactionHandlers(controller: any): {
+    emoji: string | undefined;
+    method: string;
+}[];
+/**
+ * Retrieves message handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of message handler method names.
+ */
+declare function getMessageHandlers(controller: any): {
+    keyword: string | undefined;
+    method: string;
+}[];
+/**
+ * Decorator to register command methods in a controller.
+ *
+ * @param commandName - The name or pattern of the command.
+ * @param builderOrType - A command builder class or a command type from `CommandType`.
+ *
+ * @example
+ * ```typescript
+ * @Command('help', CommandType.SLASH)
+ * public async handleHelp(interaction: ChatInputCommandInteraction) {
+ *   await interaction.reply('This is the help command!')
+ * }
+ *
+ * @Command('stats-{id}', CommandType.BUTTON)
+ * public async handleStats(message: ButtonInteraction, { id }) {
+ *   await message.reply(`Fetching stats for ID: ${id}`);
+ * }
+ * ```
+ */
+declare function Command<CBC extends CommandType.SLASH | CommandType.CONTEXT_MENU, T extends CommandBuilderConstructor<CBC> | CommandType>(commandName: string, builderOrType: T): <P extends Record<string, any>, R extends Promise<void> | void>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>, params: P) => R> | TypedPropertyDescriptor<(interaction: CommandInteractionType<CBC, T>) => R>) => void;
+/**
+ * Retrieves the command map for a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns A record containing command metadata indexed by command names.
+ */
+declare function getCommandMap<T extends string>(controller: any): Record<string, CommandMetadata<T>[]>;
+/**
+ * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class PingSlashController {
+ *   constructor(private pingService: PingService) {}
+ *
+ *   @Command('ping', PingCommandBuilder)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     const response = await this.pingService.handlePing()
+ *     await interaction.reply(response)
+ *   }
+ * }
+ * ```
+ */
+declare function Controller(): (target: any) => void;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * `@Guard()` decorator to mark a class as a Guard that later can be added on `@UseGuard` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Guard()
+export class ButtonInteractionGuard implements GuardInterface {
+  private readonly logger = new Logger(ButtonInteractionGuard.name)
+
+  async canActivate(context: ButtonInteraction, { ownerId }: { ownerId: string }): Promise<boolean> {
+    if (context.user.id !== ownerId) {
+      this.logger.error(
+        `User with id ${context.user.id} is not allowed to use this command that initiated by user with id ${ownerId}.`,
+      )
+      const embed = generateErrorEmbed(
+        `Hi <@${context.user.id}>, this command can only be used by the person who initiated it: <@${ownerId}>.`,
+      )
+      await context.reply({
+        embeds: [embed],
+        flags: MessageFlagsBitField.Flags.Ephemeral,
+      })
+      return false
+    }
+    return true
+  }
+}
+ * ```
+ */
+declare function Guard(): (target: any) => void;
+/**
+ * Type for a guard with parameters.
+ * This type defines a guard that requires additional parameters (other than the default constructor).
+ */
+interface GuardWithParams {
+    /**
+     * The guard class that needs to be instantiated.
+     */
+    provide: new (...args: any[]) => GuardInterface;
+    /**
+     * Parameters to be passed to the guard during instantiation.
+     */
+    params: Record<string, any>;
+}
+/**
+ * `@UseGuard()` decorator to apply one or more guards to methods.
+ * Guards are used to handle permission checks before executing a method.
+ * Each guard must use `@Guard` decorator and implement the `canActivate` method, which determines
+ * whether the method should be allowed to execute based on the provided context (Interaction, Message, or Reaction) and arguments.
+ * This decorator ensures that all guards pass validation before calling the original method.
+ * Supports guards that are parameterized (accepting additional parameters).
+ *
+ * @param guards - One or more guard classes to apply. These can be regular guards or guards with additional parameters.
+ *                 - If providing a guard with parameters, it should be an object with:
+ *                   - `provide`: The guard class to instantiate. Must implement `GuardInterface`.
+ *                   - `params`: A record of key-value pairs to be passed as additional properties to the guard instance.
+ * @returns A method decorator function that applies the guards to the method.
+ *
+ * @example
+ * ```typescript
+ * // Method-level usage
+ * @Command('profile-{id}', CommandType.BUTTON)
+ * @UseGuard(
+ *   { provide: RateLimiterGuard, params: { limit: 2, window: 3000 } },
+ *   ButtonInteractionGuard
+ * )
+ * async showProfileById(interaction: ButtonInteraction, { id }: { id: string }) {
+ *   await interaction.reply(`Profile ID: ${id}`)
+ * }
+ *
+ * // Class-level usage
+ * @Controller()
+ * @UseGuard(GlobalGuard)
+ * class MyController {
+ *   @Command('ping', CommandType.SLASH)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     await interaction.reply('Pong!')
+ *   }
+ * }
+ * ```
+ */
+declare function UseGuard(...guards: ((new (...args: any[]) => GuardInterface) | GuardWithParams)[]): any;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * `@MeoCord()` decorator for initializing and setting up the MeoCord application.
+ *
+ * @param {Object} options - The decorator options.
+ * @param {ServiceIdentifier[]} options.controllers - The list of controllers to be registered.
+ * @param {ClientOptions} options.clientOptions - The Discord client options for initializing the bot.
+ * @param {ActivityOptions[]} [options.activities] - Optional activities for the bot.
+ * @param {ServiceIdentifier[]} [options.services] - Optional services to be registered.
+ *
+ * @example
+ * ```typescript
+ * @MeoCord({
+ *   controllers: [PingSlashController],
+ *   clientOptions: {
+ *     intents: [
+ *       GatewayIntentBits.Guilds,
+ *       GatewayIntentBits.GuildMembers,
+ *       GatewayIntentBits.GuildMessages,
+ *       GatewayIntentBits.GuildMessageReactions,
+ *       GatewayIntentBits.MessageContent,
+ *     ],
+ *     partials: [Partials.Message, Partials.Channel, Partials.Reaction],
+ *   },
+ *   activities: [{
+ *       name: `${sample(['Genshin', 'ZZZ'])} with Romeo`,
+ *       type: ActivityType.Playing,
+ *       url: 'https://enka.network/u/824957678/',
+ *   }],
+ *   services: [MyStandaloneService],
+ * })
+ * class MyApp {}
+ * ```
+ **/
+declare function MeoCord(options: {
+    controllers: ServiceIdentifier[];
+    clientOptions: ClientOptions;
+    activities?: ActivityOptions[];
+    services?: ServiceIdentifier[];
+}): (target: any) => void;
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare const mainContainer: Container;
+
+export { Command, CommandBuilder, Controller, Guard, MeoCord, MessageHandler, ReactionHandler, Service, UseGuard, getCommandMap, getMessageHandlers, getReactionHandlers, mainContainer };

package/dist/types/enum/index.d.ts

@@ -0,0 +1,18 @@
+declare enum CommandType {
+    SLASH = "SLASH",
+    BUTTON = "BUTTON",
+    CONTEXT_MENU = "CONTEXT_MENU",
+    SELECT_MENU = "SELECT_MENU",
+    MODAL_SUBMIT = "MODAL_SUBMIT"
+}
+/**
+ * Enum representing actions that can be performed on a message reaction.
+ */
+declare enum ReactionHandlerAction {
+    /** Reaction added to a message. */
+    ADD = "ADD",
+    /** Reaction removed from a message. */
+    REMOVE = "REMOVE"
+}
+
+export { CommandType, ReactionHandlerAction };