@spatulox/simplediscordbot 1.0.4 → 1.0.6

package/dist/bot/Bot.d.ts

@@ -0,0 +1,32 @@
+import { Client, ActivityType } from 'discord.js';
+import { BotLog, ConfigLog } from "./BotLog";
+import { EmbedColor } from "../manager/messages/EmbedManager";
+import { BotMessage } from "./BotMessage";
+export type BotConfig = {
+    botIconUrl?: string;
+    defaultEmbedColor?: number | EmbedColor;
+    botName?: string;
+    log?: ConfigLog;
+};
+export type InternalBotConfig = {
+    clientId: string;
+} & BotConfig;
+export type RandomBotActivity = {
+    type: ActivityType;
+    message: string;
+}[];
+export declare class Bot {
+    static _client: Client;
+    static readonly log: typeof BotLog;
+    static readonly message: BotMessage;
+    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;
+}

package/dist/bot/BotEnv.d.ts

@@ -0,0 +1,5 @@
+export declare const BotEnv: {
+    readonly token: string;
+    readonly dev: boolean;
+    readonly clientId: string;
+};

package/dist/bot/BotLog.d.ts

@@ -0,0 +1,51 @@
+import { EmbedBuilder, Message } from 'discord.js';
+export 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;
+    };
+};
+export 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 sendLog(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send ERROR log - TEXT or EMBED ! Respecte config.log.error
+     */
+    static sendError(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send WARNING log - TEXT or EMBED ! Respecte config.log.warn
+     */
+    static sendWarn(content: string | EmbedBuilder): Promise<Message | void>;
+    /**
+     * Send DEBUG log - TEXT or EMBED ! Respecte config.log.debug
+     */
+    static sendDebug(content: string | EmbedBuilder): Promise<Message | void>;
+}

package/dist/bot/BotMessage.d.ts

@@ -0,0 +1,16 @@
+import { TextChannel, DMChannel, ThreadChannel, EmbedBuilder, Message, User, GuildMember } from 'discord.js';
+export declare class BotMessage {
+    /**
+     * Send message to any text-based channel
+     */
+    send(channel: TextChannel | DMChannel | ThreadChannel | string, content: string | EmbedBuilder): Promise<Message | boolean>;
+    sendDM(user: User | GuildMember | string, content: string | EmbedBuilder): Promise<Message | boolean>;
+    /**
+     * Quick success message
+     */
+    success(channel: TextChannel | DMChannel | ThreadChannel | User | GuildMember, message: string): Promise<Message | boolean>;
+    /**
+     * Quick error message
+     */
+    error(channel: TextChannel | DMChannel | ThreadChannel | User | GuildMember, message: string): Promise<Message | boolean>;
+}

package/dist/cli/BaseCLI.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import readline from "readline";
+export type MenuSelectionCLI = {
+    label: string;
+    action: () => BaseCLI | Promise<any> | null;
+}[];
+/**
+ * --- BaseCLI ---
+ */
+export declare abstract class BaseCLI {
+    protected parent?: BaseCLI | undefined;
+    private static _rl;
+    protected get rl(): readline.Interface;
+    constructor(parent?: BaseCLI | undefined);
+    protected abstract readonly menuSelection: MenuSelectionCLI;
+    protected abstract execute(): Promise<void>;
+    protected getTitle(): string;
+    protected showMainMenu(): Promise<void>;
+    protected prompt(question: string): Promise<string>;
+    protected requireInput(message: string, validator?: (val: string) => boolean, canBeEmpty?: boolean): Promise<string>;
+    protected yesNoInput(message: string): Promise<boolean>;
+    protected showHelp(): Promise<void>;
+    protected goBack(): Promise<void>;
+    protected saveFile<T>(folderName: string, filename: string, data: T): Promise<void>;
+}

package/dist/cli/GenerationCLI/ContextMenuGeneratorCLI.d.ts

@@ -0,0 +1,6 @@
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+export declare class ContextMenuGeneratorCLI extends BaseCLI {
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+}

package/dist/cli/GenerationCLI/GenerationCLI.d.ts

@@ -0,0 +1,6 @@
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+export declare class GenerationCLI extends BaseCLI {
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+}

package/dist/cli/GenerationCLI/ModalGeneratorCLI.d.ts

@@ -0,0 +1,44 @@
+import { ModalBuilder } from "discord.js";
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+export interface ModalCreateOption {
+    title: string;
+    customId: string;
+    label: string;
+    fields: ModalField[];
+}
+export interface ModalField {
+    title: string;
+    customId: string;
+    style: ModalFieldStyle;
+    placeholder?: string;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+}
+export interface SimpleModalCreateOption {
+    customId: string;
+    title: string;
+    label: string;
+    placeholder?: string;
+}
+export declare enum ModalFieldStyle {
+    Short = 1,
+    Paragraph = 2,
+    Number = "Number",
+    Phone = "Phone",
+    Date = "Date"
+}
+export declare class ModalGeneratorCLI extends BaseCLI {
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+    /**
+     * Create modal from declarative config - SIMPLE API !
+     */
+    static create(options: ModalCreateOption): ModalBuilder;
+    private static buildInput;
+    /**
+     * Quick helpers
+     */
+    static simple(option: SimpleModalCreateOption): ModalBuilder;
+}

package/dist/cli/GenerationCLI/SlashCommandsGeneratorCLI.d.ts

@@ -0,0 +1,12 @@
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+export declare class SlashCommandGeneratorCLI extends BaseCLI {
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+    private addCommandStructure;
+    private addSubCommands;
+    private addSubCommandOptions;
+    private addChoices;
+    private addChannelTypes;
+    private addSimpleOptions;
+}

package/dist/cli/GuildListManager.d.ts

@@ -0,0 +1,24 @@
+import { BaseCLI, MenuSelectionCLI } from "./BaseCLI";
+import { REST } from "@discordjs/rest";
+import { GuildFeature } from 'discord-api-types/v10';
+export type Guild = {
+    id: string;
+    name: string;
+    icon: string | null;
+    banner: string | null;
+    owner: boolean;
+    permissions: string;
+    features: GuildFeature[];
+};
+export declare class GuildListManager extends BaseCLI {
+    protected guilds: Guild[];
+    protected clientId: string;
+    protected token: string;
+    protected rest: REST;
+    constructor(clientId: string, token: string);
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+    list(printResult?: boolean): Promise<Guild[]>;
+    chooseGuild(): Promise<Guild | null>;
+}

package/dist/cli/InteractionCLI/InteractionCLI.d.ts

@@ -0,0 +1,8 @@
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+export declare class InteractionCLI extends BaseCLI {
+    private managers;
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    constructor(parent?: BaseCLI);
+    protected execute(): Promise<void>;
+}

package/dist/cli/InteractionCLI/InteractionCLIManager.d.ts

@@ -0,0 +1,17 @@
+import { BaseCLI, MenuSelectionCLI } from "../BaseCLI";
+import { BaseInteractionManager } from "../../manager/handlers/interactions/BaseInteractionManager";
+export declare class InteractionManagerCLI extends BaseCLI {
+    protected readonly manager: BaseInteractionManager;
+    protected readonly managerKey: string;
+    protected getTitle(): string;
+    protected readonly menuSelection: MenuSelectionCLI;
+    constructor(parent: BaseCLI, manager: BaseInteractionManager, managerKey: string);
+    protected execute(): Promise<void>;
+    private listRemote;
+    private guildListRemote;
+    private guildListAllRemote;
+    private handleDeploy;
+    private handleUpdate;
+    private handleDelete;
+    private selectCommands;
+}

package/dist/cli/MainCLI.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { BaseCLI, MenuSelectionCLI } from "./BaseCLI";
+/**
+ * --- MainCLI ---
+ * Main controller for sub menu
+ */
+export declare class MainCLI extends BaseCLI {
+    protected getTitle(): string;
+    constructor();
+    protected readonly menuSelection: MenuSelectionCLI;
+    protected execute(): Promise<void>;
+}

package/dist/cli/type/ContextMenuConfig.d.ts

@@ -0,0 +1,12 @@
+import { PermissionFlagsBits } from "discord.js";
+import { InteractionContextType, InteractionIntegrationType } from "./InteractionType";
+export interface ContextMenuConfig {
+    name: string;
+    type: 2 | 3;
+    type_comment?: Array<string>;
+    default_member_permissions?: Array<(keyof typeof PermissionFlagsBits)>;
+    dm_permission: boolean;
+    integration_types: InteractionIntegrationType[];
+    contexts?: InteractionContextType[];
+    guildID?: Array<string>;
+}

package/dist/cli/type/InteractionType.d.ts

@@ -0,0 +1,9 @@
+export declare enum InteractionIntegrationType {
+    GUILD_INSTALL = 0,
+    USER_INSTALL = 1
+}
+export declare enum InteractionContextType {
+    SERVER_CHANNEL = 0,
+    BOT_DM = 1,
+    GROUP_DM = 2
+}

package/dist/cli/type/SlashCommandConfig.d.ts

@@ -0,0 +1,43 @@
+import { PermissionFlagsBits } from "discord.js";
+import { InteractionContextType, InteractionIntegrationType } from "./InteractionType";
+export type DiscordCommandType = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export type PermissionString = keyof typeof PermissionFlagsBits | string;
+export interface Choice {
+    name: string;
+    value: string;
+}
+export interface Option {
+    type: DiscordCommandType;
+    name: string;
+    description: string;
+    required?: boolean;
+    choices?: Choice[];
+    min_length?: number;
+    max_length?: number;
+    min_value?: number;
+    max_value?: number;
+    channel_types?: number[];
+    autocomplete?: boolean;
+}
+export interface CommandOption extends Option {
+    options?: CommandOption[];
+}
+export interface SlashCommandConfig {
+    name: string;
+    description: string;
+    type: 1;
+    options?: CommandOption[];
+    default_member_permissions?: PermissionString[];
+    default_member_permissions_string?: PermissionString[];
+    dm_permission: boolean;
+    integration_types: InteractionIntegrationType[];
+    contexts: InteractionContextType[];
+    guildID?: string[];
+}
+export interface ServerManagementCommandConfig {
+    name: string;
+    type: 1;
+    description: string;
+    permissions?: PermissionString[];
+    options: CommandOption[];
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { Bot } from "./bot/Bot";
+export { BotEnv } from "./bot/BotEnv";
+export { FileManager } from './manager/FileManager';
+export { EmbedManager, EmbedColor } from './manager/messages/EmbedManager';
+export { WebhookManager } from './manager/messages/WebhookManager';
+export { ReactionManager } from "./manager/messages/ReactionManager";
+export { GuildManager } from "./manager/guild/GuildManager";
+export { UserManager } from './manager/direct/UserManager';
+export { ModalManager } from "./manager/handlers/builder/ModalManager";
+export { Time } from "./utils/times/UnitTime";
+export { Log } from "./utils/Log";
+export { SimpleMutex } from "./utils/SimpleMutex";
+export { DiscordRegex } from "./utils/DiscordRegex";
+export type { BotConfig, RandomBotActivity } from './bot/Bot';

package/dist/manager/FileManager.d.ts

@@ -0,0 +1,36 @@
+export 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>;
+}

package/dist/manager/direct/UserManager.d.ts

@@ -0,0 +1,23 @@
+import { EmbedBuilder, GuildMember, Message, MessageCreateOptions, User } from "discord.js";
+export declare class UserManager {
+    /**
+     * Find a member
+     */
+    static find(userId: string): Promise<User | null>;
+    /**
+     * 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_id: string, embed: EmbedBuilder): Promise<Message>;
+    static send(user: User, embed: EmbedBuilder): Promise<Message>;
+    static send(user_id_or_user: string | User, options: MessageCreateOptions): Promise<Message>;
+}

package/dist/manager/guild/ChannelManager/ForumChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { GuildChannelManager } from "./GuildChannelManager";
+import { ForumChannel, GuildChannelCreateOptions } from "discord.js";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/GuildChannelList.d.ts

@@ -0,0 +1,16 @@
+import { GuildChannelManager } from "./GuildChannelManager";
+import { ForumChannelManager } from "./ForumChannelManager";
+import { NewsChannelManager } from "./NewsChannelManager";
+import { StageChannelManager } from "./StageChannelManager";
+import { GuildTextChannelManager } from "./GuildTextChannelManager";
+import { ThreadChannelManager } from "./ThreadChannelManager";
+import { GuildVoiceChannelManager } from "./GuildVoiceChannelManager";
+export 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;
+}

package/dist/manager/guild/ChannelManager/GuildChannelManager.d.ts

@@ -0,0 +1,17 @@
+import { GuildBasedChannel, GuildChannelCreateOptions } from 'discord.js';
+import { GuildMessageManager } from "./GuildMessageManager";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/GuildMessageManager.d.ts

@@ -0,0 +1,21 @@
+import { EmbedBuilder, Message, MessageCreateOptions } from "discord.js";
+export declare class GuildMessageManager {
+    /**
+     * Overloads for send
+     */
+    static send(channelId: string, content: string): Promise<Message>;
+    static send(channelId: string, embed: EmbedBuilder): 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>;
+}

package/dist/manager/guild/ChannelManager/GuildTextChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { TextChannel, GuildChannelCreateOptions } from "discord.js";
+import { GuildChannelManager } from "./GuildChannelManager";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/GuildVoiceChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { GuildChannelCreateOptions, VoiceChannel } from "discord.js";
+import { GuildChannelManager } from "./GuildChannelManager";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/NewsChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { GuildChannelCreateOptions, NewsChannel } from "discord.js";
+import { GuildChannelManager } from "./GuildChannelManager";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/StageChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { GuildChannelCreateOptions, StageChannel } from "discord.js";
+import { GuildChannelManager } from "./GuildChannelManager";
+export 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>;
+}

package/dist/manager/guild/ChannelManager/ThreadChannelManager.d.ts

@@ -0,0 +1,8 @@
+import { Message, StartThreadOptions, ThreadChannel } from "discord.js";
+export 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>;
+}

package/dist/manager/guild/GuildManager.d.ts

@@ -0,0 +1,30 @@
+import { GuildMember, Collection, Guild, GuildBan, Channel } from 'discord.js';
+import { GuildUserManager } from "./GuildUserManager";
+import { RoleManager } from "./RoleManager";
+import { GuildChannelList } from "./ChannelManager/GuildChannelList";
+import { InviteManager } from "./InviteManager";
+export 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[];
+    /**
+     * 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, 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>;
+}

package/dist/manager/guild/GuildUserManager.d.ts

@@ -0,0 +1,46 @@
+import { UserManager } from "../direct/UserManager";
+import { BanOptions } from "discord.js";
+export declare class GuildUserManager extends UserManager {
+    /**
+     * 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>;
+}

package/dist/manager/guild/InviteManager.d.ts

@@ -0,0 +1,20 @@
+import { Invite } from 'discord.js';
+export 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[]>;
+}

package/dist/manager/guild/InviteManager_old.d.ts

@@ -0,0 +1,23 @@
+import { Invite, Collection } from 'discord.js';
+export declare class InviteManager {
+    /**
+     * Check if invite is old (more than 1 hour)
+     */
+    static isOld(invite: Invite, excludedInvite?: string[]): boolean;
+    /**
+     * Delete single invite
+     */
+    static delete(invite: Invite): Promise<boolean>;
+    /**
+     * Delete all old invites from guild
+     */
+    static cleanupGuild(guildId: string): Promise<number>;
+    /**
+     * Get all invites from guild
+     */
+    static fetchGuildInvites(guildId: string): Promise<Collection<string, Invite>>;
+    /**
+     * Get old invites only
+     */
+    static getOldInvites(invites: Collection<string, Invite>): Invite[];
+}

package/dist/manager/guild/RoleManager.d.ts

@@ -0,0 +1,23 @@
+import { GuildMember, Snowflake } from 'discord.js';
+export 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;
+}

package/dist/manager/handlers/builder/ModalManager.d.ts

@@ -0,0 +1,22 @@
+import { ModalBuilder } from "discord.js";
+export interface ModalJson {
+    title: string;
+    customId: string;
+    label: string;
+    fields: any[];
+}
+export 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;
+}

package/dist/manager/handlers/interactions/BaseInteractionManager.d.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { REST } from '@discordjs/rest';
+import { Guild } from "../../../cli/GuildListManager";
+export interface Command {
+    name: string;
+    description: string;
+    options?: any[];
+    default_member_permissions?: string | bigint | number;
+    default_member_permissions_string?: string[];
+    guildID?: string[];
+    type: CommandType;
+    id?: string;
+    filename?: string;
+}
+export declare enum CommandType {
+    SLASH = 1,
+    USER_CONTEXT_MENU = 2,
+    MESSAGE_CONTEXT_MENU = 3
+}
+export declare abstract class BaseInteractionManager {
+    abstract folderPath: string | undefined;
+    abstract commandType: number[];
+    protected clientId: string;
+    protected token: string;
+    protected rest: REST;
+    constructor(clientId: string, token: string);
+    listFromFile(): Promise<Command[]>;
+    private fetchCommands;
+    list(): Promise<Command[]>;
+    listGuild(guildID: string): Promise<Command[]>;
+    listAllGuilds(guilds: Guild[]): Promise<{
+        guild: string;
+        commands: Command[];
+    }[]>;
+    deploy(commands: Command[]): Promise<void>;
+    delete(commands: Command[]): Promise<void>;
+    update(commands: Command[]): Promise<void>;
+    private deploySingleInteraction;
+    private readInteraction;
+    private saveInteraction;
+    private removeLocalIdFromFile;
+    private permissionsToBitfield;
+    private bitfieldToPermissions;
+}

package/dist/manager/handlers/interactions/InteractionManager.d.ts

@@ -0,0 +1,14 @@
+import { BaseInteractionManager } from "./BaseInteractionManager";
+import { FolderName } from "../../../type/FolderName";
+export declare class CommandManager extends BaseInteractionManager {
+    commandType: number[];
+    folderPath: FolderName;
+}
+export declare class ContextMenuManager extends BaseInteractionManager {
+    commandType: number[];
+    folderPath: FolderName;
+}
+export declare class AllInteractionManager extends BaseInteractionManager {
+    commandType: number[];
+    folderPath: undefined;
+}

package/dist/manager/messages/EmbedManager.d.ts

@@ -0,0 +1,83 @@
+import { EmbedBuilder, InteractionDeferReplyOptions } from "discord.js";
+export 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
+}
+export 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;
+    /**
+     * 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;
+}

package/dist/manager/messages/ReactionManager.d.ts

@@ -0,0 +1,25 @@
+import { User, EmojiResolvable } from 'discord.js';
+export 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[];
+}
+export {};

package/dist/manager/messages/WebhookManager.d.ts

@@ -0,0 +1,29 @@
+import { TextChannel, EmbedBuilder, Message, ThreadChannel, MessageCreateOptions } from 'discord.js';
+export 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/embed - EmbedBuilder NATIVE !
+     */
+    send(content: string | EmbedBuilder | MessageCreateOptions): 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>;
+}

package/dist/type/FolderName.d.ts

@@ -0,0 +1,5 @@
+export declare enum FolderName {
+    SLASH_COMMANDS = "commands",
+    CONTEXT_MENU = "context_menu",
+    MODAL = "modals"
+}

package/dist/utils/DiscordRegex.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Classe utilitaire pour valider tous les formats Discord avec regex
+ */
+export 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>;
+}

package/dist/utils/Log.d.ts

@@ -0,0 +1,8 @@
+export 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;
+}

package/dist/utils/SimpleMutex.d.ts

@@ -0,0 +1,15 @@
+export 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;
+}

package/dist/utils/network/InternetChecker.d.ts

@@ -0,0 +1,9 @@
+export declare class InternetChecker {
+    private static readonly TARGET;
+    private static readonly RETRY_TIME;
+    /**
+     * Check internet connection towards 1.1.1.1 (Cloudflare DNS)
+     * @param tries Number of attempts (0 = infini)
+     */
+    static checkConnection(tries?: number): Promise<boolean>;
+}

package/dist/utils/times/UnitTime.d.ts

@@ -0,0 +1,186 @@
+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;
+}
+export 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;
+};
+export {};

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@spatulox/simplediscordbot",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "author": "Spatulox",
   "description": "Simple discord bot framework to set up a bot under 30 secondes",
-  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
   "bin": {
     "sdb": "dist/cli/MainCLI.js"
   },

package/.env.example

@@ -1,2 +0,0 @@
-DISCORD_BOT_TOKEN=example
-DISCORD_BOT_DEV # Define this one with anything you want, the value is not important as long as the env var is defined