xernerx 0.1.120-beta.2 → 0.1.120-beta.21

package/dist/main.d.cts

@@ -1,167 +1,702 @@
-import * as Discord from 'discord.js';
+import { ClusterManager, Cluster, ClusterManagerOptions, ClusterClient } from 'discord-hybrid-sharding';
+import * as discord_js from 'discord.js';
+import { ClientEvents, Locale, InteractionContextType, ApplicationIntegrationType, PermissionFlags, ChannelType, AutocompleteInteraction, AutocompleteFocusedOption, ChatInputCommandInteraction as ChatInputCommandInteraction$1, RestOrArray, SlashCommandBuilder, Permissions, Client as Client$1, RESTGetAPISKUsResult, Collection, ClientOptions, User, Interaction as Interaction$1, Message as Message$1, MessagePayload, WebhookMessageCreateOptions, MessageCreateOptions, MessageEditOptions, MessageReplyOptions, RepliableInteraction, InteractionEditReplyOptions } from 'discord.js';
+export * from 'discord.js';
 
 /** @format */
-interface XernerxStats {
-    guilds: null | number;
-    users: null | number;
-    shardId: null | number;
-    shardCount: null | number;
-    shards: null | number;
-    voteCount: null | number;
-    votes: null | number;
+interface XernerxShardClientOptions {
+    file: string;
 }
-interface XernerxSlashCommandHandlerOptions {
-    directory: string;
-    global: boolean;
+
+/** @format */
+
+declare class XernerxShardClient extends ClusterManager {
+    #private;
+    readonly onlineShards: Set<Cluster>;
+    readonly stats: {
+        onlineSince: number | null;
+        guildCount: number | null;
+        userCount: number | null;
+        shardCount: number | null;
+        voteCount: number | null;
+        shards: [] | null;
+    };
+    constructor(options: ClusterManagerOptions & XernerxShardClientOptions);
 }
-interface XernerxMessageCommandHandlerOptions {
-    directory: string;
-    global: boolean;
+
+/** @format */
+interface XernerxClientOptions {
+    token: string;
+    global?: boolean;
+    guildId?: string | Array<string>;
+    owners?: string | Array<string>;
+    premium?: {
+        owners?: boolean;
+        consume?: boolean;
+        synchronize?: boolean;
+    };
 }
-interface XernerxContextCommandHandlerOptions {
-    directory: string;
-    global: boolean;
+
+/** @format */
+interface XernerxClientStats {
+    onlineSince: number | null;
+    guildCount: number | null;
+    userCount: number | null;
+    shardCount: number | null;
+    voteCount: number | null;
+    shard: {
+        shardId: number | null;
+        onlineSince: number | null;
+        guildCount: number | null;
+        userCount: number | null;
+    } | null;
 }
 
 /** @format */
-declare class XernerxContextCommand {
-    readonly _id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly global: boolean;
-    readonly filetype: 'XernerxContextCommand';
-    readonly collection: 'context.commands';
-    constructor(options: any);
+declare class XernerxBase {
+    readonly base: () => string;
+    constructor();
 }
 
 /** @format */
-declare class XernerxEvent {
-    readonly _id: string;
-    readonly name: string;
-    readonly description: string;
+
+declare class XernerxError extends XernerxBase {
+    constructor(message: string, exit?: number);
+}
+
+/** @format */
+
+interface XernerxEventBuilderOptions {
+    name: ClientEvents | keyof ClientEvents | (string & {});
+    emitter?: string;
+    once?: boolean;
+}
+
+/** @format */
+
+interface XernerxSlashCommandBuilderOptions {
+    name: string;
+    locales?: Partial<Record<Locale, {
+        name: string;
+        description: string;
+    }>>;
+    description: string;
+    contexts?: Array<keyof typeof InteractionContextType>;
+    integration?: Array<keyof typeof ApplicationIntegrationType>;
+    nsfw?: boolean;
+    options?: Array<XernerxSlashCommandBuilderOption>;
+    subcommands?: Array<XernerxSlashCommandBuilderSubcommand>;
+    groups?: Array<XernerxSlashCommandBuilderGroup>;
+    premium?: boolean;
+    defer?: boolean;
+    deploy?: {
+        global?: boolean;
+        guilds?: Array<string> | string;
+    };
+    info?: string;
+    usage?: string;
+    category?: string;
+    cooldown?: number;
+    permissions?: {
+        client?: Array<keyof PermissionFlags> | bigint | number | null;
+        user?: Array<keyof PermissionFlags> | bigint | number | null;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        types?: ChannelType;
+    };
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        types?: ChannelType;
+    };
+}
+interface XernerxSlashCommandBuilderOption {
+    type: 'attachment' | 'boolean' | 'channel' | 'integer' | 'mentionable' | 'number' | 'role' | 'string' | 'user';
+    name: string;
+    locales?: Partial<Record<Locale, {
+        name: string;
+        description: string;
+    }>>;
+    description: string;
+    required?: boolean;
+    autocomplete?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    choices?: Array<{
+        name: string;
+        value: string;
+        locales?: Partial<Record<Locale, string>>;
+    }>;
+}
+interface XernerxSlashCommandBuilderSubcommand {
+    name: string;
+    description: string;
+    options?: Array<XernerxSlashCommandBuilderOption>;
+    locales?: Partial<Record<Locale, {
+        name: string;
+        description: string;
+    }>>;
+}
+interface XernerxSlashCommandBuilderGroup {
+    name: string;
+    description: string;
+    subcommands: Array<XernerxSlashCommandBuilderSubcommand>;
+    locales?: Partial<Record<Locale, {
+        name: string;
+        description: string;
+    }>>;
+}
+
+/** @format */
+
+declare class XernerxBaseBuilder {
+    readonly id: string;
+    client: XernerxClient;
+    /**
+     * Constructs a new instance of the XernerxBaseBuilder class.
+     *
+     * @param id - A unique identifier for the builder instance.
+     * @param options - Configuration options for the builder, which can be either
+     *                  XernerxSlashCommandBuilderOptions or XernerxEventBuilderOptions.
+     */
+    constructor(id: string, options: XernerxSlashCommandBuilderOptions | XernerxEventBuilderOptions);
+}
+
+/** @format */
+
+declare class XernerxEventBuilder extends XernerxBaseBuilder {
     readonly filetype: 'XernerxEvent';
-    readonly collection: 'events';
-    constructor(options: any);
+    readonly name: ClientEvents | keyof ClientEvents | (string & {});
+    readonly emitter: string;
+    readonly once: boolean;
+    constructor(id: string, options: XernerxEventBuilderOptions);
+    /**
+     * Executes the event logic. This method should be overridden in subclasses to provide specific event handling.
+     *
+     * @param args - A variable number of arguments that are passed to the event handler.
+     *               These arguments are specific to the event being handled.
+     * @returns A promise that resolves when the event handling is complete.
+     *          The resolved value can be any type, depending on the implementation in subclasses.
+     */
+    run(...args: any[]): Promise<any | void>;
 }
 
 /** @format */
-declare class XernerxInhibitor {
-    readonly _id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly filetype: 'XernerxInhibitor';
-    readonly collection: 'inhibitors';
-    constructor(options: any);
+interface XernerxMessageCommandBuilderOptions {
+    name: string;
+    alias?: string | string[];
+    prefix?: string | string[];
+    premium?: any;
 }
 
 /** @format */
-declare class XernerxMessageCommand {
-    readonly _id: string;
+
+declare class XernerxMessageCommandBuilder extends XernerxBaseBuilder {
+    readonly filetype: 'XernerxMessageCommand';
     readonly name: string;
     readonly description: string;
-    readonly global: boolean;
-    readonly filetype: 'XernerxMessageCommand';
-    readonly collection: 'message.commands';
-    constructor(options: any);
+    readonly alias: string[];
+    readonly prefix: string[];
+    readonly premium: Array<string>;
+    /**
+     * Constructs an instance of XernerxMessageCommandBuilder.
+     *
+     * @param id - A unique identifier for the command.
+     * @param options - An object containing configuration options for the command.
+     * @param options.name - The name of the command.
+     * @param options.alias - An alias or an array of aliases for the command.
+     * @param options.prefix - A prefix or an array of prefixes for the command.
+     * @param options.premium - An array indicating premium features or settings.
+     */
+    constructor(id: string, options: XernerxMessageCommandBuilderOptions);
+    /**
+     * Executes the command logic. This function is intended to be overridden by subclasses.
+     * If not overridden, it will log a warning indicating that the command will not respond.
+     *
+     * @param args - A variable number of arguments that can be passed to the command execution.
+     * @returns A promise that resolves to any value, depending on the implementation.
+     */
+    exec(...args: any[]): Promise<any>;
 }
 
 /** @format */
 
-declare class XernerxSlashCommand extends Discord.SlashCommandBuilder {
-    readonly _id: string;
-    readonly global: boolean;
-    readonly filetype: 'XernerxSlashCommand';
-    readonly collection: 'slash.commands';
-    constructor(options: any);
+interface XernerxSlashCommand {
+    interaction: ChatInputCommandInteraction$1;
+    options?: Record<string, {
+        name: string;
+        type: number;
+        value: string | number | boolean | object;
+    }> | null;
+    subcommand: string | null;
+    group: string | null;
+    command: XernerxSlashCommandBuilder$1;
+}
+interface XernerxSlashCommandAutocomplete {
+    interaction: AutocompleteInteraction;
+    focused: AutocompleteFocusedOption;
+    options: any;
 }
 
 /** @format */
 
-type XernerxFileType = 'XernerxSlashCommand' | 'XernerxMessageCommand' | 'XernerxContextCommand' | 'XernerxEvent' | 'XernerxInhibitor';
-type XernerxFile<T = XernerxFileType> = T extends 'XernerxSlashCommand' ? XernerxSlashCommand : T extends 'XernerxMessageCommand' ? XernerxMessageCommand : T extends 'XernerxContextCommand' ? XernerxContextCommand : T extends 'XernerxEvent' ? XernerxEvent : T extends 'XernerxInhibitor' ? XernerxInhibitor : XernerxSlashCommand | XernerxMessageCommand | XernerxSlashCommand | XernerxEvent | XernerxInhibitor;
-
-/** @format */
+declare class XernerxSlashCommandBuilder$1 extends XernerxBaseBuilder {
+    readonly name: string;
+    readonly description: string;
+    readonly integration: RestOrArray<InteractionContextType>;
+    readonly data: SlashCommandBuilder;
+    readonly options: Array<XernerxSlashCommandBuilderOption>;
+    readonly subcommands: Array<XernerxSlashCommandBuilderSubcommand>;
+    readonly groups: Array<XernerxSlashCommandBuilderGroup>;
+    readonly premium?: boolean;
+    readonly defer?: boolean;
+    readonly deploy?: {
+        global?: boolean;
+        guilds?: Array<string> | string;
+    };
+    readonly info?: string;
+    readonly usage?: string;
+    readonly category?: string;
+    readonly cooldown?: number;
+    readonly permissions: {
+        client: Permissions | number | bigint | null;
+        user: Permissions | number | bigint | null;
+    };
+    readonly strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        types?: ChannelType;
+    };
+    readonly ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+        types?: ChannelType;
+    };
+    readonly filetype: 'XernerxSlashCommand';
+    constructor(id: string, options: XernerxSlashCommandBuilderOptions);
+    /**
+     * Handles the autocomplete functionality for a slash command.
+     *
+     * @param args - The arguments for the autocomplete function, which include the context and options for the command.
+     * @returns A promise that resolves to either void or any value, depending on the implementation.
+     */
+    autocomplete(args: XernerxSlashCommandAutocomplete): Promise<void | any>;
+    /**
+     * Evaluates conditions for executing a slash command.
+     *
+     * @param args - The arguments for the conditions function, which include the context and options for the command.
+     * @returns A promise that resolves to either void or any value, depending on the implementation.
+     */
+    conditions(args: XernerxSlashCommand): Promise<void | any>;
+    /**
+     * Executes the slash command.
+     *
+     * @param args - The arguments for the exec function, which include the context and options for the command.
+     * @returns A promise that resolves to either void or any value, depending on the implementation.
+     */
+    exec(args: XernerxSlashCommand): Promise<void | any>;
+    private addArguments;
+    private addSubcommands;
+    /**
+     * Adds subcommand groups to the slash command builder.
+     *
+     * @param groups - An array of subcommand groups to be added. Each group contains a name, description, locales, and subcommands.
+     */
+    private addSubcommandGroups;
+}
 
 declare class Handler {
     readonly client: XernerxClient;
+    [index: string]: Record<string, any>;
     constructor(client: XernerxClient);
-    protected readdir(directory: string): Promise<string[]>;
-    protected load(filepath: string): Promise<XernerxFile | null>;
+    /**
+     * Loads JavaScript files from a specified directory.
+     *
+     * @param dir - The directory path from which to load the files.
+     * @returns An array of file paths for JavaScript files in the specified directory.
+     *          Returns an empty array if an error occurs during the file reading process.
+     */
+    loadFiles(dir: string): string[];
+    /**
+     * Asynchronously loads a JavaScript file and imports its default export.
+     *
+     * @param file - The path to the JavaScript file to be loaded.
+     * @returns A promise that resolves when the file is successfully loaded and imported.
+     *          If the file does not have a default export, an error is thrown.
+     */
+    loadFile(file: string): Promise<XernerxError | undefined>;
+    /**
+     * Imports a file by registering it with the client based on its type.
+     *
+     * @param builder - An instance of XernerxEventBuilder, XernerxMessageCommandBuilder, or XernerxSlashCommandBuilder.
+     *                  This object contains the necessary information to register the file with the client.
+     * @param filename - An optional string representing the name of the file being imported.
+     *                   Used for error reporting if the builder ID is not unique.
+     * @returns The builder object after it has been registered with the client.
+     *          If the builder is of type XernerxEvent, it is registered as an event listener.
+     *          If the builder is of type XernerxMessageCommand or XernerxSlashCommand, it is registered as a command.
+     */
+    importFile(builder: XernerxEventBuilder | XernerxMessageCommandBuilder | XernerxSlashCommandBuilder$1, filename?: string): Promise<XernerxError | XernerxEventBuilder | XernerxMessageCommandBuilder | XernerxSlashCommandBuilder$1>;
 }
 
-/** @format */
-
-declare class CommandHandler extends Handler {
+declare class EventHandler extends Handler {
     constructor(client: XernerxClient);
-    protected loadSlashCommands(options: XernerxSlashCommandHandlerOptions): Promise<void>;
-    protected loadMessageCommands(options: XernerxMessageCommandHandlerOptions): Promise<void>;
-    protected loadContextCommands(options: XernerxContextCommandHandlerOptions): Promise<void>;
+    /**
+     * Loads a single event file.
+     *
+     * @param file - The path to the event file to be loaded.
+     * @returns A promise that resolves when the event file has been successfully loaded.
+     */
+    loadEvent(file: string): Promise<XernerxError | undefined>;
+    /**
+     * Loads all event files from the specified directory and initializes them.
+     *
+     * @param options - An object containing options for loading events.
+     * @param options.directory - The directory path where event files are located.
+     * @returns A promise that resolves when all events have been loaded.
+     */
+    loadEvents(options: {
+        directory: string;
+    }): Promise<void>;
 }
 
 /** @format */
+interface XernerxMessageCommandHandlerOptions {
+    directory: string | null;
+    prefix?: string | string[];
+    mention?: boolean;
+    seperator?: string;
+    handleEdits?: boolean;
+    handleDeletions?: boolean;
+    ignore?: {
+        system?: boolean;
+        bots?: boolean;
+        self?: boolean;
+    };
+}
 
-declare class Util {
-    readonly client: XernerxClient;
-    constructor(client: XernerxClient);
+/** @format */
+interface XernerxSlashCommandHandlerOptions {
+    directory: string | null;
 }
 
 /** @format */
 
-declare class ClientUtil extends Util {
+declare class CommandHandler extends Handler {
     constructor(client: XernerxClient);
-    uptime(timestamp?: number | null): string;
+    /**
+     * Loads a message command from a specified file.
+     *
+     * @param file - The path to the file containing the message command to be loaded.
+     * @returns A promise that resolves when the file has been successfully loaded.
+     */
+    loadMessageCommand(file: string): Promise<XernerxError | undefined>;
+    /**
+     * Loads message commands based on the provided options.
+     *
+     * @param options - Configuration options for loading message commands, including directory, prefix, mention, separator, handleEdits, handleDeletions, and ignore settings.
+     * @returns A promise that resolves when all message commands have been successfully loaded.
+     */
+    loadMessageCommands(options: XernerxMessageCommandHandlerOptions): Promise<void>;
+    /**
+     * Loads a slash command from a specified file.
+     *
+     * @param file - The path to the file containing the slash command to be loaded.
+     * @returns A promise that resolves when the file has been successfully loaded.
+     */
+    loadSlashCommand(file: string): Promise<XernerxError | undefined>;
+    /**
+     * Loads slash commands based on the provided options.
+     *
+     * @param options - Configuration options for loading slash commands, including the directory where the command files are located.
+     * @returns A promise that resolves when all slash commands have been successfully loaded.
+     */
+    loadSlashCommands(options: XernerxSlashCommandHandlerOptions): Promise<void>;
+    /**
+     * Loads and imports event files based on the provided event classes.
+     *
+     * @param args - An array of event classes extending XernerxEventBuilder. Each class represents an event to be loaded and imported.
+     * @returns A promise that resolves when all specified events have been successfully imported.
+     */
+    private loadEvents;
 }
 
 /** @format */
 
-declare class XernerxClient<T = {}> extends Discord.Client {
-    readonly settings: {
-        token: string;
-        global: boolean;
-        owners: string[];
-        guilds: string[];
-        debug: boolean;
+declare class XernerxClient extends Client$1 {
+    readonly token: string;
+    readonly sharded: boolean;
+    readonly settings: XernerxClientOptions;
+    readonly premium: {
+        owners?: boolean;
+        consume?: boolean;
+        synchronize?: boolean;
     };
-    readonly stats: XernerxStats;
+    readonly monitisation: {
+        skus: RESTGetAPISKUsResult;
+    };
+    readonly stats: XernerxClientStats;
+    readonly cluster: ClusterClient | null;
+    readonly cache: {
+        messages: Collection<string, string>;
+        slash: Collection<string, string>;
+    };
+    readonly handler: {
+        message: XernerxMessageCommandHandlerOptions;
+        slash: XernerxSlashCommandHandlerOptions;
+    };
+    readonly commands: {
+        message: Collection<string, XernerxMessageCommandBuilder>;
+        slash: Collection<string, XernerxSlashCommandBuilder$1>;
+    };
+    readonly events: Collection<string, XernerxEventBuilder>;
     readonly modules: {
+        eventHandler: EventHandler;
         commandHandler: CommandHandler;
-        options: {
-            message?: {
-                global?: boolean;
-            };
-            slash?: {
-                global?: boolean;
-            };
-            context?: {
-                global?: boolean;
-            };
-        };
-    };
-    readonly util: ClientUtil;
-    readonly commands: {
-        message: Discord.Collection<string, XernerxMessageCommand>;
-        slash: Discord.Collection<string, XernerxSlashCommand>;
-        context: Discord.Collection<string, XernerxContextCommand>;
-        stats: {
-            slash: {
-                local: number;
-                global: number;
-            };
-            message: {
-                local: number;
-                global: number;
-            };
-            context: {
-                local: number;
-                global: number;
-            };
-        };
-    };
-    readonly events: Discord.Collection<string, XernerxEvent>;
-    readonly inhibitors: Discord.Collection<string, XernerxInhibitor>;
-    constructor(DiscordOptions: any, XernerxOptions: any, config: T);
-    private connect;
-    private deploy;
-}
-
-export { XernerxClient, XernerxSlashCommand };
+    };
+    constructor(options: ClientOptions & XernerxClientOptions);
+    /**
+     * Connects the client to Discord and initializes various client statistics and handlers.
+     *
+     * @returns A promise that resolves when the client successfully logs in, or rejects with an error message if the login fails.
+     */
+    connect(): Promise<string | XernerxError>;
+}
+
+declare class XernerxUser extends User {
+    #private;
+    constructor(client: Client$1<true> | XernerxClient, user: User);
+    /**
+     * Checks if the user has any entitlements, indicating premium status.
+     *
+     * @param id - The ID of the user to check for premium entitlements.
+     * @returns A promise that resolves to a boolean indicating whether the user has any entitlements (true) or not (false).
+     */
+    premium(id: string): Promise<boolean>;
+    /**
+     * Retrieves the entitlements for the user and maps them to their corresponding SKU.
+     *
+     * @returns A promise that resolves to an array of objects, each containing an entitlement and its associated SKU.
+     */
+    entitlements(): Promise<{
+        entitlement: discord_js.APIEntitlement;
+        sku: discord_js.APISKU | undefined;
+    }[]>;
+    /**
+     * Synchronizes the user's entitlements with the current SKU data and performs necessary actions
+     * such as consuming, deleting, or creating entitlements based on their type and the client's premium settings.
+     *
+     * @returns A promise that resolves to an array of error messages, if any occurred during the synchronization process.
+     */
+    synchronize(): Promise<string[]>;
+}
+
+/** @format */
+
+declare class XernerxBaseUtil {
+    readonly client: XernerxClient & Client$1<true>;
+    readonly parsed: {
+        command: string | null;
+        alias: string | null;
+        mention: boolean | null;
+        prefix: string | null;
+    };
+    interaction: Interaction$1 | Message$1;
+    constructor(client: XernerxClient & Client$1<true>, interaction: Interaction$1 | Message$1);
+    /**
+     * Sends a message using a webhook in the current interaction's channel.
+     *
+     * @param options - The message content or options to send via the webhook. This can be a string, MessagePayload, or WebhookMessageCreateOptions.
+     * @returns A promise that resolves to the message sent by the webhook.
+     */
+    webhook(options: string | MessagePayload | WebhookMessageCreateOptions): Promise<Message$1<boolean> | undefined>;
+}
+
+/** @format */
+
+declare class XernerxMessageUtil extends XernerxBaseUtil {
+    #private;
+    readonly message: Message$1;
+    readonly cache: Collection<string, string>;
+    args: string[];
+    constructor(client: XernerxClient & Client$1<true>, message: Message$1);
+    /**
+     * Sends a message to the channel or edits an existing message if applicable.
+     *
+     * @param options - The content or options for the message to be sent or edited.
+     *                  It can be a string, MessagePayload, MessageCreateOptions, or MessageEditOptions.
+     * @returns The sent or edited message, or null if the message ID is not found in the cache.
+     */
+    send(options: string | MessagePayload | MessageCreateOptions | MessageEditOptions): Promise<Message$1<boolean> | null>;
+    /**
+     * Replies to the current message or edits an existing reply if applicable.
+     *
+     * @param options - The content or options for the reply message.
+     *                  It can be a string, MessagePayload, or MessageReplyOptions.
+     * @returns The sent or edited message, or null if the message ID is not found in the cache.
+     */
+    reply(options: string | MessagePayload | MessageReplyOptions): Promise<Message$1<boolean> | null>;
+}
+
+/** @format */
+
+
+declare module 'discord.js' {
+	interface Message {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxMessageUtil;
+	}
+}
+
+declare class XernerxInteractionUtil extends XernerxBaseUtil {
+    readonly interaction: RepliableInteraction;
+    readonly cache: Collection<string, string>;
+    args: string[];
+    constructor(client: XernerxClient & Client$1<true>, interaction: Interaction$1);
+    /**
+     * Sends a message to the channel associated with the interaction.
+     *
+     * @param options - The content or options for the message to be sent. It can be a string, MessagePayload, or MessageCreateOptions.
+     * @returns A promise that resolves to the sent message.
+     * @throws {XernerxError} Throws an error if the options parameter is not provided.
+     */
+    send(options: string | MessagePayload | MessageCreateOptions): Promise<discord_js.Message<true>>;
+    /**
+     * Replies to the interaction with the provided options.
+     *
+     * @param options - The content or options for the reply. It can be a string, MessagePayload, or InteractionEditReplyOptions.
+     * @returns A promise that resolves to the sent message or the edited reply.
+     * @throws {XernerxError} Throws an error if the options parameter is not provided.
+     */
+    reply(options: string | MessagePayload | InteractionEditReplyOptions): Promise<discord_js.Message<boolean> | discord_js.InteractionResponse<boolean>>;
+    /**
+     * Sends a message to the channel associated with the interaction with componentsV2 flag.
+     *
+     * @param options - The options for the message to be sent, including content and other message properties.
+     * @returns A promise that resolves to the sent message.
+     */
+    send2(options: MessageCreateOptions): Promise<discord_js.Message<true>>;
+    /**
+     * Replies to the interaction with the provided options, using the componentsV2 flag.
+     *
+     * @param options - The options for the reply, including content and other message properties.
+     * @returns A promise that resolves to the sent message or the edited reply.
+     */
+    reply2(options: InteractionEditReplyOptions): Promise<discord_js.Message<boolean> | discord_js.InteractionResponse<boolean>>;
+}
+
+/** @format */
+
+
+
+declare module 'discord.js' {
+	interface Interaction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface ChatInputCommandInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface MessageContextMenuCommandInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface UserContextMenuCommandInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface PrimaryEntryPointCommandInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface StringSelectMenuInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface UserSelectMenuInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface RoleSelectMenuInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface MentionableSelectMenuInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface ChannelSelectMenuInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface ButtonInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface AutocompleteInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+
+	interface ModalSubmitInteraction {
+		user: XernerxUser;
+		client: Client<true> & XernerxClient;
+		util: XernerxInteractionUtil;
+	}
+}
+
+/** @format */
+
+
+
+declare module 'discord.js' {
+	interface ClientEvents {
+		selectMenuInteraction: [interaction: AnySelectMenuInteraction];
+		buttonInteraction: [interaction: ButtonInteraction];
+		modalInteraction: [interaction: ModalSubmitInteraction];
+		contextCommandInteraction: [interaction: ContextMenuCommandInteraction];
+		slashCommandInteraction: [interaction: ChatInputCommandInteraction];
+		commandError: [interaction: Interaction | Message, args: any, command: XernerxSlashCommandBuilder | XernerxMessageCommandBuilder, error: Error];
+		commandBlock: [interaction: Interaction | Message, command: XernerxSlashCommandBuilder | XernerxMessageCommandBuilder, error: any];
+		commandStart: [interaction: Interaction | Message, args: any, command: XernerxSlashCommandBuilder | XernerxMessageCommandBuilder];
+		commandFinish: [interaction: Interaction | Message, args: any, command: XernerxSlashCommandBuilder | XernerxMessageCommandBuilder];
+		commandDelete: [interaction: Interaction | Message, error: Error];
+	}
+}
+
+export { XernerxClient, XernerxEventBuilder, XernerxMessageCommandBuilder, XernerxShardClient, type XernerxSlashCommand, type XernerxSlashCommandAutocomplete, XernerxSlashCommandBuilder$1 as XernerxSlashCommandBuilder };