@jubbio/core 1.1.20 → 1.3.2

package/dist/esm/enums.js

@@ -0,0 +1,208 @@
+/**
+ * Gateway Intent Bits
+ */
+export var GatewayIntentBits;
+(function (GatewayIntentBits) {
+    GatewayIntentBits[GatewayIntentBits["Guilds"] = 1] = "Guilds";
+    GatewayIntentBits[GatewayIntentBits["GuildMembers"] = 2] = "GuildMembers";
+    GatewayIntentBits[GatewayIntentBits["GuildModeration"] = 4] = "GuildModeration";
+    GatewayIntentBits[GatewayIntentBits["GuildEmojisAndStickers"] = 8] = "GuildEmojisAndStickers";
+    GatewayIntentBits[GatewayIntentBits["GuildIntegrations"] = 16] = "GuildIntegrations";
+    GatewayIntentBits[GatewayIntentBits["GuildWebhooks"] = 32] = "GuildWebhooks";
+    GatewayIntentBits[GatewayIntentBits["GuildInvites"] = 64] = "GuildInvites";
+    GatewayIntentBits[GatewayIntentBits["GuildVoiceStates"] = 128] = "GuildVoiceStates";
+    GatewayIntentBits[GatewayIntentBits["GuildPresences"] = 256] = "GuildPresences";
+    GatewayIntentBits[GatewayIntentBits["GuildMessages"] = 512] = "GuildMessages";
+    GatewayIntentBits[GatewayIntentBits["GuildMessageReactions"] = 1024] = "GuildMessageReactions";
+    GatewayIntentBits[GatewayIntentBits["GuildMessageTyping"] = 2048] = "GuildMessageTyping";
+    GatewayIntentBits[GatewayIntentBits["DirectMessages"] = 4096] = "DirectMessages";
+    GatewayIntentBits[GatewayIntentBits["DirectMessageReactions"] = 8192] = "DirectMessageReactions";
+    GatewayIntentBits[GatewayIntentBits["DirectMessageTyping"] = 16384] = "DirectMessageTyping";
+    GatewayIntentBits[GatewayIntentBits["MessageContent"] = 32768] = "MessageContent";
+    GatewayIntentBits[GatewayIntentBits["GuildScheduledEvents"] = 65536] = "GuildScheduledEvents";
+    GatewayIntentBits[GatewayIntentBits["AutoModerationConfiguration"] = 1048576] = "AutoModerationConfiguration";
+    GatewayIntentBits[GatewayIntentBits["AutoModerationExecution"] = 2097152] = "AutoModerationExecution";
+})(GatewayIntentBits || (GatewayIntentBits = {}));
+/**
+ * Gateway Opcodes
+ */
+export var GatewayOpcodes;
+(function (GatewayOpcodes) {
+    GatewayOpcodes[GatewayOpcodes["Dispatch"] = 0] = "Dispatch";
+    GatewayOpcodes[GatewayOpcodes["Heartbeat"] = 1] = "Heartbeat";
+    GatewayOpcodes[GatewayOpcodes["Identify"] = 2] = "Identify";
+    GatewayOpcodes[GatewayOpcodes["PresenceUpdate"] = 3] = "PresenceUpdate";
+    GatewayOpcodes[GatewayOpcodes["VoiceStateUpdate"] = 4] = "VoiceStateUpdate";
+    GatewayOpcodes[GatewayOpcodes["Resume"] = 6] = "Resume";
+    GatewayOpcodes[GatewayOpcodes["Reconnect"] = 7] = "Reconnect";
+    GatewayOpcodes[GatewayOpcodes["RequestGuildMembers"] = 8] = "RequestGuildMembers";
+    GatewayOpcodes[GatewayOpcodes["InvalidSession"] = 9] = "InvalidSession";
+    GatewayOpcodes[GatewayOpcodes["Hello"] = 10] = "Hello";
+    GatewayOpcodes[GatewayOpcodes["HeartbeatAck"] = 11] = "HeartbeatAck";
+})(GatewayOpcodes || (GatewayOpcodes = {}));
+/**
+ * Interaction Types
+ */
+export var InteractionType;
+(function (InteractionType) {
+    InteractionType[InteractionType["Ping"] = 1] = "Ping";
+    InteractionType[InteractionType["ApplicationCommand"] = 2] = "ApplicationCommand";
+    InteractionType[InteractionType["MessageComponent"] = 3] = "MessageComponent";
+    InteractionType[InteractionType["ApplicationCommandAutocomplete"] = 4] = "ApplicationCommandAutocomplete";
+    InteractionType[InteractionType["ModalSubmit"] = 5] = "ModalSubmit";
+})(InteractionType || (InteractionType = {}));
+/**
+ * Application Command Types
+ */
+export var ApplicationCommandType;
+(function (ApplicationCommandType) {
+    ApplicationCommandType[ApplicationCommandType["ChatInput"] = 1] = "ChatInput";
+    ApplicationCommandType[ApplicationCommandType["User"] = 2] = "User";
+    ApplicationCommandType[ApplicationCommandType["Message"] = 3] = "Message";
+})(ApplicationCommandType || (ApplicationCommandType = {}));
+/**
+ * Application Command Option Types
+ */
+export var ApplicationCommandOptionType;
+(function (ApplicationCommandOptionType) {
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Subcommand"] = 1] = "Subcommand";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["SubcommandGroup"] = 2] = "SubcommandGroup";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["String"] = 3] = "String";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Integer"] = 4] = "Integer";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Boolean"] = 5] = "Boolean";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["User"] = 6] = "User";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Channel"] = 7] = "Channel";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Role"] = 8] = "Role";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Mentionable"] = 9] = "Mentionable";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Number"] = 10] = "Number";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Attachment"] = 11] = "Attachment";
+})(ApplicationCommandOptionType || (ApplicationCommandOptionType = {}));
+/**
+ * Channel Types
+ */
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["GuildText"] = 0] = "GuildText";
+    ChannelType[ChannelType["DM"] = 1] = "DM";
+    ChannelType[ChannelType["GuildVoice"] = 2] = "GuildVoice";
+    ChannelType[ChannelType["GroupDM"] = 3] = "GroupDM";
+    ChannelType[ChannelType["GuildCategory"] = 4] = "GuildCategory";
+    ChannelType[ChannelType["GuildAnnouncement"] = 5] = "GuildAnnouncement";
+    ChannelType[ChannelType["GuildStageVoice"] = 13] = "GuildStageVoice";
+    ChannelType[ChannelType["GuildDirectory"] = 14] = "GuildDirectory";
+    ChannelType[ChannelType["GuildForum"] = 15] = "GuildForum";
+})(ChannelType || (ChannelType = {}));
+/**
+ * Interaction Response Types
+ */
+export var InteractionResponseType;
+(function (InteractionResponseType) {
+    InteractionResponseType[InteractionResponseType["Pong"] = 1] = "Pong";
+    InteractionResponseType[InteractionResponseType["ChannelMessageWithSource"] = 4] = "ChannelMessageWithSource";
+    InteractionResponseType[InteractionResponseType["DeferredChannelMessageWithSource"] = 5] = "DeferredChannelMessageWithSource";
+    InteractionResponseType[InteractionResponseType["DeferredUpdateMessage"] = 6] = "DeferredUpdateMessage";
+    InteractionResponseType[InteractionResponseType["UpdateMessage"] = 7] = "UpdateMessage";
+    InteractionResponseType[InteractionResponseType["ApplicationCommandAutocompleteResult"] = 8] = "ApplicationCommandAutocompleteResult";
+    InteractionResponseType[InteractionResponseType["Modal"] = 9] = "Modal";
+})(InteractionResponseType || (InteractionResponseType = {}));
+/**
+ * Message Flags
+ */
+export var MessageFlags;
+(function (MessageFlags) {
+    MessageFlags[MessageFlags["Crossposted"] = 1] = "Crossposted";
+    MessageFlags[MessageFlags["IsCrosspost"] = 2] = "IsCrosspost";
+    MessageFlags[MessageFlags["SuppressEmbeds"] = 4] = "SuppressEmbeds";
+    MessageFlags[MessageFlags["SourceMessageDeleted"] = 8] = "SourceMessageDeleted";
+    MessageFlags[MessageFlags["Urgent"] = 16] = "Urgent";
+    MessageFlags[MessageFlags["Ephemeral"] = 64] = "Ephemeral";
+    MessageFlags[MessageFlags["Loading"] = 128] = "Loading";
+    MessageFlags[MessageFlags["SuppressNotifications"] = 4096] = "SuppressNotifications";
+})(MessageFlags || (MessageFlags = {}));
+/**
+ * Activity Types
+ */
+export var ActivityType;
+(function (ActivityType) {
+    ActivityType[ActivityType["Playing"] = 0] = "Playing";
+    ActivityType[ActivityType["Streaming"] = 1] = "Streaming";
+    ActivityType[ActivityType["Listening"] = 2] = "Listening";
+    ActivityType[ActivityType["Watching"] = 3] = "Watching";
+    ActivityType[ActivityType["Custom"] = 4] = "Custom";
+    ActivityType[ActivityType["Competing"] = 5] = "Competing";
+})(ActivityType || (ActivityType = {}));
+/**
+ * Presence Status
+ */
+export var PresenceStatus;
+(function (PresenceStatus) {
+    PresenceStatus["Online"] = "online";
+    PresenceStatus["Idle"] = "idle";
+    PresenceStatus["DoNotDisturb"] = "dnd";
+    PresenceStatus["Invisible"] = "invisible";
+    PresenceStatus["Offline"] = "offline";
+})(PresenceStatus || (PresenceStatus = {}));
+/**
+ * Permission Flags Bits
+ * Used for channel permission overwrites
+ */
+export const PermissionFlagsBits = {
+    // General (0-9)
+    CreateInstantInvite: 1n << 0n,
+    KickMembers: 1n << 1n,
+    BanMembers: 1n << 2n,
+    Administrator: 1n << 3n,
+    ManageChannels: 1n << 4n,
+    ManageGuild: 1n << 5n,
+    AddReactions: 1n << 6n,
+    ViewAuditLog: 1n << 7n,
+    ViewGuildInsights: 1n << 8n,
+    Stream: 1n << 9n,
+    ViewChannel: 1n << 10n,
+    // Messages (11-19)
+    SendMessages: 1n << 11n,
+    SendTTSMessages: 1n << 12n,
+    ManageMessages: 1n << 13n,
+    EmbedLinks: 1n << 14n,
+    AttachFiles: 1n << 15n,
+    ReadMessageHistory: 1n << 16n,
+    UseExternalEmojis: 1n << 17n,
+    UseSlashCommands: 1n << 18n,
+    MentionEveryone: 1n << 19n,
+    // Voice (20-27)
+    Connect: 1n << 20n,
+    Speak: 1n << 21n,
+    MuteMembers: 1n << 22n,
+    DeafenMembers: 1n << 23n,
+    MoveMembers: 1n << 24n,
+    UseVAD: 1n << 25n,
+    ChangeCodec: 1n << 26n,
+    AudioQualityAdmin: 1n << 27n,
+    // Video and Screen Sharing (28-37)
+    VideoCall: 1n << 28n,
+    ShareScreen: 1n << 29n,
+    ShareCamera: 1n << 30n,
+    ControlQuality: 1n << 31n,
+    RequestToSpeak: 1n << 32n,
+    ManageEvents: 1n << 33n,
+    AddMembers: 1n << 34n,
+    RemoveMembers: 1n << 35n,
+    ChangeGroupIcon: 1n << 36n,
+    ChangeDMSettings: 1n << 37n,
+    // Advanced (38-43)
+    ManageGroup: 1n << 38n,
+    UseActivities: 1n << 39n,
+    ModerateMembers: 1n << 40n,
+    ManageRoles: 1n << 41n,
+    ManageEmojis: 1n << 42n,
+    PrioritySpeaker: 1n << 43n,
+};
+/**
+ * Overwrite Type - for permission overwrites
+ */
+export var OverwriteType;
+(function (OverwriteType) {
+    OverwriteType[OverwriteType["Role"] = 0] = "Role";
+    OverwriteType[OverwriteType["Member"] = 1] = "Member";
+})(OverwriteType || (OverwriteType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../src/enums.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Gateway Intent Bits\r\n */\r\nexport enum GatewayIntentBits {\r\n  Guilds = 1 << 0,\r\n  GuildMembers = 1 << 1,\r\n  GuildModeration = 1 << 2,\r\n  GuildEmojisAndStickers = 1 << 3,\r\n  GuildIntegrations = 1 << 4,\r\n  GuildWebhooks = 1 << 5,\r\n  GuildInvites = 1 << 6,\r\n  GuildVoiceStates = 1 << 7,\r\n  GuildPresences = 1 << 8,\r\n  GuildMessages = 1 << 9,\r\n  GuildMessageReactions = 1 << 10,\r\n  GuildMessageTyping = 1 << 11,\r\n  DirectMessages = 1 << 12,\r\n  DirectMessageReactions = 1 << 13,\r\n  DirectMessageTyping = 1 << 14,\r\n  MessageContent = 1 << 15,\r\n  GuildScheduledEvents = 1 << 16,\r\n  AutoModerationConfiguration = 1 << 20,\r\n  AutoModerationExecution = 1 << 21\r\n}\r\n\r\n/**\r\n * Gateway Opcodes\r\n */\r\nexport enum GatewayOpcodes {\r\n  Dispatch = 0,\r\n  Heartbeat = 1,\r\n  Identify = 2,\r\n  PresenceUpdate = 3,\r\n  VoiceStateUpdate = 4,\r\n  Resume = 6,\r\n  Reconnect = 7,\r\n  RequestGuildMembers = 8,\r\n  InvalidSession = 9,\r\n  Hello = 10,\r\n  HeartbeatAck = 11\r\n}\r\n\r\n/**\r\n * Interaction Types\r\n */\r\nexport enum InteractionType {\r\n  Ping = 1,\r\n  ApplicationCommand = 2,\r\n  MessageComponent = 3,\r\n  ApplicationCommandAutocomplete = 4,\r\n  ModalSubmit = 5\r\n}\r\n\r\n/**\r\n * Application Command Types\r\n */\r\nexport enum ApplicationCommandType {\r\n  ChatInput = 1,\r\n  User = 2,\r\n  Message = 3\r\n}\r\n\r\n/**\r\n * Application Command Option Types\r\n */\r\nexport enum ApplicationCommandOptionType {\r\n  Subcommand = 1,\r\n  SubcommandGroup = 2,\r\n  String = 3,\r\n  Integer = 4,\r\n  Boolean = 5,\r\n  User = 6,\r\n  Channel = 7,\r\n  Role = 8,\r\n  Mentionable = 9,\r\n  Number = 10,\r\n  Attachment = 11\r\n}\r\n\r\n/**\r\n * Channel Types\r\n */\r\nexport enum ChannelType {\r\n  GuildText = 0,\r\n  DM = 1,\r\n  GuildVoice = 2,\r\n  GroupDM = 3,\r\n  GuildCategory = 4,\r\n  GuildAnnouncement = 5,\r\n  GuildStageVoice = 13,\r\n  GuildDirectory = 14,\r\n  GuildForum = 15\r\n}\r\n\r\n/**\r\n * Interaction Response Types\r\n */\r\nexport enum InteractionResponseType {\r\n  Pong = 1,\r\n  ChannelMessageWithSource = 4,\r\n  DeferredChannelMessageWithSource = 5,\r\n  DeferredUpdateMessage = 6,\r\n  UpdateMessage = 7,\r\n  ApplicationCommandAutocompleteResult = 8,\r\n  Modal = 9\r\n}\r\n\r\n/**\r\n * Message Flags\r\n */\r\nexport enum MessageFlags {\r\n  Crossposted = 1 << 0,\r\n  IsCrosspost = 1 << 1,\r\n  SuppressEmbeds = 1 << 2,\r\n  SourceMessageDeleted = 1 << 3,\r\n  Urgent = 1 << 4,\r\n  Ephemeral = 1 << 6,\r\n  Loading = 1 << 7,\r\n  SuppressNotifications = 1 << 12\r\n}\r\n\r\n/**\r\n * Activity Types\r\n */\r\nexport enum ActivityType {\r\n  Playing = 0,\r\n  Streaming = 1,\r\n  Listening = 2,\r\n  Watching = 3,\r\n  Custom = 4,\r\n  Competing = 5\r\n}\r\n\r\n/**\r\n * Presence Status\r\n */\r\nexport enum PresenceStatus {\r\n  Online = 'online',\r\n  Idle = 'idle',\r\n  DoNotDisturb = 'dnd',\r\n  Invisible = 'invisible',\r\n  Offline = 'offline'\r\n}\r\n\r\n/**\r\n * Permission Flags Bits\r\n * Used for channel permission overwrites\r\n */\r\nexport const PermissionFlagsBits = {\r\n  // General (0-9)\r\n  CreateInstantInvite: 1n << 0n,\r\n  KickMembers: 1n << 1n,\r\n  BanMembers: 1n << 2n,\r\n  Administrator: 1n << 3n,\r\n  ManageChannels: 1n << 4n,\r\n  ManageGuild: 1n << 5n,\r\n  AddReactions: 1n << 6n,\r\n  ViewAuditLog: 1n << 7n,\r\n  ViewGuildInsights: 1n << 8n,\r\n  Stream: 1n << 9n,\r\n  ViewChannel: 1n << 10n,\r\n\r\n  // Messages (11-19)\r\n  SendMessages: 1n << 11n,\r\n  SendTTSMessages: 1n << 12n,\r\n  ManageMessages: 1n << 13n,\r\n  EmbedLinks: 1n << 14n,\r\n  AttachFiles: 1n << 15n,\r\n  ReadMessageHistory: 1n << 16n,\r\n  UseExternalEmojis: 1n << 17n,\r\n  UseSlashCommands: 1n << 18n,\r\n  MentionEveryone: 1n << 19n,\r\n\r\n  // Voice (20-27)\r\n  Connect: 1n << 20n,\r\n  Speak: 1n << 21n,\r\n  MuteMembers: 1n << 22n,\r\n  DeafenMembers: 1n << 23n,\r\n  MoveMembers: 1n << 24n,\r\n  UseVAD: 1n << 25n,\r\n  ChangeCodec: 1n << 26n,\r\n  AudioQualityAdmin: 1n << 27n,\r\n\r\n  // Video and Screen Sharing (28-37)\r\n  VideoCall: 1n << 28n,\r\n  ShareScreen: 1n << 29n,\r\n  ShareCamera: 1n << 30n,\r\n  ControlQuality: 1n << 31n,\r\n  RequestToSpeak: 1n << 32n,\r\n  ManageEvents: 1n << 33n,\r\n  AddMembers: 1n << 34n,\r\n  RemoveMembers: 1n << 35n,\r\n  ChangeGroupIcon: 1n << 36n,\r\n  ChangeDMSettings: 1n << 37n,\r\n\r\n  // Advanced (38-43)\r\n  ManageGroup: 1n << 38n,\r\n  UseActivities: 1n << 39n,\r\n  ModerateMembers: 1n << 40n,\r\n  ManageRoles: 1n << 41n,\r\n  ManageEmojis: 1n << 42n,\r\n  PrioritySpeaker: 1n << 43n,\r\n} as const;\r\n\r\n/**\r\n * Overwrite Type - for permission overwrites\r\n */\r\nexport enum OverwriteType {\r\n  Role = 0,\r\n  Member = 1,\r\n}\r\n"]}

package/dist/esm/index.js

@@ -0,0 +1,34 @@
+/**
+ * @jubbio/core - Bot library for Jubbio
+ */
+// Core
+export { Client, GatewayIntentBits } from './Client';
+export * from './types';
+export * from './enums';
+// REST
+export { REST } from './rest/REST';
+// Structures
+export { Collection } from './structures/Collection';
+export { User } from './structures/User';
+export { Guild } from './structures/Guild';
+export { GuildMember, Permissions, PermissionFlags } from './structures/GuildMember';
+export { Message } from './structures/Message';
+export { Interaction, CommandInteraction, ButtonInteraction, SelectMenuInteraction, AutocompleteInteraction, ModalSubmitInteraction, CommandInteractionOptions, createInteraction, } from './structures/Interaction';
+export { BaseChannel, TextChannel, VoiceChannel, DMChannel, createChannel, } from './structures/Channel';
+// Collectors (from utils - more comprehensive)
+export { Collector, MessageCollector, InteractionCollector, ReactionCollector, awaitMessages, awaitReactions, } from './utils/Collector';
+// Builders
+export { EmbedBuilder, Colors, } from './builders/EmbedBuilder';
+export { ButtonBuilder, ButtonStyle, } from './builders/ButtonBuilder';
+export { StringSelectMenuBuilder, SelectMenuBuilder, StringSelectMenuOptionBuilder, } from './builders/SelectMenuBuilder';
+export { ActionRowBuilder, } from './builders/ActionRowBuilder';
+export { ModalBuilder, TextInputBuilder, TextInputStyle, } from './builders/ModalBuilder';
+export { SlashCommandBuilder, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandMentionableOption, SlashCommandAttachmentOption, ApplicationCommandOptionType as SlashCommandOptionType, } from './builders/SlashCommandBuilder';
+// Utils - Formatters
+export { Formatters, userMention, channelMention, roleMention, formatEmoji, bold, italic, underline, strikethrough, spoiler, inlineCode, codeBlock, blockQuote, quote, hyperlink, hideLinkEmbed, time, heading, unorderedList, orderedList, TimestampStyles, } from './utils/Formatters';
+// Utils - BitFields
+export { BitField } from './utils/BitField';
+export { PermissionsBitField } from './utils/PermissionsBitField';
+// Sharding
+export { ShardingManager, Shard, ShardClientUtil, ShardStatus, } from './sharding/ShardingManager';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/managers/BaseManager.js

@@ -0,0 +1,100 @@
+/**
+ * Base manager class for caching and managing structures
+ */
+import { Collection } from '../utils/Collection';
+/**
+ * Base manager for caching structures
+ */
+export class BaseManager {
+    /** The client that instantiated this manager */
+    client;
+    /** The cache of items */
+    cache;
+    /** The class to instantiate for items */
+    holds;
+    constructor(client, holds, iterable) {
+        this.client = client;
+        this.holds = holds;
+        this.cache = new Collection();
+        if (iterable) {
+            for (const item of iterable) {
+                this._add(item);
+            }
+        }
+    }
+    /**
+     * Resolve an item from the cache or ID
+     */
+    resolve(idOrInstance) {
+        if (idOrInstance instanceof this.holds)
+            return idOrInstance;
+        if (typeof idOrInstance === 'string')
+            return this.cache.get(idOrInstance) ?? null;
+        return null;
+    }
+    /**
+     * Resolve an ID from an item or ID
+     */
+    resolveId(idOrInstance) {
+        if (idOrInstance instanceof this.holds)
+            return idOrInstance.id;
+        if (typeof idOrInstance === 'string')
+            return idOrInstance;
+        if (typeof idOrInstance === 'object' && idOrInstance !== null && 'id' in idOrInstance) {
+            return idOrInstance.id;
+        }
+        return null;
+    }
+    /**
+     * Get the cache as a JSON array
+     */
+    valueOf() {
+        return [...this.cache.values()];
+    }
+}
+/**
+ * Caching manager that fetches data from the API
+ */
+export class CachedManager extends BaseManager {
+    /**
+     * Fetch an item, using cache if available (async version)
+     */
+    async resolveAsync(idOrInstance, options) {
+        const existing = super.resolve(idOrInstance);
+        if (existing && !options?.force)
+            return existing;
+        const id = this.resolveId(idOrInstance);
+        if (!id)
+            return null;
+        try {
+            return await this.fetch(id, options);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Data manager that doesn't cache
+ */
+export class DataManager extends BaseManager {
+    /**
+     * Add an item to the cache
+     */
+    _add(data, cache = true, options) {
+        const existing = this.cache.get(options?.id ?? data.id);
+        if (existing) {
+            if (cache) {
+                existing._patch?.(data);
+            }
+            return existing;
+        }
+        const entry = new this.holds(this.client, data, ...(options?.extras ?? []));
+        if (cache) {
+            this.cache.set(options?.id ?? data.id, entry);
+        }
+        return entry;
+    }
+}
+export default BaseManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/managers/ChannelManager.js

@@ -0,0 +1,200 @@
+/**
+ * Manager for channels with caching and lazy loading
+ */
+import { CachedManager } from './BaseManager';
+import { Collection } from '../utils/Collection';
+/** Channel types */
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["GuildText"] = 0] = "GuildText";
+    ChannelType[ChannelType["DM"] = 1] = "DM";
+    ChannelType[ChannelType["GuildVoice"] = 2] = "GuildVoice";
+    ChannelType[ChannelType["GroupDM"] = 3] = "GroupDM";
+    ChannelType[ChannelType["GuildCategory"] = 4] = "GuildCategory";
+    ChannelType[ChannelType["GuildAnnouncement"] = 5] = "GuildAnnouncement";
+    ChannelType[ChannelType["GuildStageVoice"] = 13] = "GuildStageVoice";
+    ChannelType[ChannelType["GuildDirectory"] = 14] = "GuildDirectory";
+    ChannelType[ChannelType["GuildForum"] = 15] = "GuildForum";
+})(ChannelType || (ChannelType = {}));
+/**
+ * Manages channels for a guild
+ */
+export class GuildChannelManager extends CachedManager {
+    /** The guild this manager belongs to */
+    guild;
+    constructor(guild, iterable) {
+        super(guild.client, Object, iterable);
+        this.guild = guild;
+    }
+    /**
+     * Add a channel to the cache
+     */
+    _add(data, cache = true) {
+        const id = data.id;
+        const existing = this.cache.get(id);
+        if (existing) {
+            if (cache)
+                Object.assign(existing, data);
+            return existing;
+        }
+        const channel = {
+            id,
+            guildId: this.guild.id,
+            name: data.name,
+            type: data.type,
+            position: data.position ?? 0,
+            parentId: data.parent_id ?? null,
+            permissionOverwrites: data.permission_overwrites ?? [],
+            topic: data.topic ?? null,
+            nsfw: data.nsfw ?? false,
+            rateLimitPerUser: data.rate_limit_per_user ?? 0,
+            bitrate: data.bitrate,
+            userLimit: data.user_limit,
+            get isText() { return [ChannelType.GuildText, ChannelType.GuildAnnouncement].includes(this.type); },
+            get isVoice() { return [ChannelType.GuildVoice, ChannelType.GuildStageVoice].includes(this.type); },
+            get isCategory() { return this.type === ChannelType.GuildCategory; },
+            toString() { return `<#${this.id}>`; },
+            async send(content) {
+                return this.guild.client.rest.request('POST', `/channels/${this.id}/messages`, typeof content === 'string' ? { content } : content);
+            },
+            async delete(reason) {
+                return this.guild.client.rest.request('DELETE', `/channels/${this.id}`, reason ? { reason } : undefined);
+            },
+            async edit(data) {
+                return this.guild.client.rest.request('PATCH', `/channels/${this.id}`, data);
+            },
+        };
+        if (cache)
+            this.cache.set(id, channel);
+        return channel;
+    }
+    /**
+     * Fetch a channel from the API
+     */
+    async fetch(id, options) {
+        if (!options?.force) {
+            const existing = this.cache.get(id);
+            if (existing)
+                return existing;
+        }
+        const data = await this.client.rest.request('GET', `/channels/${id}`);
+        return this._add(data, options?.cache ?? true);
+    }
+    /**
+     * Fetch all channels for the guild
+     */
+    async fetchAll() {
+        const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/channels`);
+        const channels = new Collection();
+        for (const channelData of data) {
+            const channel = this._add(channelData);
+            channels.set(channel.id, channel);
+        }
+        return channels;
+    }
+    /**
+     * Create a new channel
+     */
+    async create(options) {
+        const body = {
+            name: options.name,
+            type: options.type ?? ChannelType.GuildText,
+        };
+        if (options.topic)
+            body.topic = options.topic;
+        if (options.bitrate)
+            body.bitrate = options.bitrate;
+        if (options.userLimit)
+            body.user_limit = options.userLimit;
+        if (options.rateLimitPerUser)
+            body.rate_limit_per_user = options.rateLimitPerUser;
+        if (options.position !== undefined)
+            body.position = options.position;
+        if (options.permissionOverwrites)
+            body.permission_overwrites = options.permissionOverwrites;
+        if (options.parent)
+            body.parent_id = options.parent;
+        if (options.nsfw !== undefined)
+            body.nsfw = options.nsfw;
+        const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/channels`, body);
+        return this._add(data);
+    }
+    /**
+     * Delete a channel
+     */
+    async delete(id, reason) {
+        await this.client.rest.request('DELETE', `/channels/${id}`, reason ? { reason } : undefined);
+        this.cache.delete(id);
+    }
+    /**
+     * Edit a channel
+     */
+    async edit(id, data) {
+        const body = {};
+        if (data.name)
+            body.name = data.name;
+        if (data.type !== undefined)
+            body.type = data.type;
+        if (data.position !== undefined)
+            body.position = data.position;
+        if (data.topic !== undefined)
+            body.topic = data.topic;
+        if (data.nsfw !== undefined)
+            body.nsfw = data.nsfw;
+        if (data.rateLimitPerUser !== undefined)
+            body.rate_limit_per_user = data.rateLimitPerUser;
+        if (data.bitrate !== undefined)
+            body.bitrate = data.bitrate;
+        if (data.userLimit !== undefined)
+            body.user_limit = data.userLimit;
+        if (data.permissionOverwrites)
+            body.permission_overwrites = data.permissionOverwrites;
+        if (data.parent !== undefined)
+            body.parent_id = data.parent;
+        const result = await this.client.rest.request('PATCH', `/channels/${id}`, body);
+        return this._add(result);
+    }
+    /**
+     * Set channel positions
+     */
+    async setPositions(positions) {
+        const body = positions.map(p => ({
+            id: p.channel,
+            position: p.position,
+            parent_id: p.parent,
+        }));
+        await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/channels`, body);
+    }
+}
+/**
+ * Global channel manager for the client
+ */
+export class ChannelManager extends CachedManager {
+    constructor(client, iterable) {
+        super(client, Object, iterable);
+    }
+    _add(data, cache = true) {
+        const id = data.id;
+        const existing = this.cache.get(id);
+        if (existing) {
+            if (cache)
+                Object.assign(existing, data);
+            return existing;
+        }
+        const channel = { ...data, id };
+        if (cache)
+            this.cache.set(id, channel);
+        return channel;
+    }
+    async fetch(id, options) {
+        if (!options?.force) {
+            const existing = this.cache.get(id);
+            if (existing)
+                return existing;
+        }
+        const data = await this.client.rest.request('GET', `/channels/${id}`);
+        return this._add(data, options?.cache ?? true);
+    }
+}
+export default GuildChannelManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChannelManager.js","sourceRoot":"","sources":["../../../src/managers/ChannelManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Manager for channels with caching and lazy loading\n */\n\nimport { CachedManager } from './BaseManager';\nimport { Collection } from '../utils/Collection';\n\n/** Channel types */\nexport enum ChannelType {\n  GuildText = 0,\n  DM = 1,\n  GuildVoice = 2,\n  GroupDM = 3,\n  GuildCategory = 4,\n  GuildAnnouncement = 5,\n  GuildStageVoice = 13,\n  GuildDirectory = 14,\n  GuildForum = 15,\n}\n\n/**\n * Manages channels for a guild\n */\nexport class GuildChannelManager extends CachedManager<string, any> {\n  /** The guild this manager belongs to */\n  public readonly guild: any;\n\n  constructor(guild: any, iterable?: Iterable<any>) {\n    super(guild.client, Object as any, iterable);\n    this.guild = guild;\n  }\n\n  /**\n   * Add a channel to the cache\n   */\n  _add(data: any, cache = true): any {\n    const id = data.id;\n    const existing = this.cache.get(id);\n    \n    if (existing) {\n      if (cache) Object.assign(existing, data);\n      return existing;\n    }\n    \n    const channel = {\n      id,\n      guildId: this.guild.id,\n      name: data.name,\n      type: data.type,\n      position: data.position ?? 0,\n      parentId: data.parent_id ?? null,\n      permissionOverwrites: data.permission_overwrites ?? [],\n      topic: data.topic ?? null,\n      nsfw: data.nsfw ?? false,\n      rateLimitPerUser: data.rate_limit_per_user ?? 0,\n      bitrate: data.bitrate,\n      userLimit: data.user_limit,\n      \n      get isText() { return [ChannelType.GuildText, ChannelType.GuildAnnouncement].includes(this.type); },\n      get isVoice() { return [ChannelType.GuildVoice, ChannelType.GuildStageVoice].includes(this.type); },\n      get isCategory() { return this.type === ChannelType.GuildCategory; },\n      \n      toString() { return `<#${this.id}>`; },\n      \n      async send(content: any) {\n        return this.guild.client.rest.request('POST', `/channels/${this.id}/messages`, \n          typeof content === 'string' ? { content } : content\n        );\n      },\n      \n      async delete(reason?: string) {\n        return this.guild.client.rest.request('DELETE', `/channels/${this.id}`, reason ? { reason } : undefined);\n      },\n      \n      async edit(data: any) {\n        return this.guild.client.rest.request('PATCH', `/channels/${this.id}`, data);\n      },\n    };\n    \n    if (cache) this.cache.set(id, channel);\n    return channel;\n  }\n\n  /**\n   * Fetch a channel from the API\n   */\n  async fetch(id: string, options?: { cache?: boolean; force?: boolean }): Promise<any> {\n    if (!options?.force) {\n      const existing = this.cache.get(id);\n      if (existing) return existing;\n    }\n    \n    const data = await this.client.rest.request('GET', `/channels/${id}`);\n    return this._add(data, options?.cache ?? true);\n  }\n\n  /**\n   * Fetch all channels for the guild\n   */\n  async fetchAll(): Promise<Collection<string, any>> {\n    const data = await this.client.rest.request('GET', `/guilds/${this.guild.id}/channels`);\n    const channels = new Collection<string, any>();\n    for (const channelData of data) {\n      const channel = this._add(channelData);\n      channels.set(channel.id, channel);\n    }\n    return channels;\n  }\n\n  /**\n   * Create a new channel\n   */\n  async create(options: {\n    name: string;\n    type?: ChannelType;\n    topic?: string;\n    bitrate?: number;\n    userLimit?: number;\n    rateLimitPerUser?: number;\n    position?: number;\n    permissionOverwrites?: any[];\n    parent?: string;\n    nsfw?: boolean;\n    reason?: string;\n  }): Promise<any> {\n    const body: any = {\n      name: options.name,\n      type: options.type ?? ChannelType.GuildText,\n    };\n    if (options.topic) body.topic = options.topic;\n    if (options.bitrate) body.bitrate = options.bitrate;\n    if (options.userLimit) body.user_limit = options.userLimit;\n    if (options.rateLimitPerUser) body.rate_limit_per_user = options.rateLimitPerUser;\n    if (options.position !== undefined) body.position = options.position;\n    if (options.permissionOverwrites) body.permission_overwrites = options.permissionOverwrites;\n    if (options.parent) body.parent_id = options.parent;\n    if (options.nsfw !== undefined) body.nsfw = options.nsfw;\n    \n    const data = await this.client.rest.request('POST', `/guilds/${this.guild.id}/channels`, body);\n    return this._add(data);\n  }\n\n  /**\n   * Delete a channel\n   */\n  async delete(id: string, reason?: string): Promise<void> {\n    await this.client.rest.request('DELETE', `/channels/${id}`, reason ? { reason } : undefined);\n    this.cache.delete(id);\n  }\n\n  /**\n   * Edit a channel\n   */\n  async edit(id: string, data: {\n    name?: string;\n    type?: ChannelType;\n    position?: number;\n    topic?: string;\n    nsfw?: boolean;\n    rateLimitPerUser?: number;\n    bitrate?: number;\n    userLimit?: number;\n    permissionOverwrites?: any[];\n    parent?: string | null;\n  }): Promise<any> {\n    const body: any = {};\n    if (data.name) body.name = data.name;\n    if (data.type !== undefined) body.type = data.type;\n    if (data.position !== undefined) body.position = data.position;\n    if (data.topic !== undefined) body.topic = data.topic;\n    if (data.nsfw !== undefined) body.nsfw = data.nsfw;\n    if (data.rateLimitPerUser !== undefined) body.rate_limit_per_user = data.rateLimitPerUser;\n    if (data.bitrate !== undefined) body.bitrate = data.bitrate;\n    if (data.userLimit !== undefined) body.user_limit = data.userLimit;\n    if (data.permissionOverwrites) body.permission_overwrites = data.permissionOverwrites;\n    if (data.parent !== undefined) body.parent_id = data.parent;\n    \n    const result = await this.client.rest.request('PATCH', `/channels/${id}`, body);\n    return this._add(result);\n  }\n\n  /**\n   * Set channel positions\n   */\n  async setPositions(positions: Array<{ channel: string; position: number; parent?: string | null }>): Promise<void> {\n    const body = positions.map(p => ({\n      id: p.channel,\n      position: p.position,\n      parent_id: p.parent,\n    }));\n    await this.client.rest.request('PATCH', `/guilds/${this.guild.id}/channels`, body);\n  }\n}\n\n/**\n * Global channel manager for the client\n */\nexport class ChannelManager extends CachedManager<string, any> {\n  constructor(client: any, iterable?: Iterable<any>) {\n    super(client, Object as any, iterable);\n  }\n\n  _add(data: any, cache = true): any {\n    const id = data.id;\n    const existing = this.cache.get(id);\n    if (existing) {\n      if (cache) Object.assign(existing, data);\n      return existing;\n    }\n    \n    const channel = { ...data, id };\n    if (cache) this.cache.set(id, channel);\n    return channel;\n  }\n\n  async fetch(id: string, options?: { cache?: boolean; force?: boolean }): Promise<any> {\n    if (!options?.force) {\n      const existing = this.cache.get(id);\n      if (existing) return existing;\n    }\n    const data = await this.client.rest.request('GET', `/channels/${id}`);\n    return this._add(data, options?.cache ?? true);\n  }\n}\n\nexport default GuildChannelManager;\n"]}