@spatulox/simplediscordbot 1.0.31 → 1.0.32

package/dist/index.d.mts

@@ -0,0 +1,915 @@
+import { EmbedBuilder, Message, InteractionDeferReplyOptions, InteractionReplyOptions, InteractionEditReplyOptions, MessageCreateOptions, ActionRowBuilder, MessageActionRowComponentBuilder, TextChannel, DMChannel, ThreadChannel, User, GuildMember, BaseInteraction, InteractionResponse, Client, ActivityType, WebhookMessageCreateOptions, EmojiResolvable, Guild, BanOptions, Snowflake, GuildBasedChannel, GuildChannelCreateOptions, ForumChannel, NewsChannel, StageChannel, StartThreadOptions, VoiceChannel, Invite, Channel, Collection, GuildBan, ModalBuilder, StringSelectMenuBuilder, UserSelectMenuBuilder, RoleSelectMenuBuilder, MentionableSelectMenuBuilder, ChannelType, ChannelSelectMenuBuilder, StringSelectMenuOptionBuilder } from 'discord.js';
+
+type ConfigLog = {
+    logChannelId: string;
+    errorChannelId: string;
+    info: {
+        console: boolean;
+        discord: boolean;
+    };
+    error: {
+        console: boolean;
+        discord: boolean;
+    };
+    warn: {
+        console: boolean;
+        discord: boolean;
+    };
+    debug: {
+        console: boolean;
+        discord: boolean;
+    };
+};
+declare class BotLog {
+    private static logChannel;
+    private static errorChannel;
+    constructor();
+    static config(): ConfigLog | undefined;
+    /**
+     * Initialize Discord logging channels and update Bot.log references
+     */
+    static initDiscordLogging(): Promise<void>;
+    /**
+     * Send content to specific Discord channel
+     */
+    private static _sendToChannel;
+    /**
+     * Send INFO log - TEXT or EMBED ! Respecte config.log.info
+     */
+    static info(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send ERROR log - TEXT or EMBED ! Respecte config.log.error
+     */
+    static error(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send WARNING log - TEXT or EMBED ! Respecte config.log.warn
+     */
+    static warn(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send DEBUG log - TEXT or EMBED ! Respecte config.log.debug
+     */
+    static debug(content: string | EmbedBuilder): Promise<Message | void>;
+}
+
+declare enum EmbedColor {
+    error = 8912917,
+    success = 65280,
+    black = 0,
+    white = 16777215,
+    red = 16711680,
+    green = 65280,
+    blue = 255,
+    yellow = 16776960,
+    cyan = 65535,
+    magenta = 16711935,
+    gray = 8421504,
+    lightgray = 13882323,
+    darkgray = 11119017,
+    orange = 16753920,
+    purple = 8388736,
+    pink = 16761035,
+    brown = 10824234,
+    lime = 65280,
+    navy = 128,
+    teal = 32896,
+    olive = 8421376,
+    gold = 16766720,
+    silver = 12632256,
+    coral = 16744272,
+    salmon = 16416882,
+    khaki = 15787660,
+    plum = 14524637,
+    lavender = 15132410,
+    beige = 16119260,
+    mint = 10026904,
+    peach = 16767673,
+    chocolate = 13789470,
+    crimson = 14423100,
+    youtube = 16718362,
+    default = 6064856,
+    minecraft = 25600
+}
+declare class EmbedManager {
+    private static get BOT_ICON();
+    private static get DEFAULT_COLOR();
+    /**
+     * Creates base embed - SAME SIMPLE API !
+     */
+    static create(color?: EmbedColor | null): EmbedBuilder;
+    /**
+     * Creates simple embed with just description
+     */
+    static simple(description: string, color?: EmbedColor | null): EmbedBuilder;
+    /**
+     * Creates error embed
+     */
+    static error(description: string): EmbedBuilder;
+    /**
+     * Creates success embed
+     */
+    static success(description: string): EmbedBuilder;
+    /**
+     * Creates success embed
+     */
+    static description(description: string): EmbedBuilder;
+    /**
+     * Creates debug embed
+     */
+    static debug(description: string): EmbedBuilder;
+    /**
+     * Defer ephemeral reply
+     */
+    static deferEphemeral(): InteractionDeferReplyOptions;
+    /**
+     * Quick field adder
+     */
+    static field(embed: EmbedBuilder, name: string, value: string, inline?: boolean): EmbedBuilder;
+    static fields(embed: EmbedBuilder, fields: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[]): EmbedBuilder;
+    /**
+     * Fluent API shortcuts
+     */
+    static title(embed: EmbedBuilder, title: string): EmbedBuilder;
+    static desc(embed: EmbedBuilder, description: string): EmbedBuilder;
+    static thumb(embed: EmbedBuilder, url: string): EmbedBuilder;
+    static image(embed: EmbedBuilder, url: string): EmbedBuilder;
+    static footer(embed: EmbedBuilder, text: string): EmbedBuilder;
+    /**
+     * Transform embed into objet for interaction.reply()
+     */
+    static toInteraction(embed: EmbedBuilder, ephemeral?: boolean): InteractionReplyOptions | InteractionEditReplyOptions;
+    /**
+     * Transform embed into objet to send a message
+     */
+    static toMessage(embed: EmbedBuilder): MessageCreateOptions;
+}
+
+type SendableComponent = EmbedBuilder | ActionRowBuilder<MessageActionRowComponentBuilder>;
+
+declare class BotMessage {
+    /**
+     * Send message to any text-based channel
+     */
+    static send(channel: TextChannel | DMChannel | ThreadChannel | string, content?: string | null, component?: SendableComponent): Promise<Message | null>;
+    static send(channel: TextChannel | DMChannel | ThreadChannel | string, content: SendableComponent): Promise<Message | null>;
+    static send(channel: TextChannel | DMChannel | ThreadChannel | string, content: MessageCreateOptions): Promise<Message | null>;
+    static sendDM(user: User | GuildMember | string, content?: string, component?: SendableComponent): Promise<Message | null>;
+    /**
+     * Quick success message
+     */
+    static success(channel: TextChannel | DMChannel | ThreadChannel | User | GuildMember, message: string): Promise<Message | null>;
+    /**
+     * Quick error message
+     */
+    static error(channel: TextChannel | DMChannel | ThreadChannel | User | GuildMember, message: string): Promise<Message | null>;
+}
+
+declare class BotInteraction {
+    /**
+     * InteractionReplyOptions && InteractionUpdateOptions
+     * The two have "content", "embeds" & "flags" field, so an internal cast is ok, unless discord/discordjs deprecate it
+     */
+    private static buildReplyOptions;
+    private static buildUpdateOptions;
+    private static _buildOptions;
+    static send(interaction: BaseInteraction, content: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static send(interaction: BaseInteraction, content: string, component: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static reply(interaction: BaseInteraction, content: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static reply(interaction: BaseInteraction, content: string, component: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static followUp(interaction: BaseInteraction, content: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static followUp(interaction: BaseInteraction, content: string, component: SendableComponent, ephemeral?: boolean): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static defer(interaction: BaseInteraction): Promise<void>;
+    static update(interaction: BaseInteraction, content: SendableComponent): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+    static update(interaction: BaseInteraction, content: string, component: SendableComponent): Promise<InteractionResponse<boolean> | Message<boolean> | boolean>;
+}
+
+type BotConfig = {
+    botIconUrl?: string;
+    defaultEmbedColor?: number | EmbedColor;
+    botName?: string;
+    log?: ConfigLog;
+};
+type InternalBotConfig = {
+    clientId: string;
+} & BotConfig;
+type RandomBotActivity = {
+    type: ActivityType;
+    message: string;
+}[];
+declare class Bot {
+    static readonly log: typeof BotLog;
+    static readonly message: typeof BotMessage;
+    static readonly interaction: typeof BotInteraction;
+    static _client: Client;
+    private static criticConfig;
+    private static _config;
+    get config(): InternalBotConfig;
+    get client(): Client;
+    static get client(): Client;
+    static get config(): InternalBotConfig;
+    constructor(client: Client, config: BotConfig);
+    login(maxTries?: number): Promise<boolean>;
+    static setActivity(message: string, type: ActivityType): void;
+    static setRandomActivity(randomActivity: RandomBotActivity, intervalMs?: number | null): void;
+}
+
+declare const BotEnv: {
+    readonly token: string;
+    readonly dev: boolean;
+    readonly clientId: string;
+};
+
+declare class FileManager {
+    /**
+     * Reads a JSON file synchronously.
+     * @param filePath Full path to the JSON file
+     * @returns Parsed JSON object or 'Error' string on failure
+     */
+    static readJsonFile(filePath: string): Promise<any | false>;
+    /**
+     * Lists all directories in a given path.
+     * @param directoryPath Path to scan for directories
+     * @returns Array of directory names or false on error
+     */
+    static listDirectories(directoryPath: string): Promise<string[] | false>;
+    /**
+     * Lists all JSON files in a directory.
+     * @param directoryPath Path to scan for JSON files
+     * @returns Array of JSON filenames or false on error
+     */
+    static listJsonFiles(directoryPath: string): Promise<string[] | false>;
+    /**
+     * Lists files with specific extension in a directory.
+     * @param directoryPath Path to scan
+     * @param extension File extension (with or without dot)
+     * @returns Array of matching filenames or 'Error' string on failure
+     */
+    static listFiles(directoryPath: string, extension: string): Promise<string[] | false>;
+    /**
+     * Creates directory structure and writes JSON data to file.
+     * @param directoryPath Full directory path (creates if missing)
+     * @param filename Filename without extension
+     * @param data Data to write (JSON serializable)
+     * @param sendErrorToErrorChannel Send error to the error channel
+     * @returns true on success, false on failure
+     */
+    static writeJsonFile(directoryPath: string, filename: string, data: any, sendErrorToErrorChannel?: boolean): Promise<boolean>;
+}
+
+declare class WebhookManager {
+    private readonly channel;
+    private readonly name;
+    private readonly avatarURL?;
+    private webhook;
+    constructor(channel: TextChannel | ThreadChannel, name?: string, avatarURL?: string | undefined);
+    private get textChannel();
+    /**
+     * Get or create webhook (lazy initialization)
+     */
+    private getWebhook;
+    /**
+     * Send message/text/component !
+     */
+    send(content: string): Promise<Message | null>;
+    send(content: SendableComponent): Promise<Message | null>;
+    send(content: WebhookMessageCreateOptions): Promise<Message | null>;
+    /**
+     * Quick success embed
+     */
+    success(message: string): Promise<Message | null>;
+    /**
+     * Quick error embed
+     */
+    error(message: string): Promise<Message | null>;
+    /**
+     * Delete webhook
+     */
+    delete(reason?: string): Promise<void>;
+}
+
+declare class ReactionManager {
+    /**
+     * Add a reaction to a message
+     */
+    static add(channelId: string, messageId: string, emoji: string | EmojiResolvable): Promise<void>;
+    /**
+     * Delete a reaction from a user
+     */
+    static remove(channelId: string, messageId: string, emoji: string, userId: string): Promise<void>;
+    /**
+     * Get all reaction of a message
+     */
+    static getAll(channelId: string, messageId: string): Promise<Reaction[]>;
+    /**
+     * Delete all reaction
+     */
+    static clear(channelId: string, messageId: string): Promise<void>;
+}
+interface Reaction {
+    emoji: any;
+    count: number;
+    users: User[];
+}
+
+declare abstract class BasicUserManager {
+    /**
+     * Find member in specific guild
+     */
+    static findInGuild(guildId: string, memberId: string): Promise<GuildMember | null>;
+    /**
+     * Check if user is still in guild
+     */
+    static isInGuild(guildId: string, userId: string): Promise<boolean>;
+    /**
+     * Overload for send
+     */
+    static send(user_id: string, content: string): Promise<Message>;
+    static send(user: User, content: string): Promise<Message>;
+    static send(user: GuildMember, content: string): Promise<Message>;
+    static send(user_id: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user: User, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user: GuildMember, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user_id: string, content: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user: User, content: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user: GuildMember, content: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(user_id_or_user: string, options: MessageCreateOptions): Promise<Message>;
+    static send(user_id_or_user: User, options: MessageCreateOptions): Promise<Message>;
+    static send(user_id_or_user: GuildMember, options: MessageCreateOptions): Promise<Message>;
+}
+
+declare class GuildUserManager extends BasicUserManager {
+    static find(userId: string, guild: Guild | string): Promise<GuildMember | null>;
+    static rename(member: GuildMember, nickname: string, maxAttempts?: number): Promise<boolean>;
+    /**
+     * Check if user is banned from guild
+     */
+    static isBanned(guildId: string, userId: string): Promise<boolean>;
+    /**
+     * Deconnect a member from a voice
+     */
+    static deconnectFromVoice(guildId: string, memberId: string): Promise<void>;
+    /**
+     * Check if a member is in voice
+     */
+    static isInVoice(memberId: string, guildId: string): Promise<boolean>;
+    /**
+     * Mute a member
+     */
+    static mute(guildId: string, memberId: string, reason?: string): Promise<void>;
+    /**
+     * Unmute a member
+     */
+    static unmute(guildId: string, memberId: string, reason?: string): Promise<void>;
+    /**
+     * Deafen a member
+     */
+    static deafen(guildId: string, memberId: string, reason?: string): Promise<void>;
+    /**
+     * Undeafen member voice
+     */
+    static undeafen(guildId: string, memberId: string, reason?: string): Promise<void>;
+    /**
+     * Timeout a member
+     */
+    static timeout(guildId: string, memberId: string, duration: number, reason?: string): Promise<void>;
+    /**
+     * Remove the timeout of a member
+     */
+    static untimeout(guildId: string, memberId: string, reason?: string): Promise<void>;
+    /**
+     * Kick a member
+     */
+    static kick(guildId: string, memberId: string, reason?: string): Promise<void>;
+    static ban(guildId: string, userId: string, banOption?: BanOptions): Promise<void>;
+    static unban(guildId: string, userId: string, reason?: string): Promise<void>;
+}
+
+declare class RoleManager {
+    /**
+     * Add role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleId - Role ID (string)
+     */
+    static add(member: GuildMember, roleId: Snowflake): Promise<boolean>;
+    /**
+     * Remove role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleIdOrName - Role ID or name
+     */
+    static remove(member: GuildMember, roleIdOrName: Snowflake | string): Promise<boolean>;
+    /**
+     * Toggle role (add/remove)
+     */
+    static toggle(member: GuildMember, roleIdOrName: Snowflake | string): Promise<'added' | 'removed'>;
+    /**
+     * Check if member has role
+     */
+    static hasRole(member: GuildMember, roleIdOrName: Snowflake | string): boolean;
+}
+
+declare class GuildMessageManager {
+    /**
+     * Overloads for send
+     */
+    static send(channelId: string, content: string): Promise<Message>;
+    static send(channelId: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(channelId: string, options: MessageCreateOptions): Promise<Message>;
+    /**
+     * Delete message
+     */
+    static delete(channelId: string, messageId: string): Promise<boolean>;
+    /**
+     * Fetch messages (last X messages, default 10)
+     */
+    static fetch(channelId: string, limit?: number): Promise<Message[]>;
+    /**
+     * Fetch single message
+     */
+    static fetchOne(channelId: string, messageId: string): Promise<Message | null>;
+}
+
+declare class GuildChannelManager {
+    static readonly message: typeof GuildMessageManager;
+    /**
+     * Recherche un channel par ID dans une guild spécifique
+     */
+    static findInGuild(guildId: string, channelId: string): Promise<GuildBasedChannel | null>;
+    static find(channelId: string): Promise<GuildBasedChannel | null>;
+    static findAll(guildId: string): GuildBasedChannel[];
+    /**
+     * Recherche channels par nom (insensible à la casse)
+     */
+    static findByName(guildId: string, name: string): GuildBasedChannel[];
+    protected static _create(guildId: string, options: GuildChannelCreateOptions): Promise<GuildBasedChannel>;
+    static delete(channelId: string): Promise<boolean>;
+}
+
+declare class ForumChannelManager extends GuildChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<ForumChannel | null>;
+    static find(channelId: string): Promise<ForumChannel | null>;
+    static findAll(guildId: string): ForumChannel[];
+    static create(guildId: string, name: string, options?: Omit<GuildChannelCreateOptions, 'type'>): Promise<ForumChannel>;
+}
+
+declare class NewsChannelManager extends GuildChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<NewsChannel | null>;
+    static find(channelId: string): Promise<NewsChannel | null>;
+    static findAll(guildId: string): NewsChannel[];
+    static create(guildId: string, name: string, options?: Omit<GuildChannelCreateOptions, 'type'>): Promise<NewsChannel>;
+}
+
+declare class StageChannelManager extends GuildChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<StageChannel | null>;
+    static find(channelId: string): Promise<StageChannel | null>;
+    static findAll(guildId: string): StageChannel[];
+    static create(guildId: string, name: string, options?: Omit<GuildChannelCreateOptions, 'type'>): Promise<StageChannel>;
+}
+
+declare class GuildTextChannelManager extends GuildChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<TextChannel | null>;
+    static find(channelId: string): Promise<TextChannel | null>;
+    static findAll(guildId: string): TextChannel[];
+    static create(guildId: string, name: string, options?: Omit<GuildChannelCreateOptions, 'type'>): Promise<TextChannel>;
+}
+
+declare class ThreadChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<ThreadChannel | null>;
+    static find(channelId: string): Promise<ThreadChannel | null>;
+    static findAll(guildId: string): ThreadChannel[];
+    static createFromChannel(parentId: string, options: StartThreadOptions): Promise<ThreadChannel>;
+    static createFromMessage(message: Message, options: StartThreadOptions): Promise<ThreadChannel>;
+    static send(channelId: string, content: string): Promise<Message>;
+    static send(channelId: string, component: SendableComponent | SendableComponent[]): Promise<Message>;
+    static send(channelId: string, options: MessageCreateOptions): Promise<Message>;
+}
+
+declare class GuildVoiceChannelManager extends GuildChannelManager {
+    static findInGuild(guildId: string, channelId: string): Promise<VoiceChannel | null>;
+    static find(channelId: string): Promise<VoiceChannel | null>;
+    static findAll(guildId: string): VoiceChannel[];
+    static create(guildId: string, name: string, options?: Omit<GuildChannelCreateOptions, 'type'>): Promise<VoiceChannel>;
+}
+
+declare class GuildChannelList {
+    static readonly forum: typeof ForumChannelManager;
+    static readonly any: typeof GuildChannelManager;
+    static readonly news: typeof NewsChannelManager;
+    static readonly stage: typeof StageChannelManager;
+    static readonly text: typeof GuildTextChannelManager;
+    static readonly thread: typeof ThreadChannelManager;
+    static readonly voice: typeof GuildVoiceChannelManager;
+}
+
+declare class InviteManager {
+    /**
+     * Create an invite for a channel
+     */
+    static create(channelId: string, options?: {
+        maxAge?: number;
+        maxUses?: number;
+        reason?: string;
+        temporary?: boolean;
+    }): Promise<Invite>;
+    /**
+     * Delete an invitation
+     */
+    static delete(invite: Invite): Promise<boolean>;
+    /**
+     * List every invitation from a guild
+     */
+    static list(guildId: string): Promise<Invite[]>;
+}
+
+declare class GuildManager {
+    static readonly role: typeof RoleManager;
+    static readonly user: typeof GuildUserManager;
+    static readonly channel: typeof GuildChannelList;
+    static readonly invite: typeof InviteManager;
+    static list(): Guild[];
+    static find(guild_id: string): Promise<Guild>;
+    /**
+     * Search channel by ID (TextChannel, DMChannel, ThreadChannel)
+     */
+    static searchChannel(guildId: string, channelId: string): Promise<Channel | null>;
+    /**
+     * Search guild member by ID
+     */
+    static searchMember(memberId: string, guildId: string): Promise<GuildMember | null>;
+    /**
+     * Check if member is still in guild
+     */
+    static isMemberInGuild(memberId: string, guildId: string): Promise<boolean>;
+    /**
+     * Fetch all members with retry (heavy operation)
+     */
+    static fetchAllMembers(guildId: string | Guild, MAX_ATTEMPTS?: number, RETRY_DELAY?: number): Promise<Collection<string, GuildMember>>;
+    static listban(guildId: string, limit?: number): Promise<GuildBan[]>;
+    static moveMember(memberId: string, fromChannelId: string, toChannelId: string): Promise<boolean>;
+}
+
+declare class UserManager extends BasicUserManager {
+    static find(userId: string): Promise<User | null>;
+}
+
+declare class ModalManager {
+    /**
+     * Load modal from JSON file and return ModalBuilder
+     */
+    static load(filename: string): Promise<ModalBuilder | false>;
+    /**
+     * List all modal files
+     */
+    static list(): Promise<string[] | false>;
+    private static jsonToBuilder;
+    private static fieldJsonToInput;
+    static parseNumber(value: string): number | null;
+    static parsePhone(value: string): string | null;
+    static parseDate(value: string): Date | null;
+}
+
+type SelectMenuCreateOption = {
+    label: string;
+    description?: string;
+    emoji?: string;
+    value: string;
+};
+declare class SelectMenuManager {
+    /**
+     * Creates base StringSelectMenu - SIMPLE API !
+     */
+    static create(customId: string, placeholder?: string): StringSelectMenuBuilder;
+    /**
+     * Quick StringSelectMenu
+     */
+    static simple(customId: string, options: SelectMenuCreateOption[], placeholder?: string): StringSelectMenuBuilder;
+    /**
+     * Pagination menu
+     */
+    static paginated(customId: string, options: SelectMenuCreateOption[], pageSize?: number): ActionRowBuilder<MessageActionRowComponentBuilder>;
+    /**
+     * User Select Menu (Components V2)
+     */
+    static users(customId: string, placeholder?: string): UserSelectMenuBuilder;
+    /**
+     * Role Select Menu (Components V2)
+     */
+    static roles(customId: string, placeholder?: string): RoleSelectMenuBuilder;
+    /**
+     * Mentionable Select Menu (Components V2)
+     */
+    static mentionables(customId: string, placeholder?: string): MentionableSelectMenuBuilder;
+    /**
+     * Channel Select Menu (Components V2)
+     */
+    static channels(customId: string, placeholder?: string, channelTypes?: ChannelType[]): ChannelSelectMenuBuilder;
+    /**
+     * Quick option creator
+     */
+    static option(option: SelectMenuCreateOption): StringSelectMenuOptionBuilder;
+    static option(options: SelectMenuCreateOption[]): StringSelectMenuOptionBuilder[];
+    private static _createOption;
+    /**
+     * Fluent API pour personnaliser
+     */
+    static placeholder(menu: StringSelectMenuBuilder, placeholder: string): StringSelectMenuBuilder;
+    static minMax(menu: StringSelectMenuBuilder, min: number, max: number): StringSelectMenuBuilder;
+    static disabled(menu: StringSelectMenuBuilder, disabled: boolean): StringSelectMenuBuilder;
+    /**
+     * ActionRow
+     */
+    static row<T extends MessageActionRowComponentBuilder>(component: T): ActionRowBuilder<MessageActionRowComponentBuilder>;
+    /**
+     * Rows multiples (5 max)
+     */
+    static rows(...components: MessageActionRowComponentBuilder[]): ActionRowBuilder<MessageActionRowComponentBuilder>[];
+}
+
+declare class UnitTime {
+    private readonly val;
+    constructor(val: number);
+    toMilliseconds(): number;
+    toSeconds(): number;
+    toMinutes(): number;
+    toHours(): number;
+    toDays(): number;
+    toString(): string;
+    valueOf(): number;
+    value(): number;
+}
+declare const Time: {
+    milisecond: {
+        MS_100: UnitTime;
+        MS_200: UnitTime;
+        MS_500: UnitTime;
+        MS_800: UnitTime;
+        MS_1000: UnitTime;
+    };
+    second: {
+        SEC_01: UnitTime;
+        SEC_02: UnitTime;
+        SEC_03: UnitTime;
+        SEC_04: UnitTime;
+        SEC_05: UnitTime;
+        SEC_06: UnitTime;
+        SEC_07: UnitTime;
+        SEC_08: UnitTime;
+        SEC_09: UnitTime;
+        SEC_10: UnitTime;
+        SEC_11: UnitTime;
+        SEC_12: UnitTime;
+        SEC_13: UnitTime;
+        SEC_14: UnitTime;
+        SEC_15: UnitTime;
+        SEC_16: UnitTime;
+        SEC_17: UnitTime;
+        SEC_18: UnitTime;
+        SEC_19: UnitTime;
+        SEC_20: UnitTime;
+        SEC_21: UnitTime;
+        SEC_22: UnitTime;
+        SEC_23: UnitTime;
+        SEC_24: UnitTime;
+        SEC_25: UnitTime;
+        SEC_26: UnitTime;
+        SEC_27: UnitTime;
+        SEC_28: UnitTime;
+        SEC_29: UnitTime;
+        SEC_30: UnitTime;
+        SEC_31: UnitTime;
+        SEC_32: UnitTime;
+        SEC_33: UnitTime;
+        SEC_34: UnitTime;
+        SEC_35: UnitTime;
+        SEC_36: UnitTime;
+        SEC_37: UnitTime;
+        SEC_38: UnitTime;
+        SEC_39: UnitTime;
+        SEC_40: UnitTime;
+        SEC_41: UnitTime;
+        SEC_42: UnitTime;
+        SEC_43: UnitTime;
+        SEC_44: UnitTime;
+        SEC_45: UnitTime;
+        SEC_46: UnitTime;
+        SEC_47: UnitTime;
+        SEC_48: UnitTime;
+        SEC_49: UnitTime;
+        SEC_50: UnitTime;
+        SEC_51: UnitTime;
+        SEC_52: UnitTime;
+        SEC_53: UnitTime;
+        SEC_54: UnitTime;
+        SEC_55: UnitTime;
+        SEC_56: UnitTime;
+        SEC_57: UnitTime;
+        SEC_58: UnitTime;
+        SEC_59: UnitTime;
+        SEC_60: UnitTime;
+    };
+    minute: {
+        MIN_01: UnitTime;
+        MIN_02: UnitTime;
+        MIN_03: UnitTime;
+        MIN_04: UnitTime;
+        MIN_05: UnitTime;
+        MIN_06: UnitTime;
+        MIN_07: UnitTime;
+        MIN_08: UnitTime;
+        MIN_09: UnitTime;
+        MIN_10: UnitTime;
+        MIN_11: UnitTime;
+        MIN_12: UnitTime;
+        MIN_13: UnitTime;
+        MIN_14: UnitTime;
+        MIN_15: UnitTime;
+        MIN_16: UnitTime;
+        MIN_17: UnitTime;
+        MIN_18: UnitTime;
+        MIN_19: UnitTime;
+        MIN_20: UnitTime;
+        MIN_21: UnitTime;
+        MIN_22: UnitTime;
+        MIN_23: UnitTime;
+        MIN_24: UnitTime;
+        MIN_25: UnitTime;
+        MIN_26: UnitTime;
+        MIN_27: UnitTime;
+        MIN_28: UnitTime;
+        MIN_29: UnitTime;
+        MIN_30: UnitTime;
+        MIN_31: UnitTime;
+        MIN_32: UnitTime;
+        MIN_33: UnitTime;
+        MIN_34: UnitTime;
+        MIN_35: UnitTime;
+        MIN_36: UnitTime;
+        MIN_37: UnitTime;
+        MIN_38: UnitTime;
+        MIN_39: UnitTime;
+        MIN_40: UnitTime;
+        MIN_41: UnitTime;
+        MIN_42: UnitTime;
+        MIN_43: UnitTime;
+        MIN_44: UnitTime;
+        MIN_45: UnitTime;
+        MIN_46: UnitTime;
+        MIN_47: UnitTime;
+        MIN_48: UnitTime;
+        MIN_49: UnitTime;
+        MIN_50: UnitTime;
+        MIN_51: UnitTime;
+        MIN_52: UnitTime;
+        MIN_53: UnitTime;
+        MIN_54: UnitTime;
+        MIN_55: UnitTime;
+        MIN_56: UnitTime;
+        MIN_57: UnitTime;
+        MIN_58: UnitTime;
+        MIN_59: UnitTime;
+        MIN_60: UnitTime;
+    };
+    hour: {
+        HOUR_01: UnitTime;
+        HOUR_02: UnitTime;
+        HOUR_03: UnitTime;
+        HOUR_04: UnitTime;
+        HOUR_05: UnitTime;
+        HOUR_06: UnitTime;
+        HOUR_07: UnitTime;
+        HOUR_08: UnitTime;
+        HOUR_09: UnitTime;
+        HOUR_10: UnitTime;
+        HOUR_11: UnitTime;
+        HOUR_12: UnitTime;
+        HOUR_13: UnitTime;
+        HOUR_14: UnitTime;
+        HOUR_15: UnitTime;
+        HOUR_16: UnitTime;
+        HOUR_17: UnitTime;
+        HOUR_18: UnitTime;
+        HOUR_19: UnitTime;
+        HOUR_20: UnitTime;
+        HOUR_21: UnitTime;
+        HOUR_22: UnitTime;
+        HOUR_23: UnitTime;
+        HOUR_24: UnitTime;
+    };
+    day: {
+        DAY_01: UnitTime;
+        DAY_02: UnitTime;
+        DAY_03: UnitTime;
+        DAY_04: UnitTime;
+        DAY_05: UnitTime;
+        DAY_06: UnitTime;
+        DAY_07: UnitTime;
+        DAY_08: UnitTime;
+        DAY_09: UnitTime;
+        DAY_10: UnitTime;
+    };
+    readonly DAY: boolean;
+    readonly NIGHT: boolean;
+};
+
+declare class Log {
+    private static getPrefix;
+    static info(message: string): void;
+    static warn(message: string): void;
+    static error(message: string): void;
+    static debug(message: string): void;
+    static table(data: Record<string, any>[]): void;
+}
+
+declare class SimpleMutex {
+    private _locked;
+    private queue;
+    constructor();
+    /**
+     * Verrouille le mutex. Si le mutex est déjà verrouillé, la méthode retourne une promesse qui sera résolue une fois que le mutex sera disponible.
+     * @returns Une promesse résolue lorsque le mutex est verrouillé.
+     */
+    lock(): Promise<void>;
+    /**
+     * Déverrouille le mutex. Si une file d'attente existe, débloque le prochain élément dans la file.
+     */
+    unlock(): void;
+    get locked(): boolean;
+}
+
+/**
+ * Classe utilitaire pour valider tous les formats Discord avec regex
+ */
+declare class DiscordRegex {
+    static readonly SPACE = "\u200B";
+    static readonly URL_REGEX: RegExp;
+    static readonly USER_REGEX: RegExp;
+    static readonly BOT_REGEX: RegExp;
+    static readonly CHANNEL_REGEX: RegExp;
+    static readonly ROLE_REGEX: RegExp;
+    /**
+     * Mention a User
+     * Mention a Role
+     */
+    static readonly DISCORD_PING_REGEX: RegExp;
+    /**
+     * Mention a User
+     * Mention a Role
+     * Mention a Channel
+     */
+    static readonly DISCORD_MENTION_REGEX: RegExp;
+    static readonly USER_ID: RegExp;
+    static readonly CHANNEL_ID: RegExp;
+    static readonly GUILD_ID: RegExp;
+    static readonly BOT_ID: RegExp;
+    static readonly USERNAME: RegExp;
+    static readonly USERNAME_DISCRIM: RegExp;
+    static readonly CHANNEL_MENTION: RegExp;
+    static readonly USER_MENTION: RegExp;
+    static readonly ROLE_MENTION: RegExp;
+    static readonly INVITE: RegExp;
+    static readonly EMOJI: RegExp;
+    /**
+     * Validate Discord ID Discord (18)
+     */
+    static isDiscordId(id: string): boolean;
+    /**
+     * Validate a bot ID (19)
+     */
+    static isBotMention(mention: string): boolean;
+    /**
+     * Validate a User ping
+     */
+    static isUserMention(mention: string): boolean;
+    /**
+     * Validate a Discord username
+     */
+    static isUsername(username: string): boolean;
+    /**
+     * Type guard for Discord ID
+     */
+    static isDiscordIdType(id: string): id is string;
+    /**
+     * Any Discord URL
+     */
+    static isDiscordUrl(url: string): boolean;
+    /**
+     * Any discord mention
+     */
+    static isAnyMention(text: string): boolean;
+    /**
+     * List all regex
+     */
+    static listAll(): Record<string, RegExp | string>;
+}
+
+declare const SimpleDiscordBotInfo: {
+    name: string;
+    version: string;
+    author: string;
+    description: string;
+    license: string;
+};
+
+export { Bot, type BotConfig, BotEnv, DiscordRegex, EmbedColor, EmbedManager, FileManager, GuildManager, Log, ModalManager, type RandomBotActivity, ReactionManager, SelectMenuManager, SimpleDiscordBotInfo, SimpleMutex, Time, UserManager, WebhookManager };