@futdevpro/nts-dynamo 1.15.156 → 1.15.160

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.ts

@@ -1,641 +0,0 @@
-import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel, Channel, DMChannel } from 'discord.js';
-import { DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config } from '../../../_services/bot-messaging-provider.service-base';
-import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
-import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.interface';
-import { DyNTS_Bot_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
-
-export type DyNTS_DiB_Message = DyNTS_Bot_MessageWrapper<Message>;
-export type DyNTS_DiB_Channel = DyNTS_Bot_ChannelWrapper<Channel>;
-export type DyNTS_DiB_User = DyNTS_Bot_UserWrapper<GuildMember>;
-
-export interface Discord_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
-  token: string;
-  guildId: string;
-  clientId: string;
-  oauth2Url: string;
-  intents: GatewayIntentBits[];
-  partials: Partials[];
-}
-
-export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
-  Channel,
-  Message,
-  GuildMember,
-  Discord_MessagingProviderConfig,
-  Role
-> {
-  readonly name = 'discord';
-  readonly type = DyFM_Msg_Provider_Type.discord;
-
-  get botId(): string {
-    return this.client.user?.id;
-  }
-
-  get botDisplayName(): string {
-    return this.client.user?.displayName;
-  }
-  
-  override readonly config: Discord_MessagingProviderConfig;
-
-  private client: Client;
-  private guild: Guild;
-
-  constructor(
-    setConfig: Discord_MessagingProviderConfig
-  ) {
-    super();
-
-    this.config = setConfig;
-  }
-
-  // Public accessors for Discord-specific objects (for backward compatibility with CCAP)
-  get discordClient(): Client {
-    return this.client;
-  }
-
-  get discordGuild(): Guild {
-    return this.guild;
-  }
-
-  async setup(issuer: string): Promise<void> {
-    try {
-      this.client = new Client({
-        intents: this.config.intents,
-        partials: this.config.partials,
-      });
-
-    } catch (error) {   
-      DyFM_Error.logSimple('Error during Discord bot setup:', error);
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('setup', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S000`,
-      });
-    }
-  }
-
-  async start(issuer: string): Promise<void> {
-    try {
-      if (!this.client) {
-        throw new Error('Discord client not initialized. Call setup() first.');
-      }
-
-      return new Promise((resolve, reject) => {
-        this.client.on('ready', async () => {
-          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
-            DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
-          }
-
-          // Get guild
-          this.guild = this.client.guilds.cache.get(this.config.guildId);
-          if (!this.guild) {
-            reject(new Error(`Discord server not found with ID: ${this.config.guildId}`));
-            return;
-          }
-
-          resolve();
-        });
-
-        this.client.login(this.config.token).catch(reject);
-      });
-    } catch (error) {
-      DyFM_Error.logSimple('Error during Discord bot start:', error);
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('start', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S001`,
-      });
-    }
-  }
-
-  async getChannelByName(name: string): Promise<DyNTS_DiB_Channel> {
-    if (this.channelCache.has(name)) {
-      return await this.wrapChannel(this.channelCache.get(name));
-    }
-
-    const channel = this.guild.channels.cache.find(
-      (ch) => ch.name === name && ch.isTextBased()
-    ) as TextChannel;
-
-    if (!channel) {
-      throw new Error(`No text channel found with name "${name}"`);
-    }
-
-    this.channelCache.set(name, channel);
-    return await this.wrapChannel(channel);
-  }
-
-  async getChannelById(id: string): Promise<DyNTS_DiB_Channel> {
-    const channel = this.guild.channels.cache.get(id) as TextChannel;
-    if (!channel) {
-      throw new Error(`No text channel found with ID "${id}"`);
-    }
-
-    if (!this.channelCache.has(channel.name)) {
-      this.channelCache.set(channel.name, channel);
-    }
-    return await this.wrapChannel(channel);
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DiB_Message> {
-    const discordChannel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-
-    return await this.sendMessageToChannel(discordChannel, message);
-
-    /* if (!discordChannel) {
-      throw new Error(`No text channel found with name "${channelName}"`);
-    }
-
-    if (!discordChannel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channelName}" is not a text channel`);
-    }
-
-    //const sentMessage: Message = await (discordChannel.rawPlatformChannel as TextChannel).send(message);
-    const channel: TextChannel = discordChannel.rawPlatformChannel as TextChannel;
-
-    let firstMessage: Message;
-    const originalMessage: string = message;
-    if (message.length > 2_000) { // 2000 characters per message
-      while (message.length) {
-        if (!firstMessage) {
-          firstMessage = await channel.send(message.substring(0, 2_000));
-        } else {
-          await channel.send(message.substring(0, 2_000));
-        }
-
-        message = message.substring(2_000);
-      }
-
-      firstMessage.content = originalMessage;
-      return this.wrapMessage(firstMessage);
-    } else {
-      const messageSent: Message = await channel.send(message);
-      return this.wrapMessage(messageSent);
-    } */
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_DiB_Message[]> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channelName}" is not a text channel`);
-    }
-
-    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
-      limit: limit
-    });
-
-    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_DiB_Message> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channelName}" is not a text channel`);
-    }
-
-    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
-      limit: 1 
-    });
-    const lastMessage: Message = messages.first();
-
-    return lastMessage ? await this.wrapMessage(lastMessage) : null;
-  }
-
-  async clearChannel(channel: DyNTS_DiB_Channel): Promise<void> {
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channel.name}" is not a text channel`);
-    }
-
-    let lastId: string | undefined = undefined;
-    let fetched: number = 0;
-    const maxFetch: number = 1000;
-
-    while (fetched < maxFetch) {
-      const options: { limit: number; before?: string } = { limit: 100 };
-      if (lastId) {
-        options.before = lastId;
-      }
-
-      const messageCollection: Collection<string, Message> = await channel.rawPlatformChannel.messages.fetch(options);
-      if (messageCollection.size === 0) {
-        break;
-      }
-
-      const deletePromises = Array.from(messageCollection.values()).map((message: Message) => 
-        message.delete().catch((error) => {
-          DyFM_Error.logSimple('Failed to delete message', error);
-        })
-      );
-
-      await Promise.all(deletePromises);
-      lastId = Array.from(messageCollection.values()).pop()?.id;
-      fetched += messageCollection.size;
-    }
-  }
-
-  // Message operations
-  async sendMessageToChannel(channel: DyNTS_DiB_Channel, content: string): Promise<DyNTS_DiB_Message> {
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channel.name}" is not a text channel`);
-    }
-    const discordTextChannel: TextChannel = channel.rawPlatformChannel as TextChannel;
-    
-    const originalContent: string = content;
-
-    let firstMessage: Message;
-    if (content.length > 2_000) { // 2000 characters per message
-      while (content.length) {
-        if (!firstMessage) {
-          firstMessage = await discordTextChannel.send(content.substring(0, 2_000));
-        } else {
-          await discordTextChannel.send(content.substring(0, 2_000));
-        }
-        content = content.substring(2_000);
-      }
-
-      firstMessage.content = originalContent;
-      return await this.wrapMessage(firstMessage);
-    } else {
-      const message: Message = await discordTextChannel.send(content);
-      return await this.wrapMessage(message);
-    }
-  }
-
-  async replyToMessage(message: DyNTS_DiB_Message, content: string): Promise<DyNTS_DiB_Message> {
-    try {
-      /* const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-      if (!channel) {
-        throw new Error(`Channel not found with ID: ${channelId}`);
-      }
-      const message = await channel.messages.fetch(messageId); */
-      if (!message.rawPlatformMessage.channel.isTextBased()) {
-        throw new Error(`Message "${message.id}" is not a text message`);
-      }
-
-      const originalContent: string = content;
-      if (content.length > 2_000) {
-        let firstMessage: Message;
-
-        while (content.length) {
-          if (!firstMessage) {
-            firstMessage = await (message.rawPlatformMessage.channel as TextChannel).send(
-              content.substring(0, 2_000)
-            );
-          } else {
-            await message.reply(content.substring(0, 2_000));
-          }
-          content = content.substring(2_000);
-        }
-
-        firstMessage.content = originalContent;
-        return await this.wrapMessage(firstMessage);
-      } else {
-        const reply: Message= await message.rawPlatformMessage.reply(content);
-        return await this.wrapMessage(reply);
-      }
-    } catch (error) {
-      DyFM_Error.logSimple('Error replying to message:', error);
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('replyToMessage', error, message.issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S002`,
-      });
-    }
-  }
-
-  async sendTyping(channel: DyNTS_DiB_Channel): Promise<void> {
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channel.name}" is not a text channel`);
-    }
-
-    await (channel.rawPlatformChannel as TextChannel).sendTyping();
-  }
-
-  async sendTypingForMessage(message: DyNTS_DiB_Message): Promise<void> {
-    if (!message.rawPlatformMessage.channel.isTextBased()) {
-      throw new Error(`Message "${message.id}" is not a text message`);
-    }
-
-    await (message.rawPlatformMessage.channel as TextChannel).sendTyping();
-  }
-
-  async fetchMessages(channel: DyNTS_DiB_Channel, limit: number): Promise<DyNTS_DiB_Message[]> {
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channel.name}" is not a text channel`);
-    }
-
-    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
-      limit: limit
-    });
-    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
-  }
-
-  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_DiB_Message[]> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelById(id);
-    return this.fetchMessages(channel, limit);
-  }
-
-  async fetchMessagesForMessage(message: DyNTS_DiB_Message, limit: number): Promise<DyNTS_DiB_Message[]> {
-    if (!message.rawPlatformMessage.channel.isTextBased()) {
-      throw new Error(`Message "${message.id}" is not a text message`);
-    }
-
-    const messages: Collection<string, Message> = await message.rawPlatformMessage.channel.messages.fetch({ 
-      limit: limit
-    });
-    return await Promise.all(Array.from(messages.values()).map(async (msg: Message) => await this.wrapMessage(msg)));
-  }
-
-  async fetchAllMessagesWithPaging(channel: DyNTS_DiB_Channel, maxFetch: number = 1000): Promise<DyNTS_DiB_Message[]> {
-    if (!channel.rawPlatformChannel.isTextBased()) {
-      throw new Error(`Channel "${channel.name}" is not a text channel`);
-    }
-
-    let lastId: string | undefined = undefined;
-    let fetched: number = 0;
-    const allMessages: DyNTS_DiB_Message[] = [];
-
-    while (fetched < maxFetch) {
-      const options: { limit: number; before?: string } = { limit: 100 };
-      if (lastId) options.before = lastId;
-
-      const messageCollection: Collection<string, Message> = await channel.rawPlatformChannel.messages.fetch(options);
-      if (messageCollection.size === 0) break;
-
-      await DyFM_Array.asyncForEach(
-        Array.from(messageCollection.values()), 
-        async (msg: Message) => {
-          allMessages.push(await this.wrapMessage(msg));
-        }
-      );
-
-      lastId = Array.from(messageCollection.values()).pop()?.id;
-      fetched += messageCollection.size;
-    }
-
-    return allMessages;
-  }
-
-  async deleteMessage(message: DyNTS_DiB_Message): Promise<void> {
-    await message.rawPlatformMessage.delete();
-  }
-
-  // User operations
-  async updateMessage(message: Message, issuer: string): Promise<void> {
-    throw new Error('Discord provider not yet implemented');
-  }
-
-  async getUserByName(username: string): Promise<DyNTS_DiB_User> {
-    const member: GuildMember = this.guild.members.cache.find((m: GuildMember) => m.user.username === username);
-
-    if (!member) {
-      throw new Error(`User not found with username: ${username}`);
-    }
-
-    return await this.wrapUser(member);
-  }
-
-  getUserMention(userId: string): string {
-    return `<@${userId}>`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_DiB_User[]> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-    const members: Collection<string, GuildMember> = await this.fetchMembersInGuild(this.guild);
-    
-    const allowedMembers: Collection<string, GuildMember> = members.filter((member: GuildMember) =>
-      channel.rawPlatformChannel.isTextBased() &&
-      (channel.rawPlatformChannel as TextChannel).permissionsFor(member)?.has('ViewChannel')
-    );
-
-    return await DyFM_Array.asyncMap(
-      Array.from(allowedMembers.values()), 
-      async (member: GuildMember) => await this.wrapUser(member)
-    );
-  }
-
-  async fetchMembersInGuild(guild: Guild): Promise<Collection<string, GuildMember>> {
-    try {
-      // Try to fetch with a limit to avoid timeout
-      return await guild?.members.fetch({ limit: 1000 })
-    } catch (fetchError: any) {
-      throw new DyFM_Error({
-        errorCode: 'DIB-OPS-FMI0',
-        message: 'Failed to fetch members',
-        error: fetchError,
-      })
-    }
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    const members: DyNTS_DiB_User[] = await this.readMembersInChannel(channelName);
-    return members.map((member: DyNTS_DiB_User) => member.username);
-  }
-
-  // Advanced message queries
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
-    
-    return messages.find((msg: DyNTS_DiB_Message) => msg.authorName === username) || null;
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
-    
-    return messages.find((msg: DyNTS_DiB_Message) => 
-      msg.content.includes(`@${username}`) || 
-      msg.content.includes(`<@${username}>`)
-    ) || null;
-  }
-
-  // Advanced message queries
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
-    
-    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
-    memberNames.forEach((name: string) => {
-      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
-    });
-
-    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
-
-    messages.forEach((message: DyNTS_DiB_Message) => {
-      if (message.timestamp < cutoffTime) return;
-
-      const author = message.authorName;
-      if (memberStatus[author] !== undefined) {
-        memberStatus[author].allMessages++;
-        if (!memberStatus[author].lastMessageDate) {
-          memberStatus[author].lastMessageDate = new Date(message.timestamp);
-        }
-      }
-    });
-
-    return memberNames.map((memberName: string) => {
-      const status: { lastMessageDate: Date | null, allMessages: number } = memberStatus[memberName];
-
-      return {
-        memberName: memberName,
-        allMessages: status.allMessages,
-        lastMessageDate: status.lastMessageDate
-      };
-    });
-  }
-
-  // Advanced message queries
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_DiB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
-    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
-    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
-    
-    const memberStatus: Record<string, { lastMentionDate: Date | null, allMentions: number }> = {};
-    users.forEach((user: DyNTS_DiB_User) => {
-      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
-    });
-
-    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
-
-    messages.forEach((message: DyNTS_DiB_Message) => {
-      if (message.timestamp < cutoffTime) return;
-
-      users.forEach((user: DyNTS_DiB_User) => {
-        if (
-          message.content.includes(`@${user.id}`) && 
-          !memberStatus[user.username].lastMentionDate
-        ) {
-          memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
-          memberStatus[user.username].allMentions++;
-        }
-      });
-    });
-
-    return users.map((user: DyNTS_DiB_User) => {
-      const status: { lastMentionDate: Date | null, allMentions: number } = memberStatus[user.username];
-      
-      return {
-        memberId: user.id,
-        memberName: user.username,
-        allMentions: status.allMentions,
-        lastMentionDate: status.lastMentionDate
-      };
-    });
-  }
-
-  // Discord-specific features
-  getRoleByName(roleName: string): Role {
-    if (this.roleCache.has(roleName)) {
-      return this.roleCache.get(roleName);
-    }
-
-    const role: Role = this.guild.roles.cache.find((r: Role) => r.name === roleName);
-    if (role) {
-      this.roleCache.set(roleName, role);
-    }
-    return role;
-  }
-
-  async getRolePingByName(roleName: string): Promise<string> {
-    const role: Role = this.getRoleByName(roleName);
-    return role ? `<@&${role.id}>` : '';
-  }
-
-  async getRolePingsByName(roleNames: string[]): Promise<string> {
-    const pings: string[] = await Promise.all(
-      roleNames.map((roleName: string) => this.getRolePingByName(roleName))
-    );
-    return pings.join(' ');
-  }
-
-  async create_onMessageEventListener(handler: (message: DyNTS_DiB_Message, issuer: string) => Promise<void>): Promise<void> {
-    this.client.on('messageCreate', async (message: Message) => {
-      await handler(await this.wrapMessage(message), 'discord');
-    });
-  }
-
-  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
-    this.client.on('error', (error: Error) => {
-      handler(error);
-    });
-  }
-
-  async sendReport(message: string): Promise<DyNTS_DiB_Message> {
-    return await this.sendMessageToChannelByName(this.config.reportChannelName, message);
-  }
-
-  async sendReportIn(message: string): Promise<DyNTS_DiB_Message> {
-    return await this.sendMessageToChannelByName(
-      this.config.reportChannelName, 
-      `${this.botDisplayName} report for duty! ` +
-        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`
-    );
-  }
-
-  async wrapMessage(message: Message): Promise<DyNTS_DiB_Message> {
-    let replyTo: Message | null = null;
-    if (message.reference?.messageId) {
-      replyTo = message.channel.messages.cache.get(
-        message.reference.messageId
-      );
-    }
-
-    return new DyNTS_Bot_MessageWrapper<Message>({
-      id: message.id,
-      content: message.content,
-      authorId: message.author.id,
-      authorName: message.author.username,
-      authorDisplayName: message.author.displayName,
-      channelId: message.channel.id,
-      channelName: (message.channel as TextChannel)?.name || 'DM Channel with ' + (message.channel as DMChannel).recipient.username,
-      timestamp: message.createdTimestamp,
-      isBot: message.author.bot,
-      isTextBased: message.channel.isTextBased(),
-      isVoiceBased: false, /* message.channel.isVoiceBased(), */
-      isDM: message.channel.isDMBased(),
-      mentions: Array.from(message.mentions.users.keys()),
-      replyToMessageId: message.reference?.messageId,
-      replyToMessageAuthorId: replyTo?.author?.id,
-      rawPlatformMessage: message,
-
-      issuer: message.author.id,
-
-      channel: await this.wrapChannel(message.channel),
-      /* user: this.wrapUser(message.author), */
-
-      provider: this,
-    });
-  }
-
-  async wrapChannel(channel: Channel): Promise<DyNTS_DiB_Channel> {
-    return new DyNTS_Bot_ChannelWrapper<Channel>({
-      id: channel.id,
-      name: (channel as TextChannel).name || ('DM Channel with ' + (channel as DMChannel).recipient.username),
-      isTextBased: channel.isTextBased(),
-      isDM: channel.isDMBased(),
-      isVoiceBased: channel.isVoiceBased(),
-      rawPlatformChannel: channel,
-
-      provider: this,
-    });
-  }
-
-  async wrapUser(user: GuildMember): Promise<DyNTS_DiB_User> {
-    return new DyNTS_Bot_UserWrapper<GuildMember>({
-      id: user.user.id,
-      username: user.user.username,
-      displayName: user.displayName,
-      isBot: user.user.bot,
-      rawPlatformUser: user,
-      
-      provider: this,
-    });
-  }
-}

package/src/_modules/bot/_modules/discord-bot/index.ts

@@ -1,12 +0,0 @@
-//
-// Discord Bot Provider
-//
-// This module provides Discord-specific implementation of the Bot provider interface
-//
-
-// TYPES
-/* export * from './_models/dib-platform.types'; */
-
-// SERVICES
-export * from './_services/dib-messaging-provider.control-service';
-