@spatulox/simplediscordbot 1.0.1

package/dist/manager/discord/InviteManager.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/discord/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/discord/UserManager.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManager = void 0;
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+const UnitTime_1 = require("../../utils/times/UnitTime");
+class UserManager {
+    /**
+     * Find member in specific guild
+     */
+    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;
+        }
+    }
+    /**
+     * Find member in specific guild
+     */
+    static async findInGuild(memberId, guildId) {
+        try {
+            const guild = await Bot_1.Bot.client.guilds.fetch(guildId);
+            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(userId, guildId) {
+        try {
+            const guild = await Bot_1.Bot.client.guilds.fetch(guildId);
+            await guild.members.fetch({ user: userId, force: true });
+            return true;
+        }
+        catch (error) {
+            return error.code !== 10007;
+        }
+    }
+    /**
+     * 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`);
+    }
+}
+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,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMessageManager = void 0;
+const GuildTextChannelManager_1 = require("./GuildTextChannelManager");
+const Log_1 = require("../../../utils/Log");
+class GuildMessageManager {
+    /**
+     * Impl
+     */
+    static async send(channelId, content_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;
+            }
+            const payload = typeof content_or_options === 'string'
+                ? { content: content_or_options }
+                : content_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,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadChannelManager = void 0;
+const GuildChannelManager_1 = require("./GuildChannelManager");
+const GuildTextChannelManager_1 = require("./GuildTextChannelManager");
+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);
+    }
+}
+exports.ThreadChannelManager = ThreadChannelManager;