@spatulox/simplediscordbot 1.0.1

package/dist/manager/guild/GuildManager.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildManager = void 0;
+const discord_js_1 = require("discord.js");
+const Log_1 = require("../../utils/Log");
+const UnitTime_1 = require("../../utils/times/UnitTime");
+const GuildUserManager_1 = require("./GuildUserManager");
+const Bot_1 = require("../../bot/Bot");
+const GuildChannelManager_1 = require("./ChannelManager/GuildChannelManager");
+const RoleManager_1 = require("./RoleManager");
+const GuildChannelList_1 = require("./ChannelManager/GuildChannelList");
+const InviteManager_1 = require("./InviteManager");
+class GuildManager {
+    static list() {
+        return Array.from(Bot_1.Bot.client.guilds.cache.values());
+    }
+    /**
+     * Search channel by ID (TextChannel, DMChannel, ThreadChannel)
+     */
+    static async searchChannel(guildId, channelId) {
+        try {
+            return await GuildChannelManager_1.GuildChannelManager.findInGuild(guildId, channelId);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch channel ${channelId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Search guild member by ID
+     */
+    static async searchMember(memberId, guildId) {
+        try {
+            return await this.user.findInGuild(guildId, guildId);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Check if member is still in guild
+     */
+    static async isMemberInGuild(memberId, guildId) {
+        try {
+            return await this.user.isInGuild(memberId, guildId);
+        }
+        catch (error) {
+            return error.code !== 10007; // Unknown Member
+        }
+    }
+    /**
+     * Fetch all members with retry (heavy operation)
+     */
+    static async fetchAllMembers(guildId, MAX_ATTEMPTS = 3, RETRY_DELAY = UnitTime_1.Time.minute.MIN_05.toMilliseconds()) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild)
+            throw new Error(`Guild ${guildId} not found`);
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                Log_1.Log.info(`UserManager: Fetching ${guild.name} members (attempt ${attempt})`);
+                return await guild.members.fetch();
+            }
+            catch (error) {
+                Log_1.Log.error(`UserManager: Fetch failed (attempt ${attempt}): ${error}`);
+                if (attempt < MAX_ATTEMPTS) {
+                    await new Promise(r => setTimeout(r, RETRY_DELAY));
+                }
+            }
+        }
+        throw new Error(`Failed to fetch members after ${MAX_ATTEMPTS} attempts`);
+    }
+    static async listban(guildId, limit) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            throw new Error(`Guild ${guildId} not found`);
+        }
+        try {
+            const bans = await guild.bans.fetch({ limit });
+            return Array.from(bans.values());
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to list bans in guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async moveMember(memberId, fromChannelId, toChannelId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.find(g => g.channels.cache.has(fromChannelId) || g.channels.cache.has(toChannelId));
+            if (!guild) {
+                throw new Error(`Guild containing channels ${fromChannelId} or ${toChannelId} not found`);
+            }
+            const member = await guild.members.fetch(memberId).catch(() => null);
+            if (!member) {
+                throw new Error(`Member ${memberId} not found in guild ${guild.id}`);
+            }
+            const fromChannel = guild.channels.cache.get(fromChannelId);
+            const toChannel = guild.channels.cache.get(toChannelId);
+            if (!fromChannel) {
+                throw new Error(`From channel ${fromChannelId} not found`);
+            }
+            if (!toChannel) {
+                throw new Error(`To channel ${toChannelId} not found`);
+            }
+            if (!(fromChannel instanceof discord_js_1.VoiceChannel || fromChannel instanceof discord_js_1.StageChannel)) {
+                throw new Error(`From channel ${fromChannelId} is not a voice/stage channel`);
+            }
+            if (!(toChannel instanceof discord_js_1.VoiceChannel || toChannel instanceof discord_js_1.StageChannel)) {
+                throw new Error(`To channel ${toChannelId} is not a voice/stage channel`);
+            }
+            if (member.voice.channelId !== fromChannelId) {
+                throw new Error(`Member ${memberId} is not in channel ${fromChannelId}`);
+            }
+            try {
+                await member.voice.setChannel(toChannel);
+                Log_1.Log.info(`Moved member ${memberId} from ${fromChannelId} to ${toChannelId}`);
+            }
+            catch (error) {
+                Log_1.Log.error(`Failed to move member ${memberId} from ${fromChannelId} to ${toChannelId}: ${error}`);
+                throw error;
+            }
+            return true;
+        }
+        catch (e) {
+            Log_1.Log.error(`Failed to move member ${e}`);
+            return false;
+        }
+    }
+}
+exports.GuildManager = GuildManager;
+GuildManager.role = RoleManager_1.RoleManager;
+GuildManager.user = GuildUserManager_1.GuildUserManager;
+GuildManager.channel = GuildChannelList_1.GuildChannelList;
+GuildManager.invite = InviteManager_1.InviteManager;

package/dist/manager/guild/GuildUserManager.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildUserManager = void 0;
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+const UserManager_1 = require("../direct/UserManager");
+class GuildUserManager extends UserManager_1.UserManager {
+    /**
+     * Check if user is banned from guild
+     */
+    static async isBanned(guildId, userId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                Log_1.Log.warn(`Guild ${guildId} not found`);
+                return false;
+            }
+            const ban = await guild.bans.fetch(userId);
+            return !!ban;
+        }
+        catch (error) {
+            Log_1.Log.debug(`User ${userId} is not banned from guild ${guildId}`);
+            return false;
+        }
+    }
+    /**
+     * Deconnect a member from a voice
+     */
+    static async deconnectFromVoice(guildId, memberId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                throw new Error(`Guild ${guildId} not found`);
+            }
+            const member = await guild.members.fetch(memberId);
+            if (!member.voice.channel) {
+                throw new Error(`Member ${memberId} is not in a voice channel`);
+            }
+            await member.voice.disconnect();
+            Log_1.Log.info(`Disconnected member ${memberId} from voice in guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to disconnect member ${memberId} from voice in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a member is in voice
+     */
+    static async isInVoice(memberId, guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                return false;
+            const member = await guild.members.fetch(memberId);
+            return member.voice.channelId !== null;
+        }
+        catch (error) {
+            Log_1.Log.debug(`Member ${memberId} not found or not in voice in guild ${guildId}`);
+            return false;
+        }
+    }
+    /**
+     * Mute a member
+     */
+    static async mute(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setMute(true, reason);
+            Log_1.Log.info(`Server muted ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server mute ${memberId} in ${guildId}:, error`);
+            throw error;
+        }
+    }
+    /**
+     * Unmute a member
+     */
+    static async unmute(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setMute(false, reason);
+            Log_1.Log.info(`Server unmuted ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server unmute ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Deafen a member
+     */
+    static async deafen(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setDeaf(true, reason);
+            Log_1.Log.info(`Server deafened ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server deafen ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Undeafen member voice
+     */
+    static async undeafen(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.voice.setDeaf(false, reason);
+            Log_1.Log.info(`Server undeafened ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to server undeafen ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Timeout a member
+     */
+    static async timeout(guildId, memberId, duration, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            const expires = Date.now() + duration;
+            await member.timeout(expires, reason);
+            Log_1.Log.info(`Timed out ${memberId} for ${duration}ms in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to timeout ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Remove the timeout of a member
+     */
+    static async untimeout(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.timeout(null, reason);
+            Log_1.Log.info(`Untimed out ${memberId} in guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to untimeout ${memberId} in ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Kick a member
+     */
+    static async kick(guildId, memberId, reason) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch(memberId);
+            await member.kick(reason);
+            Log_1.Log.info(`Kicked ${memberId} from guild ${guildId}: ${reason || 'No reason'}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to kick ${memberId} from ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async ban(guildId, userId, banOption) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            throw new Error(`Guild ${guildId} not found`);
+        }
+        try {
+            await guild.members.ban(userId, banOption);
+            Log_1.Log.info(`Banned user ${userId} from guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to ban user ${userId} from guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async unban(guildId, userId, reason) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            throw new Error(`Guild ${guildId} not found`);
+        }
+        try {
+            await guild.members.unban(userId, reason);
+            Log_1.Log.info(`Unbanned user ${userId} from guild ${guildId}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to unban user ${userId} from guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.GuildUserManager = GuildUserManager;

package/dist/manager/guild/InviteManager.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteManager = void 0;
+const Log_1 = require("../../utils/Log");
+const Bot_1 = require("../../bot/Bot");
+const GuildChannelManager_1 = require("./ChannelManager/GuildChannelManager");
+class InviteManager {
+    /**
+     * Create an invite for a channel
+     */
+    static async create(channelId, options = {}) {
+        try {
+            const channel = await GuildChannelManager_1.GuildChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            const guild = channel.guild;
+            const inviteOptions = {
+                maxAge: options.maxAge ?? 86400,
+                maxUses: options.maxUses ?? 0,
+                temporary: options.temporary ?? false,
+                reason: options.reason
+            };
+            // ✅ guild.invites.create(channelId, options)
+            const invite = await guild.invites.create(channelId, inviteOptions);
+            Log_1.Log.info(`Created invite ${invite.code} for channel ${channelId}`);
+            return invite;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to create invite for channel ${channelId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete an invitation
+     */
+    static async delete(invite) {
+        try {
+            await invite.delete();
+            Log_1.Log.info(`Deleted invite ${invite.code} from guild ${invite.guild?.id}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete invite ${invite.code}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * List every invitation from a guild
+     */
+    static async list(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                throw new Error(`Guild ${guildId} not found`);
+            }
+            const invites = await guild.invites.fetch();
+            const inviteList = Array.from(invites.values());
+            Log_1.Log.info(`Fetched ${inviteList.length} invites for guild ${guildId}`);
+            return inviteList;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch invites for guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.InviteManager = InviteManager;

package/dist/manager/guild/InviteManager_old.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteManager = void 0;
+const discord_js_1 = require("discord.js");
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+class InviteManager {
+    /**
+     * Check if invite is old (more than 1 hour)
+     */
+    static isOld(invite, excludedInvite = []) {
+        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000); // 1h
+        if (!invite.createdAt) {
+            return false;
+        }
+        return (invite.maxAge !== 0 &&
+            !excludedInvite.includes(invite.code) &&
+            invite.createdAt < oneHourAgo);
+    }
+    /**
+     * Delete single invite
+     */
+    static async delete(invite) {
+        try {
+            await invite.delete();
+            if (invite.createdAt) {
+                Log_1.Log.info(`🗑️ Deleted invite \`${invite.code}\` created ${invite.createdAt.toDateString()}`);
+                return true;
+            }
+            Log_1.Log.warn(`Invite ${invite.code} deleted but no createdAt`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete invite ${invite.code}: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Delete all old invites from guild
+     */
+    static async cleanupGuild(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                Log_1.Log.error(`Guild ${guildId} not found for invite cleanup`);
+                return 0;
+            }
+            const invites = await guild.invites.fetch();
+            let deletedCount = 0;
+            for (const [_code, invite] of invites) {
+                if (this.isOld(invite)) {
+                    const success = await this.delete(invite);
+                    if (success)
+                        deletedCount++;
+                    // Rate limit protection
+                    await new Promise(r => setTimeout(r, 100));
+                }
+            }
+            Log_1.Log.info(`Invite cleanup ${guild.name}: ${deletedCount} old invites deleted`);
+            return deletedCount;
+        }
+        catch (error) {
+            Log_1.Log.error(`Invite cleanup failed for ${guildId}: ${error}`);
+            return 0;
+        }
+    }
+    /**
+     * Get all invites from guild
+     */
+    static async fetchGuildInvites(guildId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            return await guild.invites.fetch();
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch invites for ${guildId}: ${error}`);
+            return new discord_js_1.Collection();
+        }
+    }
+    /**
+     * Get old invites only
+     */
+    static getOldInvites(invites) {
+        return invites.filter(invite => this.isOld(invite)).map(invite => invite);
+    }
+}
+exports.InviteManager = InviteManager;

package/dist/manager/guild/RoleManager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleManager = void 0;
+const Log_1 = require("../../utils/Log");
+class RoleManager {
+    /**
+     * Add role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleId - Role ID (string)
+     */
+    static async add(member, roleId) {
+        try {
+            const role = member.roles.cache.get(roleId);
+            if (!role) {
+                Log_1.Log.warn(`Role ${roleId} not found in cache`);
+                return false;
+            }
+            await member.roles.add(role);
+            Log_1.Log.info(`✅ Added ${role.name} to ${member.displayName}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to add role ${roleId}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Remove role - CACHE ONLY
+     * @param member - GuildMember ALREADY FETCHED
+     * @param roleIdOrName - Role ID or name
+     */
+    static async remove(member, roleIdOrName) {
+        try {
+            let role;
+            if (typeof roleIdOrName === 'string' && roleIdOrName.length === 18) {
+                role = member.roles.cache.get(roleIdOrName);
+            }
+            else {
+                role = member.roles.cache.find(r => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+            }
+            if (!role) {
+                Log_1.Log.warn(`Role ${roleIdOrName} not found for ${member.displayName}`);
+                return false;
+            }
+            await member.roles.remove(role);
+            Log_1.Log.info(`✅ Removed ${role.name} from ${member.displayName}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to remove role ${roleIdOrName}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Toggle role (add/remove)
+     */
+    static async toggle(member, roleIdOrName) {
+        const role = member.roles.cache.get(roleIdOrName) ||
+            member.roles.cache.find(r => r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+        if (!role) {
+            Log_1.Log.warn(`Role ${roleIdOrName} not found`);
+            throw new Error(`Role not found`);
+        }
+        if (member.roles.cache.has(role.id)) {
+            await this.remove(member, role.id);
+            return 'removed';
+        }
+        else {
+            await this.add(member, role.id);
+            return 'added';
+        }
+    }
+    /**
+     * Check if member has role
+     */
+    static hasRole(member, roleIdOrName) {
+        if (typeof roleIdOrName === 'string' && roleIdOrName.length === 18) {
+            return member.roles.cache.has(roleIdOrName);
+        }
+        return member.roles.cache.some(r => r.id === roleIdOrName || r.name.toLowerCase() === roleIdOrName.toString().toLowerCase());
+    }
+}
+exports.RoleManager = RoleManager;

package/dist/manager/hadlers_old/builder/ModalManager.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalManager = void 0;
+const discord_js_1 = require("discord.js");
+const Log_1 = require("../../../utils/Log");
+const FileManager_1 = require("../../FileManager");
+const MAX_COMPONENTS = 5;
+class ModalManager {
+    /**
+     * Load and build modal from JSON file
+     */
+    static async load(name) {
+        const formData = await FileManager_1.FileManager.readJsonFile(`./form/${name}.json`);
+        if (formData === 'Error') {
+            Log_1.Log.error(`Form ${name} not found!`);
+            return null;
+        }
+        if (!this.validateForm(formData)) {
+            Log_1.Log.error(`${name}.json is not a valid modal json`);
+            return null;
+        }
+        return this.buildModal(formData);
+    }
+    /**
+     * Validate form structure
+     */
+    static validateForm(form) {
+        if (!form?.title || typeof form.title !== 'string') {
+            Log_1.Log.error(`Form needs 'title' (string)`);
+            return false;
+        }
+        if (!form?.id || typeof form.id !== 'string') {
+            Log_1.Log.error(`Form needs 'id' (string)`);
+            return false;
+        }
+        if (!form?.inputs || !Array.isArray(form.inputs)) {
+            Log_1.Log.error(`Form needs 'inputs' array`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Build ModalBuilder from validated form
+     */
+    static buildModal(form) {
+        const modal = new discord_js_1.ModalBuilder()
+            .setCustomId(form.id)
+            .setTitle(form.title);
+        let componentCount = 0;
+        for (const input of form.inputs.slice(0, MAX_COMPONENTS)) {
+            if (!this.isValidInput(input)) {
+                Log_1.Log.error(`Invalid input in form '${form.title}'`);
+                continue;
+            }
+            const row = this.createInputRow(input);
+            modal.addComponents(row);
+            componentCount++;
+        }
+        if (form.inputs.length > MAX_COMPONENTS) {
+            Log_1.Log.warn(`Form '${form.title}': ${form.inputs.length} inputs → ${MAX_COMPONENTS} max, Discord will force hide the 5th+ component`);
+        }
+        return modal;
+    }
+    /**
+     * Validate single input
+     */
+    static isValidInput(input) {
+        const requiredFields = ['type', 'id', 'title'];
+        return requiredFields.every(field => input?.[field]);
+    }
+    /**
+     * Create ActionRowBuilder from input config
+     */
+    static createInputRow(input) {
+        let textInput = new discord_js_1.TextInputBuilder()
+            .setCustomId(input.id)
+            .setLabel(input.title)
+            .setRequired(input.required ?? false);
+        // Style mapping
+        const style = input.style === 'paragraph' ? discord_js_1.TextInputStyle.Paragraph : discord_js_1.TextInputStyle.Short;
+        textInput = textInput.setStyle(style);
+        // Type-specific options
+        switch (input.type) {
+            case 'text_placeholder':
+                textInput = textInput.setPlaceholder(input.placeholder ?? '');
+                break;
+            case 'text_minmax_length':
+                textInput = textInput
+                    .setMinLength(input.minLength ?? 0)
+                    .setMaxLength(input.maxLength ?? 4000);
+                break;
+            case 'number':
+                textInput = textInput
+                    .setStyle(discord_js_1.TextInputStyle.Short)
+                    .setPlaceholder('Enter a number');
+                break;
+            case 'date':
+                textInput = textInput
+                    .setStyle(discord_js_1.TextInputStyle.Short)
+                    .setPlaceholder('DD/MM/YYYY');
+                break;
+            case 'date-hour':
+                textInput = textInput
+                    .setStyle(discord_js_1.TextInputStyle.Short)
+                    .setPlaceholder('DD/MM/YYYY HH:MM');
+                break;
+        }
+        return new discord_js_1.ActionRowBuilder().addComponents(textInput);
+    }
+}
+exports.ModalManager = ModalManager;