@spatulox/simplediscordbot 1.0.24 → 1.0.26

package/dist/manager/direct/BasicUserManager.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicUserManager = void 0;
+const discord_js_1 = require("discord.js");
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+const SendableComponentBuilder_1 = require("../builder/SendableComponentBuilder");
+class BasicUserManager {
+    /**
+     * Find member in specific guild
+     */
+    static async findInGuild(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({ user: memberId, force: true });
+            return member ?? null;
+        }
+        catch (error) {
+            Log_1.Log.error(`UserManager: Member ${memberId} not found in ${guildId}`);
+            return null;
+        }
+    }
+    /**
+     * Check if user is still in guild
+     */
+    static async isInGuild(guildId, userId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                return false;
+            await guild.members.fetch({ user: userId, force: true });
+            return true;
+        }
+        catch (error) {
+            return error.code !== 10007; // Unknown Member
+        }
+    }
+    /**
+     * Impl
+     */
+    static async send(user_id_or_user, content_or_component_or_options, component) {
+        try {
+            let user;
+            if (typeof user_id_or_user === 'string') {
+                user = await Bot_1.Bot.client.users.fetch(user_id_or_user);
+            }
+            else {
+                user = user_id_or_user;
+            }
+            const dmChannel = await user.createDM();
+            let payload;
+            if (component && typeof content_or_component_or_options == "string") { // component + content
+                payload = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content_or_component_or_options, component);
+            }
+            else if (typeof content_or_component_or_options === 'string') { // content only
+                payload = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content_or_component_or_options);
+            }
+            else if (SendableComponentBuilder_1.SendableComponentBuilder.isSendableComponent(content_or_component_or_options)) { // component only
+                payload = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content_or_component_or_options);
+            }
+            else { // MessageCreationOptionOnly
+                payload = content_or_component_or_options;
+            }
+            const message = await dmChannel.send(payload);
+            if (user instanceof discord_js_1.GuildMember) {
+                Log_1.Log.info(`Sent DM to ${user.id} (${user.user.username}): "${(payload.content || 'Embed/Component').substring(0, 50)}..."`);
+            }
+            else {
+                Log_1.Log.info(`Sent DM to ${user.id} (${user.username}): "${(payload.content || 'Embed/Component').substring(0, 50)}..."`);
+            }
+            return message;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
+            throw new Error(`Cannot send DM to ${user_id_or_user}`);
+        }
+    }
+}
+exports.BasicUserManager = BasicUserManager;

package/dist/manager/direct/UserManager.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManager = void 0;
+const BasicUserManager_1 = require("./BasicUserManager");
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+class UserManager extends BasicUserManager_1.BasicUserManager {
+    static async find(userId) {
+        try {
+            return await Bot_1.Bot.client.users.fetch(userId);
+        }
+        catch (error) {
+            Log_1.Log.error(`UserManager: Member ${userId} not found`);
+            return null;
+        }
+    }
+}
+exports.UserManager = UserManager;

package/dist/manager/guild/ChannelManager/ForumChannelManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForumChannelManager = void 0;
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const discord_js_1 = require("discord.js");
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+class ForumChannelManager extends GuildChannelManager_1.GuildChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await super.findInGuild(guildId, channelId);
+        return channel instanceof discord_js_1.ForumChannel ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await super.find(channelId);
+        return channel instanceof discord_js_1.ForumChannel ? channel : null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values()).filter(c => c instanceof discord_js_1.ForumChannel);
+    }
+    static async create(guildId, name, options) {
+        return await super._create(guildId, {
+            name,
+            type: discord_js_1.ChannelType.GuildForum,
+            ...options
+        });
+    }
+}
+exports.ForumChannelManager = ForumChannelManager;

package/dist/manager/guild/ChannelManager/GuildChannelList.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildChannelList = void 0;
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const ForumChannelManager_1 = require("./ForumChannelManager");
+const NewsChannelManager_1 = require("./NewsChannelManager");
+const StageChannelManager_1 = require("./StageChannelManager");
+const GuildTextChannelManager_1 = require("./GuildTextChannelManager");
+const ThreadChannelManager_1 = require("./ThreadChannelManager");
+const GuildVoiceChannelManager_1 = require("./GuildVoiceChannelManager");
+class GuildChannelList {
+}
+exports.GuildChannelList = GuildChannelList;
+GuildChannelList.forum = ForumChannelManager_1.ForumChannelManager;
+GuildChannelList.any = GuildChannelManager_1.GuildChannelManager;
+GuildChannelList.news = NewsChannelManager_1.NewsChannelManager;
+GuildChannelList.stage = StageChannelManager_1.StageChannelManager;
+GuildChannelList.text = GuildTextChannelManager_1.GuildTextChannelManager;
+GuildChannelList.thread = ThreadChannelManager_1.ThreadChannelManager;
+GuildChannelList.voice = GuildVoiceChannelManager_1.GuildVoiceChannelManager;

package/dist/manager/guild/ChannelManager/GuildChannelManager.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildChannelManager = void 0;
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+const GuildMessageManager_1 = require("./GuildMessageManager");
+class GuildChannelManager {
+    /**
+     * Recherche un channel par ID dans une guild spécifique
+     */
+    static async findInGuild(guildId, channelId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                Log_1.Log.warn(`Guild ${guildId} not found`);
+                return null;
+            }
+            const channel = await guild.channels.fetch(channelId);
+            return channel ?? null;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to find channel ${channelId} in guild ${guildId}: ${error}`);
+            return null;
+        }
+    }
+    static async find(channelId) {
+        for (const guild of Bot_1.Bot.client.guilds.cache.values()) {
+            try {
+                const channel = await guild.channels.fetch(channelId);
+                if (channel)
+                    return channel;
+            }
+            catch {
+            }
+        }
+        Log_1.Log.warn(`Channel ${channelId} not found in any guild`);
+        return null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values());
+    }
+    /**
+     * Recherche channels par nom (insensible à la casse)
+     */
+    static findByName(guildId, name) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values())
+            .filter(channel => channel.name.toLowerCase().includes(name.toLowerCase()));
+    }
+    static async _create(guildId, options) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild) {
+                throw new Error(`Guild ${guildId} not found`);
+            }
+            const channel = await guild.channels.create(options);
+            Log_1.Log.info(`Created channel ${channel.name} (${channel.id}) in guild ${guildId}`);
+            return channel;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to create channel in guild ${guildId}: ${error}`);
+            throw error;
+        }
+    }
+    static async delete(channelId) {
+        try {
+            const channel = await GuildChannelManager.find(channelId);
+            if (!channel) {
+                throw new Error(`Channel ${channelId} not found`);
+            }
+            await channel.delete();
+            Log_1.Log.info(`Deleted channel ${channelId}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete channel ${channelId}: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.GuildChannelManager = GuildChannelManager;
+GuildChannelManager.message = GuildMessageManager_1.GuildMessageManager;

package/dist/manager/guild/ChannelManager/GuildMessageManager.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMessageManager = void 0;
+const GuildTextChannelManager_1 = require("./GuildTextChannelManager");
+const Log_1 = require("../../../utils/Log");
+const SendableComponentBuilder_1 = require("../../builder/SendableComponentBuilder");
+class GuildMessageManager {
+    /**
+     * Impl
+     */
+    static async send(channelId, content_or_component_or_options) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                Log_1.Log.error(`Channel ${channelId} not found in guild`);
+                return null;
+            }
+            let payload;
+            if (typeof content_or_component_or_options === 'string') {
+                payload = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content_or_component_or_options);
+            }
+            else if (SendableComponentBuilder_1.SendableComponentBuilder.isSendableComponent(content_or_component_or_options) || Array.isArray(content_or_component_or_options)) {
+                payload = SendableComponentBuilder_1.SendableComponentBuilder.buildMessage(content_or_component_or_options);
+            }
+            else {
+                payload = content_or_component_or_options;
+            }
+            return await channel.send(payload);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to send message to ${channelId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Delete message
+     */
+    static async delete(channelId, messageId) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                Log_1.Log.error(`Channel ${channelId} not found`);
+                return false;
+            }
+            const message = await channel.messages.fetch(messageId);
+            await message.delete();
+            Log_1.Log.info(`Deleted message ${messageId} from ${channelId}`);
+            return true;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to delete message ${messageId} from ${channelId}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Fetch messages (last X messages, default 10)
+     */
+    static async fetch(channelId, limit = 10) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                Log_1.Log.error(`Channel ${channelId} not found`);
+                return [];
+            }
+            const messages = await channel.messages.fetch({ limit });
+            Log_1.Log.info(`Fetched ${messages.size} messages from ${channelId}`);
+            return Array.from(messages.values());
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch messages from ${channelId}: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Fetch single message
+     */
+    static async fetchOne(channelId, messageId) {
+        try {
+            const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(channelId);
+            if (!channel) {
+                Log_1.Log.error(`Channel ${channelId} not found`);
+                return null;
+            }
+            const message = await channel.messages.fetch(messageId);
+            return message;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch message ${messageId} from ${channelId}: ${error}`);
+            return null;
+        }
+    }
+}
+exports.GuildMessageManager = GuildMessageManager;

package/dist/manager/guild/ChannelManager/GuildTextChannelManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildTextChannelManager = void 0;
+const discord_js_1 = require("discord.js");
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+class GuildTextChannelManager extends GuildChannelManager_1.GuildChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await super.findInGuild(guildId, channelId);
+        return channel?.isTextBased() ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await super.find(channelId);
+        return channel?.isTextBased() ? channel : null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values()).filter(c => c instanceof discord_js_1.TextChannel);
+    }
+    static async create(guildId, name, options) {
+        return await super._create(guildId, {
+            name,
+            type: discord_js_1.ChannelType.GuildText,
+            ...options
+        });
+    }
+}
+exports.GuildTextChannelManager = GuildTextChannelManager;

package/dist/manager/guild/ChannelManager/GuildVoiceChannelManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildVoiceChannelManager = void 0;
+const discord_js_1 = require("discord.js");
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+class GuildVoiceChannelManager extends GuildChannelManager_1.GuildChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await super.findInGuild(guildId, channelId);
+        return channel?.isVoiceBased() ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await super.find(channelId);
+        return channel?.isVoiceBased() ? channel : null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values()).filter(c => c instanceof discord_js_1.VoiceChannel);
+    }
+    static async create(guildId, name, options) {
+        return await super._create(guildId, {
+            name,
+            type: discord_js_1.ChannelType.GuildVoice,
+            ...options
+        });
+    }
+}
+exports.GuildVoiceChannelManager = GuildVoiceChannelManager;

package/dist/manager/guild/ChannelManager/NewsChannelManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewsChannelManager = void 0;
+const discord_js_1 = require("discord.js");
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+class NewsChannelManager extends GuildChannelManager_1.GuildChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await super.findInGuild(guildId, channelId);
+        return channel instanceof discord_js_1.NewsChannel ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await super.find(channelId);
+        return channel instanceof discord_js_1.NewsChannel ? channel : null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values()).filter(c => c instanceof discord_js_1.NewsChannel);
+    }
+    static async create(guildId, name, options) {
+        return await super._create(guildId, {
+            name,
+            type: discord_js_1.ChannelType.GuildAnnouncement,
+            ...options
+        });
+    }
+}
+exports.NewsChannelManager = NewsChannelManager;

package/dist/manager/guild/ChannelManager/StageChannelManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageChannelManager = void 0;
+const discord_js_1 = require("discord.js");
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const Bot_1 = require("../../../bot/Bot");
+const Log_1 = require("../../../utils/Log");
+class StageChannelManager extends GuildChannelManager_1.GuildChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await super.findInGuild(guildId, channelId);
+        return channel instanceof discord_js_1.StageChannel ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await super.find(channelId);
+        return channel instanceof discord_js_1.StageChannel ? channel : null;
+    }
+    static findAll(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild) {
+            Log_1.Log.warn(`Guild ${guildId} not found`);
+            return [];
+        }
+        return Array.from(guild.channels.cache.values()).filter(c => c instanceof discord_js_1.StageChannel);
+    }
+    static async create(guildId, name, options) {
+        return await super._create(guildId, {
+            name,
+            type: discord_js_1.ChannelType.GuildStageVoice,
+            ...options
+        });
+    }
+}
+exports.StageChannelManager = StageChannelManager;

package/dist/manager/guild/ChannelManager/ThreadChannelManager.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadChannelManager = void 0;
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const GuildTextChannelManager_1 = require("./GuildTextChannelManager");
+const SendableComponentBuilder_1 = require("../../builder/SendableComponentBuilder");
+class ThreadChannelManager {
+    static async findInGuild(guildId, channelId) {
+        const channel = await GuildChannelManager_1.GuildChannelManager.findInGuild(guildId, channelId);
+        return channel?.isThread() ? channel : null;
+    }
+    static async find(channelId) {
+        const channel = await GuildChannelManager_1.GuildChannelManager.find(channelId);
+        return channel?.isThread() ? channel : null;
+    }
+    static findAll(guildId) {
+        const channels = GuildChannelManager_1.GuildChannelManager.findAll(guildId);
+        return channels.filter(c => c.isThread());
+    }
+    static async createFromChannel(parentId, options) {
+        const channel = await GuildTextChannelManager_1.GuildTextChannelManager.find(parentId);
+        if (!channel || !channel.isTextBased()) {
+            throw new Error('Parent must be a text-based channel');
+        }
+        const thread = await channel.threads.create(options);
+        return thread;
+    }
+    static async createFromMessage(message, options) {
+        const channel = await GuildChannelManager_1.GuildChannelManager.find(message.id);
+        if (!channel)
+            throw new Error('Message channel not found');
+        return await message.startThread(options);
+    }
+    /**
+     * Impl
+     */
+    static async send(channelId, content_or_component_or_options) {
+        if (typeof content_or_component_or_options == 'string') {
+            return await GuildTextChannelManager_1.GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+        }
+        else if (SendableComponentBuilder_1.SendableComponentBuilder.isSendableComponent(content_or_component_or_options) || Array.isArray(content_or_component_or_options)) {
+            return await GuildTextChannelManager_1.GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+        }
+        else {
+            return await GuildTextChannelManager_1.GuildTextChannelManager.message.send(channelId, content_or_component_or_options);
+        }
+    }
+}
+exports.ThreadChannelManager = ThreadChannelManager;

package/dist/manager/guild/GuildManager.js

@@ -0,0 +1,144 @@
+"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());
+    }
+    static async find(guild_id) {
+        return await Bot_1.Bot.client.guilds.fetch(guild_id);
+    }
+    /**
+     * 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()) {
+        let guild;
+        if (guildId instanceof discord_js_1.Guild) {
+            guild = guildId;
+        }
+        else {
+            let tmp = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!tmp)
+                throw new Error(`Guild ${guildId} not found`);
+            guild = tmp;
+        }
+        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;