@guardbot/framework 1.1.3 → 2.0.0

package/build/index.d.ts

@@ -1,30 +1,33 @@
 import * as discord_js from 'discord.js';
-import { Client, PermissionResolvable, InteractionContextType, ApplicationIntegrationType, LocalizationMap, ApplicationCommandOptionData, ToAPIApplicationCommandOptions, ChatInputCommandInteraction, AutocompleteInteraction, Message, ContextMenuCommandInteraction, CommandInteraction, PermissionsString, Interaction, Collection, ClientEvents, ModalSubmitInteraction, ClientOptions, MessageCollectorOptions, InteractionCollectorOptions } from 'discord.js';
+import { PermissionResolvable, LocalizationMap, APIApplicationCommandOption, SlashCommandOptionsOnlyBuilder, Message, CommandInteraction, PermissionsString, ChatInputCommandInteraction, AutocompleteInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, ClientEvents, Collection, ModalSubmitInteraction, MessageCollectorOptions, InteractionCollectorOptions, ClientOptions, Client } from 'discord.js';
 export { SlashCommandAttachmentOption as AttachmentOption, SlashCommandBooleanOption as BooleanOption, SlashCommandChannelOption as ChannelOption, SlashCommandIntegerOption as IntegerOption, SlashCommandMentionableOption as MentionableOption, SlashCommandNumberOption as NumberOption, SlashCommandRoleOption as RoleOption, SlashCommandStringOption as StringOption, SlashCommandSubcommandBuilder as SubcommandBuilder, SlashCommandSubcommandGroupBuilder as SubcommandGroupBuilder, SlashCommandUserOption as UserOption } from 'discord.js';
 import EventEmitter from 'events';
 
-declare class FrameworkClient<Ready extends boolean = boolean> extends Client<Ready> {
-    rootDir: string;
-    prefix: string;
-    developers: string[];
-    constructor(frameworkOptions: FrameworkClientOptions);
-    start(token: string): Promise<void>;
-}
-
+declare const CommandTypes: readonly ["Slash", "Message", "ContextMessage", "ContextUser"];
+declare const CommandContexts: readonly ["Guild", "BotDM", "PrivateChannel", 0, 1, 2];
+declare const IntegrationTypes: readonly ["GuildInstall", "UserInstall", 0, 1];
+declare const CommandScopes: readonly ["default", "guild", "global"];
+declare const MessageCommandContexts: readonly ["Guild", "BotDM"];
+type CommandType = typeof CommandTypes[number];
+type CommandContext = typeof CommandContexts[number];
+type IntegrationType = typeof IntegrationTypes[number];
+type CommandScope = typeof CommandScopes[number];
+type Result$2 = unknown | void;
+type MessageCommandContext = typeof MessageCommandContexts[number];
 interface BaseCommandOptions {
     /** The Name of the Command */
     name: string;
     /** The Description of the Command */
     description: string;
     /** The Type of the Command */
-    commandType: 'Slash' | 'Message' | 'ContextMessage' | 'ContextUser';
+    commandType: CommandType;
     /** The Cooldown of the Command (in MS) */
     cooldown?: number;
     /** Permissions required by the User to use this Command */
     memberPermissions?: PermissionResolvable;
     /** Permissions required by the Application Client to execute this Command */
     clientPermissions?: PermissionResolvable;
-    /** Whether this command is Disbaled */
+    /** Whether this command is Disabled */
     disabled?: boolean;
 }
 interface BaseAppCommandOptions extends BaseCommandOptions {
@@ -34,26 +37,27 @@ interface BaseAppCommandOptions extends BaseCommandOptions {
      * - `guild` - In only Guild Commands
      * - `global` - In only Global Commands
      */
-    commandScope: 'default' | 'guild' | 'global';
+    commandScope: CommandScope;
     /**
      * Where this Application Command can be used
      * - `Guild` | `(0)` - In Guilds
      * - `BotDM` | `(1)` - In Application DMs
      * - `PrivateChannel` | `(2)` - In Other's DMs & Group DMs
      */
-    commandContexts?: (InteractionContextType | keyof typeof InteractionContextType)[];
+    commandContexts?: CommandContext[];
     /**
      * Where this Application Command can be integrated
      * - `GuildInstall` | `(0)` - App is installable to servers
      * - `UserInstall` | `(1)` - App is installable to users
      */
-    integrationTypes?: (ApplicationIntegrationType | keyof typeof ApplicationIntegrationType)[];
+    integrationTypes?: IntegrationType[];
     /** The Name Localizations of the Command */
     nameLocalizations?: LocalizationMap;
     /** The Description Localizations of the Command */
     descriptionLocalizations?: LocalizationMap;
 }
-interface MessageCommandOptions$1 extends BaseCommandOptions {
+type InferMessage<C> = (C extends MessageCommandContext[] ? 'Guild' extends C[number] ? 'BotDM' extends C[number] ? Message<boolean> : Message<true> : Message<false> : Message<boolean>);
+interface MessageCommandOptions$1<C extends MessageCommandContext[] | undefined = ['Guild']> extends BaseCommandOptions {
     commandType: 'Message';
     /** The Aliases of the Command */
     aliases?: string[];
@@ -62,53 +66,110 @@ interface MessageCommandOptions$1 extends BaseCommandOptions {
     /** Whether the command is Developer Only */
     devOnly?: boolean;
     /**
-     * Where this Application Command can be used
+     * Where this Message Command can be used
      * - `BotDM` - In Application DMs
      * - `Guild` - In Guilds
      */
-    contexts?: ('BotDM' | 'Guild')[];
-    execute: (client: FrameworkClient<true>, message: Message, args: string[]) => Promise<unknown>;
+    contexts?: C;
+    execute: (client: FrameworkClient<true>, message: InferMessage<C>, args: string[]) => Promise<Result$2> | Result$2;
 }
+type SlashOptionsInput = (APIApplicationCommandOption[] | {
+    toJSON(): APIApplicationCommandOption;
+}[] | ((builder: SlashCommandOptionsOnlyBuilder) => SlashCommandOptionsOnlyBuilder));
 interface SlashCommandOptions$1 extends BaseAppCommandOptions {
     commandType: 'Slash';
     /** The Application Command Options of this Command */
-    options?: (ApplicationCommandOptionData | ToAPIApplicationCommandOptions)[];
-    execute: (client: FrameworkClient<true>, interaction: ChatInputCommandInteraction) => Promise<unknown>;
-    autocomplete?: (client: FrameworkClient<true>, interaction: AutocompleteInteraction) => Promise<unknown>;
+    options?: SlashOptionsInput;
+    execute: (client: FrameworkClient<true>, interaction: ChatInputCommandInteraction<'cached'>) => Promise<Result$2> | Result$2;
+    autocomplete?: (client: FrameworkClient<true>, interaction: AutocompleteInteraction<'cached'>) => Promise<Result$2> | Result$2;
 }
-interface ContextCommandOptions extends BaseAppCommandOptions {
-    commandType: 'ContextMessage' | 'ContextUser';
-    execute: (client: FrameworkClient<true>, interaction: ContextMenuCommandInteraction) => Promise<unknown>;
+interface ContextMessageCommandOptions extends Omit<BaseAppCommandOptions, 'description'> {
+    commandType: 'ContextMessage';
+    /** The Description of the Command */
+    description?: string;
+    execute: (client: FrameworkClient<true>, interaction: MessageContextMenuCommandInteraction<'cached'>) => Promise<Result$2> | Result$2;
 }
-interface BaseCommand {
+interface ContextUserCommandOptions extends Omit<BaseAppCommandOptions, 'description'> {
+    commandType: 'ContextUser';
+    /** The Description of the Command */
+    description?: string;
+    execute: (client: FrameworkClient<true>, interaction: UserContextMenuCommandInteraction<'cached'>) => Promise<Result$2> | Result$2;
+}
+type ContextCommandOptions = (ContextMessageCommandOptions | ContextUserCommandOptions);
+interface BaseCommandMeta {
     id: string;
     filepath: string;
     disabled: boolean;
 }
-type FrameworkSlashCommand = SlashCommandOptions$1 & BaseCommand;
-type FrameworkContextCommand = ContextCommandOptions & BaseCommand;
-type FrameworkMessageCommand = MessageCommandOptions$1 & BaseCommand & {
+type FrameworkSlashCommand = SlashCommandOptions$1 & BaseCommandMeta & {
+    options: APIApplicationCommandOption[];
+};
+type FrameworkMessageCommand = MessageCommandOptions$1 & BaseCommandMeta & {
     devOnly: boolean;
-    contexts: ('BotDM' | 'Guild')[];
+    contexts: MessageCommandContext[];
 };
+type FrameworkContextCommand = ContextCommandOptions & BaseCommandMeta;
 type FrameworkCommand = (FrameworkSlashCommand | FrameworkMessageCommand | FrameworkContextCommand);
-interface CommandModuleHandler {
+type CommandMiddleware = (context: Message | CommandInteraction, command: FrameworkCommand) => Promise<boolean> | boolean;
+interface CommandCustomHandlers {
     onCooldown?: (context: Message | CommandInteraction, command: FrameworkCommand, expirationTime: Date) => any;
     onMemberPermissions?: (context: Message, command: FrameworkCommand, missingPermissions: PermissionsString[]) => any;
     onClientPermissions?: (context: Message | CommandInteraction, command: FrameworkCommand, missingPermissions: PermissionsString[]) => any;
-    MessageCommandInterceptor?: (message: Message) => Promise<boolean>;
-    InteractionCommandInterceptor?: (interaction: Interaction) => Promise<boolean>;
 }
-type CommandHandlerName = keyof Omit<CommandModuleHandler, 'MessageCommandInterceptor' | 'InteractionCommandInterceptor'>;
+
+type Result$1 = unknown | void;
+interface ListenerOptions<T extends keyof ClientEvents = keyof ClientEvents> {
+    /** Name of the Listener */
+    name: T;
+    /** Whether to execute only once */
+    once?: boolean;
+    /** Whether the Listener is disabled */
+    disabled?: boolean;
+    /** Handles the execution of the Listener */
+    execute: (...args: ClientEvents[T]) => Promise<Result$1> | Result$1;
+}
+interface BaseListenerMeta {
+    id: string;
+    filepath: string;
+}
+interface FrameworkListener<T extends keyof ClientEvents = keyof ClientEvents> extends BaseListenerMeta {
+    name: T;
+    once: boolean;
+    disabled: boolean;
+    execute: (...args: ClientEvents[T]) => Promise<Result$1> | Result$1;
+    _execute?: (...args: ClientEvents[T]) => Promise<Result$1> | Result$1;
+}
+
+type Result = unknown | void;
+interface AutocompleterOptions {
+    /** Name of the Autocompleter */
+    name: string;
+    /** Whether the Autocompleter is disabled */
+    disabled?: boolean;
+    /** Command Names the Autocompleter applies to */
+    commands?: string[];
+    /** Handle the execution of the Autocompleter */
+    execute: (client: FrameworkClient<true>, interaction: AutocompleteInteraction<'cached'>, command: FrameworkSlashCommand, value: string) => Promise<Result> | Result;
+}
+interface BaseAutocompleterMeta {
+    id: string;
+    filepath: string;
+}
+interface FrameworkAutocompleter extends BaseAutocompleterMeta {
+    name: string;
+    disabled: boolean;
+    commands?: string[];
+    execute: (client: FrameworkClient<true>, interaction: AutocompleteInteraction<'cached'>, command: FrameworkSlashCommand, value: string) => Promise<Result> | Result;
+}
 
 /**
- * @class AutocompleteModule
- * @fires AutocompleteModule#execute
- * @fires AutocompleteModule#success
- * @fires AutocompleteModule#error
- * @fires AutocompleteModule#unknown
+ * @class AutocompletersModule
+ * @fires AutocompletersModule#execute
+ * @fires AutocompletersModule#success
+ * @fires AutocompletersModule#error
+ * @fires AutocompletersModule#unknown
  */
-declare class AutocompleteModule extends EventEmitter {
+declare class AutocompletersModule extends EventEmitter {
     private client;
     constructor(client: FrameworkClient);
     load(filepath: string, reload?: boolean): Promise<boolean>;
@@ -136,11 +197,12 @@ declare class ListenerModule {
  */
 declare class CommandsModule extends EventEmitter {
     private client;
-    private handler;
+    private handlers;
+    private middleware?;
+    private prefixRegex?;
     constructor(client: FrameworkClient);
-    setHandler<K extends CommandHandlerName>(key: K, callback: NonNullable<CommandModuleHandler[K]>): NonNullable<CommandModuleHandler[K]>;
-    setMessageInterceptor(callback: (message: Message) => Promise<boolean>): (message: Message) => Promise<boolean>;
-    setInteractionInterceptor(callback: (interaction: Interaction) => Promise<boolean>): (interaction: Interaction) => Promise<boolean>;
+    setHandler<K extends keyof CommandCustomHandlers>(key: K, callback: NonNullable<CommandCustomHandlers[K]>): boolean;
+    setMiddleware(callback: CommandMiddleware): boolean;
     load(filepath: string, reload?: boolean): Promise<boolean>;
     loadAll(): Promise<void>;
     reload(id: string): Promise<void>;
@@ -156,54 +218,10 @@ declare class CommandsModule extends EventEmitter {
     private _getCommandData;
 }
 
-interface ListenerOptions<T extends keyof ClientEvents = keyof ClientEvents> {
-    /** Name of the Listener. */
-    name: T;
-    /** Wheather to execute the function only Once. */
-    once?: boolean;
-    /** Whether the Listener is disabled. */
-    disabled?: boolean;
-    /** Handles the execution of the Listener */
-    execute: (...args: ClientEvents[T]) => Promise<boolean>;
-}
-interface FrameworkListener<T extends keyof ClientEvents = keyof ClientEvents> {
-    id: string;
-    filepath: string;
-    name: T;
-    once: boolean;
-    disabled: boolean;
-    execute: (...args: ClientEvents[T]) => Promise<boolean>;
-    _execute?: (...args: ClientEvents[T]) => Promise<boolean>;
-}
-
-interface FrameworkClientOptions {
-    clientOptions: ClientOptions;
-    rootDir?: string;
-    developers?: string[];
-    prefix?: string;
-    registerOnStart?: boolean;
-    guildsToRegister?: string[];
-}
-interface AutocompleterOptions {
-    /** Name of the Autocompleter. */
-    name: string;
-    /** Whether the Autocompleter is disabled. */
-    disabled?: boolean;
-    /** Handle the execution of the Autocompleter. */
-    execute: (client: FrameworkClient<true>, interaction: AutocompleteInteraction, command: FrameworkSlashCommand, value: string) => Promise<unknown>;
-}
-interface FrameworkAutocompleter {
-    id: string;
-    filepath: string;
-    name: string;
-    disabled: boolean;
-    execute: (client: FrameworkClient<true>, interaction: AutocompleteInteraction, command: FrameworkSlashCommand, value: string) => Promise<unknown>;
-}
 type ModalCollectorOptions = InteractionCollectorOptions<ModalSubmitInteraction>;
 interface AwaitMemberResponseOptions extends MessageCollectorOptions {
     deleteMessage?: boolean;
 }
-
 declare module 'discord.js' {
     interface ClientEvents {
         buttonInteraction: [interaction: ButtonInteraction];
@@ -212,15 +230,15 @@ declare module 'discord.js' {
     }
     interface Client {
         prefix: string;
-        developers: string[];
-        autocomplete: Collection<string, FrameworkAutocompleter>;
+        developers: readonly string[];
         aliases: Collection<string, string>;
         commands: Collection<string, FrameworkCommand>;
         cooldowns: Collection<string, Collection<string, number>>;
         events: Collection<string, FrameworkListener<keyof ClientEvents>>;
-        autocompleteModule: AutocompleteModule;
+        autocompleters: Collection<string, FrameworkAutocompleter>;
         commandsModule: CommandsModule;
-        listenerModule: ListenerModule;
+        listenersModule: ListenerModule;
+        autocompletersModule: AutocompletersModule;
     }
     interface Message {
         prefix: string;
@@ -231,18 +249,52 @@ declare module 'discord.js' {
     }
 }
 
+interface FrameworkClientOptions {
+    clientOptions: ClientOptions;
+    developers?: readonly string[];
+    prefix?: string;
+    registerOnStart?: boolean;
+    guildsToRegister?: string[];
+    rootDir?: string;
+    commandsDir?: string;
+    listenersDir?: string;
+    autocompletersDir?: string;
+}
+
+declare class FrameworkClient<Ready extends boolean = boolean> extends Client<Ready> {
+    prefix: string;
+    developers: string[];
+    rootDir: string;
+    commandsDir: string;
+    listenersDir: string;
+    autocompletersDir: string;
+    private _inited;
+    autocompleters: Collection<string, FrameworkAutocompleter>;
+    events: Collection<string, FrameworkListener<keyof ClientEvents>>;
+    aliases: Collection<string, string>;
+    commands: Collection<string, FrameworkCommand>;
+    cooldowns: Collection<string, Collection<string, number>>;
+    commandsModule: CommandsModule;
+    listenersModule: ListenerModule;
+    autocompletersModule: AutocompletersModule;
+    constructor(frameworkOptions: FrameworkClientOptions);
+    init(): Promise<void>;
+    start(token: string): Promise<void>;
+    private routeInteractions;
+}
+
 declare function Autocompleter(options: AutocompleterOptions): {
     id: string;
     name: string;
     disabled: boolean;
-    execute: (client: FrameworkClient<true>, interaction: discord_js.AutocompleteInteraction, command: FrameworkSlashCommand, value: string) => Promise<unknown>;
+    execute: (client: FrameworkClient<true>, interaction: discord_js.AutocompleteInteraction<"cached">, command: FrameworkSlashCommand, value: string) => Promise<unknown> | unknown;
 };
 
 declare function ContextCommand(options: ContextCommandOptions): {
     id: string;
     name: string;
     description: string;
-    commandType: "Slash" | "Message" | "ContextUser" | "ContextMessage";
+    commandType: "Slash" | "Message" | "ContextMessage" | "ContextUser";
     memberPermissions: discord_js.PermissionResolvable | undefined;
     clientPermissions: discord_js.PermissionResolvable | undefined;
     cooldown: number | undefined;
@@ -254,7 +306,7 @@ declare function MessageCommand(options: MessageCommandOptions): {
     id: string;
     name: string;
     description: string;
-    commandType: "Slash" | "Message" | "ContextUser" | "ContextMessage";
+    commandType: "Slash" | "Message" | "ContextMessage" | "ContextUser";
     memberPermissions: discord_js.PermissionResolvable | undefined;
     clientPermissions: discord_js.PermissionResolvable | undefined;
     cooldown: number | undefined;
@@ -266,7 +318,7 @@ declare function SlashCommand(options: SlashCommandOptions): {
     id: string;
     name: string;
     description: string;
-    commandType: "Slash" | "Message" | "ContextUser" | "ContextMessage";
+    commandType: "Slash" | "Message" | "ContextMessage" | "ContextUser";
     memberPermissions: discord_js.PermissionResolvable | undefined;
     clientPermissions: discord_js.PermissionResolvable | undefined;
     cooldown: number | undefined;
@@ -278,7 +330,7 @@ declare function Listener<T extends keyof ClientEvents>(options: ListenerOptions
     name: T;
     once: boolean;
     disabled: boolean;
-    execute: (...args: ClientEvents[T]) => Promise<boolean>;
+    execute: (...args: ClientEvents[T]) => Promise<unknown> | unknown;
 };
 
-export { Autocompleter, type CommandHandlerName, type CommandModuleHandler, ContextCommand, type FrameworkAutocompleter, FrameworkClient, type FrameworkCommand, type FrameworkContextCommand, type FrameworkListener, type FrameworkMessageCommand, type FrameworkSlashCommand, Listener, MessageCommand, SlashCommand };
+export { Autocompleter, ContextCommand, type FrameworkAutocompleter, FrameworkClient, type FrameworkCommand, type FrameworkContextCommand, type FrameworkListener, type FrameworkMessageCommand, type FrameworkSlashCommand, Listener, MessageCommand, SlashCommand };