@impulsedev/chameleon 1.1.0

package/dist/index.js

@@ -0,0 +1,3814 @@
+// src/types/user/index.ts
+var UserFlag = {
+  STAFF: 1 << 0,
+  PARTNER: 1 << 1,
+  HYPESQUAD: 1 << 2,
+  BUG_HUNTER_LEVEL_1: 1 << 3,
+  HYPESQUAD_ONLINE_HOUSE_1: 1 << 6,
+  HYPESQUAD_ONLINE_HOUSE_2: 1 << 7,
+  HYPESQUAD_ONLINE_HOUSE_3: 1 << 8,
+  PREMIUM_EARLY_SUPPORTER: 1 << 9,
+  TEAM_PSEUDO_USER: 1 << 10,
+  BUG_HUNTER_LEVEL_2: 1 << 14,
+  VERIFIED_BOT: 1 << 16,
+  VERIFIED_DEVELOPER: 1 << 17,
+  CERTIFIED_MODERATOR: 1 << 18,
+  BOT_HTTP_INTERACTIONS: 1 << 19
+};
+var PremiumType = {
+  NONE: 0,
+  NITRO_CLASSIC: 1,
+  // older users have it / user that got a classic sub, nowdays not used
+  NITRO: 2,
+  NITRO_BASIC: 3
+};
+var VisibilityType = {
+  NONE: 0,
+  EVERYONE: 1
+};
+
+// src/types/guild/index.ts
+var DefaultMessageNotificationLevel = {
+  ALL_MESSAGES: 0,
+  ONLY_MENTIONS: 1
+};
+var ExplicitContentFilterLevel = {
+  DISABLED: 0,
+  MEMBERS_WITHOUT_ROLES: 1,
+  ALL_MEMBERS: 2
+};
+var MFALevel = {
+  NONE: 0,
+  ELEVATED: 1
+};
+var VerificationLevel = {
+  NONE: 0,
+  LOW: 1,
+  MEDIUM: 2,
+  HIGH: 3,
+  VERY_HIGH: 4
+};
+var GuildNSFWLevel = {
+  DEFAULT: 0,
+  EXPLICIT: 1,
+  SAFE: 2,
+  AGE_RESTRICTED: 3
+};
+var PremiumTier = {
+  NONE: 0,
+  TIER_1: 1,
+  TIER_2: 2,
+  TIER_3: 3
+};
+var SystemChannelFlag = {
+  SUPPRESS_JOIN_NOTIFICATIONS: 1 << 0,
+  SUPPRESS_PREMIUM_SUBSCRIPTIONS: 1 << 1,
+  SUPPRESS_GUILD_REMINDER_NOTIFICATIONS: 1 << 2,
+  SUPPRESS_JOIN_NOTIFICATION_REPLIES: 1 << 3,
+  SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATIONS: 1 << 4,
+  SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATION_REPLIES: 1 << 5
+};
+var GuildMemberFlag = {
+  DID_REJOIN: 1 << 0,
+  COMPLETED_ONBOARDING: 1 << 1,
+  BYPASSES_VERIFICATION: 1 << 2,
+  STARTED_ONBOARDING: 1 << 3,
+  IS_GUEST: 1 << 4,
+  STARTED_HOME_ACTIONS: 1 << 5,
+  COMPLETED_HOME_ACTIONS: 1 << 6,
+  AUTOMOD_QUARANTINED_USERNAME: 1 << 7,
+  DM_SETTINGS_UPSELL_ACKNOWLEDGED: 1 << 9,
+  AUTOMOD_QUARANTINED_GUILD_TAG: 1 << 10
+};
+
+// src/types/channel/index.ts
+var ChannelType = {
+  GUILD_TEXT: 0,
+  DM: 1,
+  GUILD_VOICE: 2,
+  GROUP_DM: 3,
+  GUILD_CATEGORY: 4,
+  GUILD_ANNOUNCEMENT: 5,
+  ANNOUNCEMENT_THREAD: 10,
+  PUBLIC_THREAD: 11,
+  PRIVATE_THREAD: 12,
+  GUILD_STAGE_VOICE: 13,
+  GUILD_DIRECTORY: 14,
+  GUILD_FORUM: 15,
+  GUILD_MEDIA: 16
+};
+var VideoQualityMode = {
+  AUTO: 1,
+  FULL: 2
+};
+var ChannelFlag = {
+  PINNED: 1 << 1,
+  REQUIRE_TAG: 1 << 4,
+  HIDE_MEDIA_DOWNLOAD_OPTIONS: 1 << 15
+};
+var SortOrderType = {
+  LATEST_ACTIVITY: 0,
+  CREATION_DATE: 1
+};
+var ForumLayoutType = {
+  NOT_SET: 0,
+  LIST_VIEW: 1,
+  GALLERY_VIEW: 2
+};
+
+// src/types/message/index.ts
+var MessageType = {
+  DEFAULT: 0,
+  RECIPIENT_ADD: 1,
+  RECIPIENT_REMOVE: 2,
+  CALL: 3,
+  CHANNEL_NAME_CHANGE: 4,
+  CHANNEL_ICON_CHANGE: 5,
+  CHANNEL_PINNED_MESSAGE: 6,
+  USER_JOIN: 7,
+  GUILD_BOOST: 8,
+  GUILD_BOOST_TIER_1: 9,
+  GUILD_BOOST_TIER_2: 10,
+  GUILD_BOOST_TIER_3: 11,
+  CHANNEL_FOLLOW_ADD: 12,
+  GUILD_DISCOVERY_DISQUALIFIED: 14,
+  GUILD_DISCOVERY_REQUALIFIED: 15,
+  GUILD_DISCOVERY_GRACE_PERIOD_INITIAL_WARNING: 16,
+  GUILD_DISCOVERY_GRACE_PERIOD_FINAL_WARNING: 17,
+  THREAD_CREATED: 18,
+  REPLY: 19,
+  CHAT_INPUT_COMMAND: 20,
+  THREAD_STARTER_MESSAGE: 21,
+  GUILD_INVITE_REMINDER: 22,
+  CONTEXT_MENU_COMMAND: 23,
+  AUTO_MODERATION_ACTION: 24,
+  ROLE_SUBSCRIPTION_PURCHASE: 25,
+  INTERACTION_PREMIUM_UPSELL: 26,
+  STAGE_START: 27,
+  STAGE_END: 28,
+  STAGE_SPEAKER: 29,
+  STAGE_TOPIC: 31,
+  GUILD_APPLICATION_PREMIUM_SUBSCRIPTION: 32,
+  GUILD_INCIDENT_ALERT_MODE_ENABLED: 36,
+  GUILD_INCIDENT_ALERT_MODE_DISABLED: 37,
+  GUILD_INCIDENT_REPORT_RAID: 38,
+  GUILD_INCIDENT_REPORT_FALSE_ALARM: 39,
+  PURCHASE_NOTIFICATION: 44,
+  POLL_RESULT: 46
+};
+var MessageActivityType = {
+  JOIN: 1,
+  SPECTATE: 2,
+  LISTEN: 3,
+  JOIN_REQUEST: 5
+};
+var MessageFlag = {
+  CROSSPOSTED: 1 << 0,
+  IS_CROSSPOST: 1 << 1,
+  SUPPRESS_EMBEDS: 1 << 2,
+  SOURCE_MESSAGE_DELETED: 1 << 3,
+  URGENT: 1 << 4,
+  HAS_THREAD: 1 << 5,
+  EPHEMERAL: 1 << 6,
+  LOADING: 1 << 7,
+  FAILED_TO_MENTION_SOME_ROLES_IN_THREAD: 1 << 8,
+  SUPPRESS_NOTIFICATIONS: 1 << 12,
+  IS_VOICE_MESSAGE: 1 << 13,
+  HAS_SNAPSHOT: 1 << 14,
+  IS_COMPONENTS_V2: 1 << 15
+};
+var MessageReferenceType = {
+  DEFAULT: 0,
+  FORWARD: 1
+};
+var EmbedType = {
+  RICH: "rich",
+  IMAGE: "image",
+  VIDEO: "video",
+  GIFV: "gifv",
+  ARTICLE: "article",
+  LINK: "link",
+  POLL_RESULT: "poll_result"
+};
+var AttachmentFlag = {
+  IS_CLIP: 1 << 0,
+  IS_THUMBNAIL: 1 << 1,
+  IS_REMIX: 1 << 2,
+  IS_SPOILER: 1 << 3,
+  IS_ANIMATED: 1 << 5
+};
+
+// src/types/application/index.ts
+var ApplicationFlag = {
+  APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE: 1 << 6,
+  GATEWAY_PRESENCE: 1 << 12,
+  GATEWAY_PRESENCE_LIMITED: 1 << 13,
+  GATEWAY_GUILD_MEMBERS: 1 << 14,
+  GATEWAY_GUILD_MEMBERS_LIMITED: 1 << 15,
+  VERIFICATION_PENDING_GUILD_LIMIT: 1 << 16,
+  EMBEDDED: 1 << 17,
+  GATEWAY_MESSAGE_CONTENT: 1 << 18,
+  GATEWAY_MESSAGE_CONTENT_LIMITED: 1 << 19,
+  APPLICATION_COMMAND_BADGE: 1 << 23
+};
+var ApplicationIntegrationType = {
+  GUILD_INSTALL: 0,
+  USER_INSTALL: 1
+};
+var ApplicationEventWebhookStatus = {
+  DISABLED: 1,
+  ENABLED: 2,
+  DISABLED_BY_DISCORD: 3
+};
+var ActivityLocationKind = {
+  GUILD_CHANNEL: "gc",
+  PRIVATE_CHANNEL: "pc"
+};
+var ApplicationRoleConnectionMetadataType = {
+  INTEGER_LESS_THAN_OR_EQUAL: 1,
+  INTEGER_GREATER_THAN_OR_EQUAL: 2,
+  INTEGER_EQUAL: 3,
+  INTEGER_NOT_EQUAL: 4,
+  DATETIME_LESS_THAN_OR_EQUAL: 5,
+  DATETIME_GREATER_THAN_OR_EQUAL: 6,
+  BOOLEAN_EQUAL: 7,
+  BOOLEAN_NOT_EQUAL: 8
+};
+var ApplicationCommandType = {
+  CHAT_INPUT: 1,
+  USER: 2,
+  MESSAGE: 3,
+  PRIMARY_ENTRY_POINT: 4
+};
+var ApplicationCommandOptionType = {
+  SUB_COMMAND: 1,
+  SUB_COMMAND_GROUP: 2,
+  STRING: 3,
+  INTEGER: 4,
+  BOOLEAN: 5,
+  USER: 6,
+  CHANNEL: 7,
+  ROLE: 8,
+  MENTIONABLE: 9,
+  NUMBER: 10,
+  ATTACHMENT: 11
+};
+
+// src/types/types.ts
+var IntentBits = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1,
+  GuildModeration: 1 << 2,
+  GuildEmojisAndStickers: 1 << 3,
+  GuildIntegrations: 1 << 4,
+  GuildWebhooks: 1 << 5,
+  GuildInvites: 1 << 6,
+  GuildVoiceStates: 1 << 7,
+  GuildPresences: 1 << 8,
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15,
+  GuildScheduledEvents: 1 << 16,
+  AutoModerationConfiguration: 1 << 20,
+  AutoModerationExecution: 1 << 21,
+  GuildMessagePolls: 1 << 24,
+  DirectMessagePolls: 1 << 25
+};
+var Intents = {
+  ...IntentBits,
+  Moderation: [
+    IntentBits.GuildModeration,
+    IntentBits.AutoModerationConfiguration,
+    IntentBits.AutoModerationExecution
+    // todo: add rest
+  ]
+};
+var DISCORD_GATEWAY_OPCODES = /* @__PURE__ */ ((DISCORD_GATEWAY_OPCODES2) => {
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["DISPATCH"] = 0] = "DISPATCH";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["HEARTBEAT"] = 1] = "HEARTBEAT";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["IDENTIFY"] = 2] = "IDENTIFY";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["PRESENCE_UPDATE"] = 3] = "PRESENCE_UPDATE";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["VOICE_STATE_UPDATE"] = 4] = "VOICE_STATE_UPDATE";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["RESUME"] = 6] = "RESUME";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["RECONNECT"] = 7] = "RECONNECT";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["REQUEST_GUILD_MEMBERS"] = 8] = "REQUEST_GUILD_MEMBERS";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["INVALID_SESSION"] = 9] = "INVALID_SESSION";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["HELLO"] = 10] = "HELLO";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["HEARTBEAT_ACK"] = 11] = "HEARTBEAT_ACK";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["REQUEST_SOUNDBOARD_SOUNDS"] = 31] = "REQUEST_SOUNDBOARD_SOUNDS";
+  DISCORD_GATEWAY_OPCODES2[DISCORD_GATEWAY_OPCODES2["REQUEST_CHANNEL_INFO"] = 43] = "REQUEST_CHANNEL_INFO";
+  return DISCORD_GATEWAY_OPCODES2;
+})(DISCORD_GATEWAY_OPCODES || {});
+var DISCORD_PERMISSIONS = {
+  CREATE_INSTANT_INVITE: 1n << 0n,
+  KICK_MEMBERS: 1n << 1n,
+  BAN_MEMBERS: 1n << 2n,
+  ADMINISTRATOR: 1n << 3n,
+  MANAGE_CHANNELS: 1n << 4n,
+  MANAGE_GUILD: 1n << 5n,
+  ADD_REACTIONS: 1n << 6n,
+  VIEW_AUDIT_LOG: 1n << 7n,
+  PRIORITY_SPEAKER: 1n << 8n,
+  STREAM: 1n << 9n,
+  VIEW_CHANNEL: 1n << 10n,
+  SEND_MESSAGES: 1n << 11n,
+  SEND_TTS_MESSAGES: 1n << 12n,
+  MANAGE_MESSAGES: 1n << 13n,
+  EMBED_LINKS: 1n << 14n,
+  ATTACH_FILES: 1n << 15n,
+  READ_MESSAGE_HISTORY: 1n << 16n,
+  MENTION_EVERYONE: 1n << 17n,
+  USE_EXTERNAL_EMOJIS: 1n << 18n,
+  VIEW_GUILD_INSIGHTS: 1n << 19n,
+  CONNECT: 1n << 20n,
+  SPEAK: 1n << 21n,
+  MUTE_MEMBERS: 1n << 22n,
+  DEAFEN_MEMBERS: 1n << 23n,
+  MOVE_MEMBERS: 1n << 24n,
+  USE_VAD: 1n << 25n,
+  CHANGE_NICKNAME: 1n << 26n,
+  MANAGE_NICKNAMES: 1n << 27n,
+  MANAGE_ROLES: 1n << 28n,
+  MANAGE_WEBHOOKS: 1n << 29n,
+  MANAGE_GUILD_EXPRESSIONS: 1n << 30n,
+  USE_APPLICATION_COMMANDS: 1n << 31n,
+  REQUEST_TO_SPEAK: 1n << 32n,
+  MANAGE_EVENTS: 1n << 33n,
+  MANAGE_THREADS: 1n << 34n,
+  CREATE_PUBLIC_THREADS: 1n << 35n,
+  CREATE_PRIVATE_THREADS: 1n << 36n,
+  USE_EXTERNAL_STICKERS: 1n << 37n,
+  SEND_MESSAGES_IN_THREADS: 1n << 38n,
+  USE_EMBEDDED_ACTIVITIES: 1n << 39n,
+  MODERATE_MEMBERS: 1n << 40n,
+  VIEW_CREATOR_MONETIZATION_ANALYTICS: 1n << 41n,
+  USE_SOUNDBOARD: 1n << 42n,
+  CREATE_GUILD_EXPRESSIONS: 1n << 43n,
+  CREATE_EVENTS: 1n << 44n,
+  USE_EXTERNAL_SOUNDS: 1n << 45n,
+  SEND_VOICE_MESSAGES: 1n << 46n,
+  SET_VOICE_CHANNEL_STATUS: 1n << 48n,
+  SEND_POLLS: 1n << 49n,
+  USE_EXTERNAL_APPS: 1n << 50n,
+  PIN_MESSAGES: 1n << 51n,
+  BYPASS_SLOWMODE: 1n << 52n
+};
+var AUDIT_LOG_EVENT_TYPES = {
+  GUILD_UPDATE: 1,
+  CHANNEL_CREATE: 10,
+  CHANNEL_UPDATE: 11,
+  CHANNEL_DELETE: 12,
+  CHANNEL_OVERWRITE_CREATE: 13,
+  CHANNEL_OVERWRITE_UPDATE: 14,
+  CHANNEL_OVERWRITE_DELETE: 15,
+  MEMBER_KICK: 20,
+  MEMBER_PRUNE: 21,
+  MEMBER_BAN_ADD: 22,
+  MEMBER_BAN_REMOVE: 23,
+  MEMBER_UPDATE: 24,
+  MEMBER_ROLE_UPDATE: 25,
+  MEMBER_MOVE: 26,
+  MEMBER_DISCONNECT: 27,
+  BOT_ADD: 28,
+  ROLE_CREATE: 30,
+  ROLE_UPDATE: 31,
+  ROLE_DELETE: 32,
+  INVITE_CREATE: 40,
+  INVITE_UPDATE: 41,
+  INVITE_DELETE: 42,
+  WEBHOOK_CREATE: 50,
+  WEBHOOK_UPDATE: 51,
+  WEBHOOK_DELETE: 52,
+  EMOJI_CREATE: 60,
+  EMOJI_UPDATE: 61,
+  EMOJI_DELETE: 62,
+  MESSAGE_DELETE: 72,
+  MESSAGE_BULK_DELETE: 73,
+  MESSAGE_PIN: 74,
+  MESSAGE_UNPIN: 75,
+  INTEGRATION_CREATE: 80,
+  INTEGRATION_UPDATE: 81,
+  INTEGRATION_DELETE: 82,
+  STAGE_INSTANCE_CREATE: 83,
+  STAGE_INSTANCE_UPDATE: 84,
+  STAGE_INSTANCE_DELETE: 85,
+  STICKER_CREATE: 90,
+  STICKER_UPDATE: 91,
+  STICKER_DELETE: 92,
+  GUILD_SCHEDULED_EVENT_CREATE: 100,
+  GUILD_SCHEDULED_EVENT_UPDATE: 101,
+  GUILD_SCHEDULED_EVENT_DELETE: 102,
+  THREAD_CREATE: 110,
+  THREAD_UPDATE: 111,
+  THREAD_DELETE: 112,
+  APPLICATION_COMMAND_PERMISSION_UPDATE: 121,
+  SOUNDBOARD_SOUND_CREATE: 130,
+  SOUNDBOARD_SOUND_UPDATE: 131,
+  SOUNDBOARD_SOUND_DELETE: 132,
+  AUTO_MODERATION_RULE_CREATE: 140,
+  AUTO_MODERATION_RULE_UPDATE: 141,
+  AUTO_MODERATION_RULE_DELETE: 142,
+  AUTO_MODERATION_BLOCK_MESSAGE: 143,
+  AUTO_MODERATION_FLAG_TO_CHANNEL: 144,
+  AUTO_MODERATION_USER_COMMUNICATION_DISABLED: 145,
+  AUTO_MODERATION_QUARANTINE_USER: 146,
+  CREATOR_MONETIZATION_REQUEST_CREATED: 150,
+  CREATOR_MONETIZATION_TERMS_ACCEPTED: 151,
+  ONBOARDING_PROMPT_CREATE: 163,
+  ONBOARDING_PROMPT_UPDATE: 164,
+  ONBOARDING_PROMPT_DELETE: 165,
+  ONBOARDING_CREATE: 166,
+  ONBOARDING_UPDATE: 167,
+  HOME_SETTINGS_CREATE: 190,
+  HOME_SETTINGS_UPDATE: 191,
+  VOICE_CHANNEL_STATUS_UPDATE: 192,
+  VOICE_CHANNEL_STATUS_DELETE: 193
+};
+var Activity = /* @__PURE__ */ ((Activity2) => {
+  Activity2[Activity2["PLAYING"] = 0] = "PLAYING";
+  Activity2[Activity2["STREAMING"] = 1] = "STREAMING";
+  Activity2[Activity2["LISTENING"] = 2] = "LISTENING";
+  Activity2[Activity2["WATCHING"] = 3] = "WATCHING";
+  Activity2[Activity2["CUSTOM"] = 4] = "CUSTOM";
+  Activity2[Activity2["COMPETING"] = 5] = "COMPETING";
+  return Activity2;
+})(Activity || {});
+
+// src/types/automod/index.ts
+var AutoModerationEventType = {
+  MESSAGE_SEND: 1,
+  MEMBER_UPDATE: 2
+};
+var AutoModerationTriggerType = {
+  KEYWORD: 1,
+  SPAM: 3,
+  KEYWORD_PRESET: 4,
+  MENTION_SPAM: 5,
+  MEMBER_PROFILE: 6
+};
+var AutoModerationKeywordPresetType = {
+  PROFANITY: 1,
+  SEXUAL_CONTENT: 2,
+  SLURS: 3
+};
+var AutoModerationActionType = {
+  BLOCK_MESSAGE: 1,
+  SEND_ALERT_MESSAGE: 2,
+  TIMEOUT: 3,
+  BLOCK_MEMBER_INTERACTION: 4
+};
+
+// src/types/components/index.ts
+var ComponentType = {
+  ACTION_ROW: 1,
+  BUTTON: 2,
+  STRING_SELECT: 3,
+  TEXT_INPUT: 4,
+  USER_SELECT: 5,
+  ROLE_SELECT: 6,
+  MENTIONABLE_SELECT: 7,
+  CHANNEL_SELECT: 8
+};
+var ButtonStyle = {
+  PRIMARY: 1,
+  SECONDARY: 2,
+  SUCCESS: 3,
+  DANGER: 4,
+  LINK: 5,
+  PREMIUM: 6
+};
+
+// src/types/entitlement/index.ts
+var EntitlementType = {
+  PURCHASE: 1,
+  PREMIUM_SUBSCRIPTION: 2,
+  DEVELOPER_GIFT: 3,
+  TEST_MODE_PURCHASE: 4,
+  FREE_PURCHASE: 5,
+  USER_GIFT: 6,
+  PREMIUM_PURCHASE: 7,
+  APPLICATION_SUBSCRIPTION: 8
+};
+
+// src/types/expressions/index.ts
+var StickerType = {
+  STANDARD: 1,
+  GUILD: 2
+};
+var StickerFormatType = {
+  PNG: 1,
+  APNG: 2,
+  LOTTIE: 3,
+  GIF: 4
+};
+
+// src/types/integration/index.ts
+var IntegrationExpireBehavior = {
+  REMOVE_ROLE: 0,
+  KICK: 1
+};
+
+// src/types/invite/index.ts
+var InviteType = {
+  GUILD: 0,
+  GROUP_DM: 1,
+  FRIEND: 2
+};
+var InviteTargetType = {
+  STREAM: 1,
+  EMBEDDED_APPLICATION: 2
+};
+var GuildInviteFlag = {
+  IS_GUEST_INVITE: 1 << 0
+};
+
+// src/types/lobby/index.ts
+var LobbyMemberFlag = {
+  CAN_LINK_LOBBY: 1 << 0
+};
+
+// src/types/scheduled/index.ts
+var GuildScheduledEventPrivacyLevel = {
+  GUILD_ONLY: 2
+};
+var GuildScheduledEventStatus = {
+  SCHEDULED: 1,
+  ACTIVE: 2,
+  COMPLETED: 3,
+  CANCELED: 4
+};
+var GuildScheduledEventEntityType = {
+  STAGE_INSTANCE: 1,
+  VOICE: 2,
+  EXTERNAL: 3
+};
+
+// src/types/sku/index.ts
+var SkuType = {
+  DURABLE: 2,
+  CONSUMABLE: 3,
+  SUBSCRIPTION: 5,
+  SUBSCRIPTION_GROUP: 6
+};
+var SkuFlag = {
+  AVAILABLE: 1 << 2,
+  GUILD_SUBSCRIPTION: 1 << 7,
+  USER_SUBSCRIPTION: 1 << 8
+};
+
+// src/types/stage/index.ts
+var StagePrivacyLevel = {
+  PUBLIC: 1,
+  GUILD_ONLY: 2
+};
+
+// src/types/subscription/index.ts
+var SubscriptionStatus = {
+  ACTIVE: 0,
+  ENDING: 1,
+  INACTIVE: 2
+};
+
+// src/types/voice/index.ts
+var CHAMELEON_SELF_MAP = {
+  selfMute: "userMuted",
+  selfDeaf: "userDeafened",
+  selfStream: "userStreaming",
+  selfVideo: "userVideo"
+};
+
+// src/types/webhook/index.ts
+var WebhookType = {
+  INCOMING: 1,
+  CHANNEL_FOLLOWER: 2,
+  APPLICATION: 3
+};
+
+// src/utils/tongue.ts
+var Tongue = class {
+  map;
+  max;
+  constructor(maxSize = Infinity) {
+    this.map = /* @__PURE__ */ new Map();
+    this.max = maxSize;
+  }
+  get(key) {
+    if (!this.map.has(key)) return void 0;
+    const val = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, val);
+    return val;
+  }
+  set(key, val) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.max) {
+      const firstKey = this.map.keys().next().value;
+      if (firstKey !== void 0) this.map.delete(firstKey);
+    }
+    this.map.set(key, val);
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+  values() {
+    return this.map.values();
+  }
+  keys() {
+    return this.map.keys();
+  }
+};
+
+// src/client/store.ts
+var TongueStore = class {
+  guilds;
+  roles;
+  channels;
+  users;
+  members;
+  messages;
+  emojis;
+  stickers;
+  stageInstances;
+  scheduledEvents;
+  autoModRules;
+  integrations;
+  constructor(options) {
+    this.guilds = new Tongue(options?.guilds ?? Infinity);
+    this.roles = new Tongue(options?.roles ?? Infinity);
+    this.channels = new Tongue(options?.channels ?? Infinity);
+    this.members = new Tongue(options?.members ?? 1e3);
+    this.messages = new Tongue(options?.messages ?? 100);
+    this.users = new Tongue(options?.users ?? Infinity);
+    this.emojis = new Tongue(options?.emojis ?? Infinity);
+    this.stickers = new Tongue(options?.stickers ?? Infinity);
+    this.stageInstances = new Tongue(options?.stageInstances ?? Infinity);
+    this.scheduledEvents = new Tongue(options?.scheduledEvents ?? Infinity);
+    this.autoModRules = new Tongue(options?.autoModRules ?? Infinity);
+    this.integrations = new Tongue(options?.integrations ?? Infinity);
+  }
+  static memberKey(guildId, userId) {
+    return `${guildId}_${userId}`;
+  }
+};
+
+// src/rest/rates.ts
+var RateLimitError = class extends Error {
+  constructor(delay, global) {
+    super("Rate limited");
+    this.delay = delay;
+    this.global = global;
+  }
+  delay;
+  global;
+};
+var Bucket = class {
+  remaining = 1;
+  resetTimestamp = 0;
+  promiseQueue = Promise.resolve();
+  async queue(fn) {
+    return new Promise((resolve2, reject) => {
+      this.promiseQueue = this.promiseQueue.then(async () => {
+        while (true) {
+          if (this.remaining <= 0 && Date.now() < this.resetTimestamp) {
+            await new Promise((r) => setTimeout(r, this.resetTimestamp - Date.now()));
+          }
+          this.remaining--;
+          try {
+            const res = await fn();
+            resolve2(res);
+            break;
+          } catch (e) {
+            if (e instanceof RateLimitError) {
+              await new Promise((r) => setTimeout(r, e.delay));
+              continue;
+            }
+            reject(e);
+            break;
+          }
+        }
+      });
+    });
+  }
+};
+var RateLimiter = class {
+  globalReset = 0;
+  routeToBucket = /* @__PURE__ */ new Map();
+  buckets = /* @__PURE__ */ new Map();
+  getRoute(method, endpoint) {
+    const path2 = endpoint.replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, (match, p1) => {
+      if (["channels", "guilds", "webhooks"].includes(p1)) {
+        return match;
+      }
+      return `/${p1}/:id`;
+    });
+    const reactionRoute = path2.replace(/\/reactions\/[^/]+\/?(@me|[0-9]{17,19})?/g, "/reactions/:emoji/:id");
+    return `${method} ${reactionRoute}`;
+  }
+  async execute(method, endpoint, requestFn) {
+    const route = this.getRoute(method, endpoint);
+    const bucketId = this.routeToBucket.get(route) ?? route;
+    let bucket = this.buckets.get(bucketId);
+    if (!bucket) {
+      bucket = new Bucket();
+      this.buckets.set(bucketId, bucket);
+    }
+    const initialBucket = bucket;
+    return initialBucket.queue(async () => {
+      if (Date.now() < this.globalReset) {
+        await new Promise((r) => setTimeout(r, this.globalReset - Date.now()));
+      }
+      const response = await requestFn();
+      const global = response.headers.get("x-ratelimit-global") === "true";
+      const retryAfter = response.headers.get("retry-after");
+      if (response.status === 429) {
+        const delay = retryAfter ? parseFloat(retryAfter) * 1e3 : 5e3;
+        if (global) {
+          this.globalReset = Date.now() + delay;
+        }
+        throw new RateLimitError(delay, global);
+      }
+      const hash = response.headers.get("x-ratelimit-bucket");
+      const remaining = response.headers.get("x-ratelimit-remaining");
+      const resetAfter = response.headers.get("x-ratelimit-reset-after");
+      let targetBucket = initialBucket;
+      if (hash) {
+        if (hash !== bucketId) {
+          this.routeToBucket.set(route, hash);
+          if (!this.buckets.has(hash)) {
+            this.buckets.set(hash, initialBucket);
+          } else {
+            targetBucket = this.buckets.get(hash);
+          }
+        }
+      }
+      if (remaining !== null) {
+        targetBucket.remaining = parseInt(remaining, 10);
+      }
+      if (resetAfter !== null) {
+        targetBucket.resetTimestamp = Date.now() + parseFloat(resetAfter) * 1e3;
+      }
+      return response;
+    });
+  }
+};
+
+// src/rest/index.ts
+var ChameleonREST = class {
+  token;
+  version;
+  baseUrl;
+  limiter;
+  constructor(options) {
+    this.token = options.token;
+    this.version = options.version ?? 10;
+    this.baseUrl = `https://discord.com/api/v${this.version}`;
+    this.limiter = new RateLimiter();
+  }
+  /**
+   * Internal generic request handler that doesn't throw, returning `{ ok: boolean, ... }` shape
+   */
+  async request(method, endpoint, body, headers) {
+    const path2 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    const url = `${this.baseUrl}${path2}`;
+    const reqHeaders = {
+      "Authorization": `Bot ${this.token}`,
+      "User-Agent": "Chameleon (https://github.com/impulsedoes/chameleon)",
+      ...headers
+    };
+    let reqBody = void 0;
+    if (body) {
+      reqHeaders["Content-Type"] = "application/json";
+      reqBody = JSON.stringify(body);
+    }
+    try {
+      const response = await this.limiter.execute(method, path2, () => fetch(url, {
+        method,
+        headers: reqHeaders,
+        ...reqBody !== void 0 ? { body: reqBody } : {}
+      }));
+      let data = null;
+      if (response.status !== 204) {
+        const text = await response.text();
+        if (text) {
+          try {
+            data = JSON.parse(text);
+          } catch {
+            data = text;
+          }
+        }
+      }
+      if (response.ok) {
+        return { ok: true, data };
+      }
+      const errData = data;
+      return {
+        ok: false,
+        status: response.status,
+        ...typeof errData?.code === "number" ? { code: errData.code } : {},
+        message: typeof errData?.message === "string" ? errData.message : response.statusText,
+        raw: data
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        status: 0,
+        message: error instanceof Error ? error.message : "Unknown network error"
+      };
+    }
+  }
+  get(endpoint, headers) {
+    return this.request("GET", endpoint, void 0, headers);
+  }
+  post(endpoint, body, headers) {
+    return this.request("POST", endpoint, body, headers);
+  }
+  put(endpoint, body, headers) {
+    return this.request("PUT", endpoint, body, headers);
+  }
+  patch(endpoint, body, headers) {
+    return this.request("PATCH", endpoint, body, headers);
+  }
+  delete(endpoint, headers) {
+    return this.request("DELETE", endpoint, void 0, headers);
+  }
+};
+
+// src/gateway/index.ts
+var FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([
+  4004,
+  // Authentication failed
+  4010,
+  // Invalid shard
+  4011,
+  // Sharding required
+  4012,
+  // Invalid API version
+  4013,
+  // Invalid intent(s)
+  4014
+  // Disallowed intent(s)
+]);
+var NO_RESUME_CLOSE_CODES = /* @__PURE__ */ new Set([
+  4007,
+  // Invalid seq
+  4009
+  // Session timed out
+]);
+var ChameleonGateway = class {
+  token;
+  intents;
+  version;
+  ms = -1;
+  encoding;
+  largeThreshold;
+  shard;
+  status = "idle";
+  ws = null;
+  heartbeatTimer = null;
+  heartbeatIntervalMs = 45e3;
+  heartbeatAcked = true;
+  seq = null;
+  sessionId = null;
+  baseUrl;
+  resumeUrl = null;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  _lastHeartbeatSend = 0;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.token = options.token;
+    this.intents = options.intents;
+    this.version = options.version ?? 10;
+    this.encoding = options.encoding ?? "json";
+    this.largeThreshold = options.largeThreshold ?? 50;
+    this.baseUrl = `wss://gateway.discord.gg/?v=${this.version}&encoding=${this.encoding}`;
+    if (options.shard !== void 0) this.shard = options.shard;
+  }
+  /**
+   * Open a new WebSocket connection to the Gateway,
+   * if resuming, uses the resume_gateway_url, otherwise uses the base URL
+   */
+  connect() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.clearReconnectTimer();
+    const isResuming = this.canResume();
+    const url = isResuming && this.resumeUrl ? `${this.resumeUrl}?v=${this.version}&encoding=${this.encoding}` : this.baseUrl;
+    this.status = isResuming ? "resuming" : "connecting";
+    this.emit("debug", `[GATEWAY] Connecting to ${url} (resume=${isResuming})`);
+    this.ws = new WebSocket(url);
+    this.ws.onopen = this.onOpen.bind(this);
+    this.ws.onmessage = this.onMessage.bind(this);
+    this.ws.onclose = this.onClose.bind(this);
+    this.ws.onerror = this.onError.bind(this);
+  }
+  /**
+   * Gracefully close the connection
+   * code 1000/1001 invalidates the session
+   * any other code keeps the session alive for resume
+   */
+  disconnect(code = 1e3, reason) {
+    this.stopHeartbeat();
+    this.clearReconnectTimer();
+    if (code === 1e3 || code === 1001) {
+      this.sessionId = null;
+      this.seq = null;
+      this.resumeUrl = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(code, reason);
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.status = "disconnected";
+  }
+  /**
+   * Send a payload to the Gateway.
+   */
+  send(op, d) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({ op, d }));
+  }
+  pendingPresence = null;
+  /**
+   * Update the presence/status for this shard
+   */
+  updatePresence(options) {
+    const payload = {
+      since: options.since ?? null,
+      activities: options.activities?.map((activity) => {
+        if (activity.type === 4 /* CUSTOM */ && !activity.state) {
+          return {
+            ...activity,
+            name: "CS",
+            state: activity.name
+          };
+        }
+        if (activity.type === 1 /* STREAMING */ && !activity.url) {
+          return {
+            ...activity,
+            url: "https://twitch.tv/discord"
+          };
+        }
+        return activity;
+      }) ?? [],
+      status: options.status ?? "online",
+      afk: options.afk ?? false
+    };
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.pendingPresence = payload;
+      return;
+    }
+    this.send(3 /* PRESENCE_UPDATE */, payload);
+  }
+  /**
+   * request offline/large guild members from the Gateway
+   * this is used to lazy-load members into the cache via GUILD_MEMBERS_CHUNK events
+   */
+  requestGuildMembers(options) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("[GATEWAY] Cannot request guild members while disconnected");
+    }
+    const payload = {
+      guild_id: options.guildId,
+      limit: options.limit
+    };
+    if (options.query !== void 0) payload.query = options.query;
+    if (options.presences !== void 0) payload.presences = options.presences;
+    if (options.userIds !== void 0) payload.user_ids = options.userIds;
+    if (options.nonce !== void 0) payload.nonce = options.nonce;
+    this.send(8 /* REQUEST_GUILD_MEMBERS */, payload);
+  }
+  /**
+   * Register an event listener.
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(listener);
+  }
+  /**
+   * Remove all listeners for a specific event, or all listeners entirely.
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      handler(data);
+    }
+  }
+  onOpen() {
+    this.emit("debug", "[GATEWAY] WebSocket connection opened");
+  }
+  onMessage(event) {
+    let payload;
+    try {
+      payload = JSON.parse(event.data);
+    } catch (err) {
+      this.emit("debug", `[GATEWAY] Failed to parse payload: ${err}`);
+      return;
+    }
+    if (payload.s !== null && payload.s !== void 0) {
+      this.seq = payload.s;
+    }
+    switch (payload.op) {
+      case 10 /* HELLO */: {
+        const hello = payload.d;
+        this.heartbeatIntervalMs = hello.heartbeat_interval;
+        this.heartbeatAcked = true;
+        this.startHeartbeat();
+        this.identify();
+        break;
+      }
+      case 11 /* HEARTBEAT_ACK */: {
+        this.heartbeatAcked = true;
+        this.ms = Date.now() - this._lastHeartbeatSend;
+        this.emit("heartbeatAck");
+        break;
+      }
+      case 1 /* HEARTBEAT */: {
+        this.sendHeartbeat();
+        break;
+      }
+      case 0 /* DISPATCH */: {
+        this.handleDispatch(payload);
+        break;
+      }
+      case 7 /* RECONNECT */: {
+        this.emit("debug", "[GATEWAY] Received Reconnect, reconnecting...");
+        this.scheduleReconnect();
+        break;
+      }
+      case 9 /* INVALID_SESSION */: {
+        const resumable = payload.d;
+        this.emit("debug", `[GATEWAY] Invalid Session (resumable=${resumable})`);
+        if (!resumable) {
+          this.sessionId = null;
+          this.seq = null;
+          this.resumeUrl = null;
+        }
+        const delay = 1e3 + Math.random() * 4e3;
+        this.disconnect(4900, "Invalid session");
+        setTimeout(() => this.connect(), delay);
+        break;
+      }
+    }
+  }
+  onClose(event) {
+    const { code, reason } = event;
+    this.stopHeartbeat();
+    this.emit("debug", `[GATEWAY] Connection closed (code=${code}, reason=${reason || "none"})`);
+    this.emit("disconnected", { code, reason });
+    if (FATAL_CLOSE_CODES.has(code)) {
+      this.status = "disconnected";
+      this.emit("error", new Error(`[GATEWAY] Fatal close code ${code}: ${reason}`));
+      return;
+    }
+    if (NO_RESUME_CLOSE_CODES.has(code)) {
+      this.sessionId = null;
+      this.seq = null;
+      this.resumeUrl = null;
+    }
+    this.status = "disconnected";
+    this.scheduleReconnect();
+  }
+  onError(event) {
+    this.emit("debug", `[GATEWAY] WebSocket error`);
+    this.emit("error", event);
+  }
+  handleDispatch(payload) {
+    const { t, d } = payload;
+    if (t === "READY") {
+      const ready = d;
+      this.sessionId = ready.session_id;
+      this.resumeUrl = ready.resume_gateway_url;
+      this.status = "connected";
+      this.reconnectAttempts = 0;
+      this.emit("debug", `[GATEWAY] READY (session=${this.sessionId})`);
+    }
+    if (t === "RESUMED") {
+      this.status = "connected";
+      this.reconnectAttempts = 0;
+      this.emit("debug", "[GATEWAY] Session resumed successfully");
+    }
+    this.emit("dispatch", payload);
+  }
+  /**
+   * Start the heartbeat loop
+   * first heartbeat is sent after interval * jitter
+   * subsequent heartbeats are sent every interval ms
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    const jitter = Math.random();
+    const firstDelay = Math.floor(this.heartbeatIntervalMs * jitter);
+    this.emit("debug", `[GATEWAY] Starting heartbeat (interval=${this.heartbeatIntervalMs}ms, firstDelay=${firstDelay}ms)`);
+    this.heartbeatTimer = setTimeout(() => {
+      this.sendHeartbeat();
+      this.heartbeatTimer = setInterval(() => {
+        this.sendHeartbeat();
+      }, this.heartbeatIntervalMs);
+    }, firstDelay);
+  }
+  /**
+   * send a single heartbeat, if the previous one was not ACKed,
+   * we close and reconnect
+   */
+  sendHeartbeat() {
+    if (!this.heartbeatAcked) {
+      this.emit("debug", "[GATEWAY] Heartbeat ACK not received, reconnecting...");
+      this.disconnect(4900, "Zombie connection (no heartbeat ACK)");
+      this.scheduleReconnect();
+      return;
+    }
+    this.heartbeatAcked = false;
+    this._lastHeartbeatSend = Date.now();
+    this.send(1 /* HEARTBEAT */, this.seq);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  canResume() {
+    return this.sessionId !== null && this.seq !== null;
+  }
+  /**
+   * send Identify or Resume depending on whether we have an active session
+   */
+  identify() {
+    if (this.canResume()) {
+      this.emit("debug", `[GATEWAY] Resuming session ${this.sessionId} at seq ${this.seq}`);
+      this.send(6 /* RESUME */, {
+        token: this.token,
+        session_id: this.sessionId,
+        seq: this.seq
+      });
+    } else {
+      this.emit("debug", "[GATEWAY] Identifying as new session");
+      this.send(2 /* IDENTIFY */, {
+        token: this.token,
+        intents: this.intents,
+        properties: {
+          os: process.platform ?? "linux",
+          browser: "chameleon",
+          device: "chameleon"
+        },
+        large_threshold: this.largeThreshold,
+        ...this.shard ? { shard: this.shard } : {},
+        ...this.pendingPresence ? { presence: this.pendingPresence } : {}
+      });
+    }
+  }
+  /**
+   * schedule a reconnect with exponential backoff
+   * delay: min(1s * 2^attempt, 30s) + jitter
+   */
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const baseDelay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    const jitter = Math.random() * 1e3;
+    const delay = baseDelay + jitter;
+    this.reconnectAttempts++;
+    this.emit("debug", `[GATEWAY] Reconnecting in ${Math.round(delay)}ms (attempt #${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// package.json
+var package_default = {
+  name: "chameleon",
+  version: "1.1.0",
+  description: "highly optimized, memory-efficient, and fully type-safe Discord API library",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  scripts: {
+    test: "vitest",
+    docs: "typedoc",
+    lint: "eslint src example",
+    "lint:fix": "eslint src example --fix",
+    prepare: "husky",
+    typecheck: "tsc --noEmit",
+    build: "npm run typecheck && tsup src/index.ts --format esm --dts --clean"
+  },
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    }
+  },
+  keywords: [
+    "api",
+    "chameleon",
+    "discord",
+    "library",
+    "typescript"
+  ],
+  author: "impulsedoes",
+  license: "MIT",
+  type: "module",
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.1",
+    "@vitest/coverage-v8": "^4.1.7",
+    eslint: "^10.4.0",
+    husky: "^9.1.7",
+    "lint-staged": "^17.0.5",
+    tsup: "^8.5.1",
+    tsx: "^4.22.3",
+    typedoc: "^0.28.19",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    vitest: "^4.1.7"
+  },
+  "lint-staged": {
+    "*.ts": "eslint --fix"
+  }
+};
+
+// src/utils/constants.ts
+var MESSAGE_FLAGS = {
+  CROSSPOSTED: 1 << 0,
+  IS_CROSSPOST: 1 << 1,
+  SUPPRESS_EMBEDS: 1 << 2,
+  SOURCE_MESSAGE_DELETED: 1 << 3,
+  URGENT: 1 << 4,
+  HAS_THREAD: 1 << 5,
+  EPHEMERAL: 1 << 6,
+  LOADING: 1 << 7,
+  FAILED_TO_MENTION_SOME_ROLES_IN_THREAD: 1 << 8,
+  SUPPRESS_NOTIFICATIONS: 1 << 12,
+  IS_VOICE_MESSAGE: 1 << 13,
+  HAS_SNAPSHOT: 1 << 14,
+  IS_COMPONENTS_V2: 1 << 15
+};
+var CHAMELEON_VERSION = package_default.version;
+var CHAMELEON = package_default.name;
+
+// src/builders/embed.ts
+var Colors = {
+  Blue: 2003199,
+  Purple: 10181046,
+  Orange: 16744272,
+  Pink: 16739201,
+  White: 16777215,
+  Blurple: 5793266,
+  Green: 5763719,
+  Yellow: 16705372,
+  Fuchsia: 15418782,
+  Red: 15548997,
+  Black: 2303786,
+  Transparent: 3092790
+};
+var EmbedBuilder = class {
+  data;
+  constructor(data) {
+    this.data = {};
+    if (!data) return;
+    if ("title" in data) this.data.title = data.title;
+    if ("description" in data) this.data.description = data.description;
+    if ("color" in data) this.data.color = data.color;
+    if ("url" in data) this.data.url = data.url;
+    if ("timestamp" in data && data.timestamp) {
+      this.data.timestamp = new Date(data.timestamp).getTime();
+    }
+    if (data.author) {
+      const author = data.author;
+      this.data.author = {
+        name: author.name,
+        url: author.url,
+        iconUrl: author.iconUrl ?? author.icon_url,
+        proxyIconUrl: author.proxyIconUrl ?? author.proxy_icon_url
+      };
+    }
+    if (data.footer) {
+      const footer = data.footer;
+      this.data.footer = {
+        text: footer.text,
+        iconUrl: footer.iconUrl ?? footer.icon_url,
+        proxyIconUrl: footer.proxyIconUrl ?? footer.proxy_icon_url
+      };
+    }
+    if (data.image) {
+      const image = data.image;
+      this.data.image = {
+        url: image.url,
+        proxyUrl: image.proxyUrl ?? image.proxy_url,
+        height: image.height,
+        width: image.width
+      };
+    }
+    if (data.thumbnail) {
+      const thumbnail = data.thumbnail;
+      this.data.thumbnail = {
+        url: thumbnail.url,
+        proxyUrl: thumbnail.proxyUrl ?? thumbnail.proxy_url,
+        height: thumbnail.height,
+        width: thumbnail.width
+      };
+    }
+    if (Array.isArray(data.fields)) {
+      this.data.fields = data.fields.map((f) => ({
+        name: f.name,
+        value: f.value,
+        inline: f.inline ?? false
+      }));
+    }
+  }
+  setTitle(title) {
+    this.data.title = title;
+    return this;
+  }
+  setDescription(description) {
+    this.data.description = description;
+    return this;
+  }
+  setColor(color) {
+    this.data.color = color;
+    return this;
+  }
+  setURL(url) {
+    this.data.url = url;
+    return this;
+  }
+  setTimestamp(ts) {
+    this.data.timestamp = ts instanceof Date ? ts.getTime() : ts ?? Date.now();
+    return this;
+  }
+  setFooter(text, iconUrl) {
+    this.data.footer = { text, ...iconUrl ? { iconUrl } : {} };
+    return this;
+  }
+  setAuthor(name, iconUrl, url) {
+    this.data.author = { name, ...iconUrl ? { iconUrl } : {}, ...url ? { url } : {} };
+    return this;
+  }
+  setImage(url) {
+    this.data.image = { url };
+    return this;
+  }
+  setThumbnail(url) {
+    this.data.thumbnail = { url };
+    return this;
+  }
+  addField(name, value, inline = false) {
+    if (!this.data.fields) this.data.fields = [];
+    this.data.fields.push({ name, value, inline });
+    return this;
+  }
+  addFields(...fields) {
+    if (!this.data.fields) this.data.fields = [];
+    this.data.fields.push(...fields);
+    return this;
+  }
+  build() {
+    return { ...this.data };
+  }
+  toJSON() {
+    const payload = {
+      ...this.data,
+      timestamp: this.data.timestamp ? new Date(this.data.timestamp).toISOString() : void 0
+    };
+    if (this.data.author) {
+      payload.author = {
+        name: this.data.author.name,
+        url: this.data.author.url,
+        icon_url: this.data.author.iconUrl,
+        proxy_icon_url: this.data.author.proxyIconUrl
+      };
+    }
+    if (this.data.footer) {
+      payload.footer = {
+        text: this.data.footer.text,
+        icon_url: this.data.footer.iconUrl,
+        proxy_icon_url: this.data.footer.proxyIconUrl
+      };
+    }
+    if (this.data.image) {
+      payload.image = {
+        url: this.data.image.url,
+        proxy_url: this.data.image.proxyUrl,
+        height: this.data.image.height,
+        width: this.data.image.width
+      };
+    }
+    if (this.data.thumbnail) {
+      payload.thumbnail = {
+        url: this.data.thumbnail.url,
+        proxy_url: this.data.thumbnail.proxyUrl,
+        height: this.data.thumbnail.height,
+        width: this.data.thumbnail.width
+      };
+    }
+    return payload;
+  }
+};
+
+// src/builders/components.ts
+var ButtonBuilder = class {
+  data = { type: ComponentType.BUTTON };
+  setCustomId(id) {
+    this.data.customId = id;
+    return this;
+  }
+  setLabel(label) {
+    this.data.label = label;
+    return this;
+  }
+  setStyle(style) {
+    this.data.style = style;
+    return this;
+  }
+  setEmoji(emoji) {
+    this.data.emoji = emoji;
+    return this;
+  }
+  setDisabled(disabled = true) {
+    this.data.disabled = disabled;
+    return this;
+  }
+  setURL(url) {
+    this.data.url = url;
+    this.data.style = ButtonStyle.LINK;
+    return this;
+  }
+  build() {
+    return { ...this.data };
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+var SelectMenuBuilder = class {
+  data = { type: ComponentType.STRING_SELECT };
+  setCustomId(id) {
+    this.data.customId = id;
+    return this;
+  }
+  setPlaceholder(placeholder) {
+    this.data.placeholder = placeholder;
+    return this;
+  }
+  setMinValues(min) {
+    this.data.minValues = min;
+    return this;
+  }
+  setMaxValues(max) {
+    this.data.maxValues = max;
+    return this;
+  }
+  setDisabled(disabled = true) {
+    this.data.disabled = disabled;
+    return this;
+  }
+  addOption(option) {
+    if (!this.data.options) this.data.options = [];
+    this.data.options.push(option);
+    return this;
+  }
+  addOptions(...options) {
+    if (!this.data.options) this.data.options = [];
+    this.data.options.push(...options);
+    return this;
+  }
+  setType(type) {
+    this.data.type = type;
+    return this;
+  }
+  build() {
+    return { ...this.data };
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+var TextInputBuilder = class {
+  data = { type: ComponentType.TEXT_INPUT };
+  setCustomId(id) {
+    this.data.customId = id;
+    return this;
+  }
+  setLabel(label) {
+    this.data.label = label;
+    return this;
+  }
+  setStyle(style) {
+    this.data.style = style;
+    return this;
+  }
+  setPlaceholder(placeholder) {
+    this.data.placeholder = placeholder;
+    return this;
+  }
+  _minLength;
+  _maxLength;
+  _required;
+  _value;
+  setMinLength(length) {
+    this._minLength = length;
+    return this;
+  }
+  setMaxLength(length) {
+    this._maxLength = length;
+    return this;
+  }
+  setRequired(required = true) {
+    this._required = required;
+    return this;
+  }
+  setValue(value) {
+    this._value = value;
+    return this;
+  }
+  build() {
+    return {
+      ...this.data,
+      minLength: this._minLength,
+      maxLength: this._maxLength,
+      required: this._required,
+      value: this._value
+    };
+  }
+  toJSON() {
+    return {
+      type: ComponentType.TEXT_INPUT,
+      custom_id: this.data.customId,
+      style: this.data.style,
+      label: this.data.label,
+      placeholder: this.data.placeholder,
+      min_length: this._minLength,
+      max_length: this._maxLength,
+      required: this._required,
+      value: this._value
+    };
+  }
+};
+var ActionRowBuilder = class {
+  data = { type: ComponentType.ACTION_ROW, components: [] };
+  addComponent(component) {
+    const built = "build" in component && typeof component.build === "function" ? component.build() : component;
+    this.data.components.push(built);
+    return this;
+  }
+  addComponents(...components) {
+    for (const c of components) this.addComponent(c);
+    return this;
+  }
+  build() {
+    return { ...this.data, components: [...this.data.components] };
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+var ModalBuilder = class {
+  _title = "";
+  _customId = "";
+  _components = [];
+  setTitle(title) {
+    this._title = title;
+    return this;
+  }
+  setCustomId(id) {
+    this._customId = id;
+    return this;
+  }
+  addComponent(row) {
+    const built = "build" in row && typeof row.build === "function" ? row.build() : row;
+    this._components.push(built);
+    return this;
+  }
+  addComponents(...rows) {
+    for (const r of rows) this.addComponent(r);
+    return this;
+  }
+  build() {
+    return {
+      title: this._title,
+      custom_id: this._customId,
+      components: [...this._components]
+    };
+  }
+  toJSON() {
+    return this.build();
+  }
+};
+
+// src/builders/index.ts
+function buildUser(raw) {
+  return {
+    id: raw.id,
+    username: raw.username,
+    discriminator: raw.discriminator,
+    globalName: raw.global_name ?? null,
+    avatar: raw.avatar ?? null,
+    bot: raw.bot ?? false,
+    system: raw.system ?? false,
+    mfaEnabled: raw.mfa_enabled ?? false,
+    banner: raw.banner ?? null,
+    accentColor: raw.accent_color ?? null,
+    locale: raw.locale ?? void 0,
+    flags: raw.flags ?? 0,
+    premiumType: raw.premium_type ?? 0,
+    publicFlags: raw.public_flags ?? 0
+  };
+}
+function buildChannel(raw, guildId) {
+  return {
+    id: raw.id,
+    type: raw.type,
+    guildId: raw.guild_id ?? guildId ?? void 0,
+    name: raw.name ?? null,
+    position: raw.position ?? 0,
+    parentId: raw.parent_id ?? null,
+    topic: raw.topic ?? null,
+    nsfw: raw.nsfw ?? false,
+    lastMessageId: raw.last_message_id ?? null,
+    bitrate: raw.bitrate ?? void 0,
+    userLimit: raw.user_limit ?? void 0,
+    rateLimitPerUser: raw.rate_limit_per_user ?? 0,
+    permissionOverwrites: raw.permission_overwrites ?? []
+  };
+}
+function buildGuild(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    icon: raw.icon ?? null,
+    splash: raw.splash ?? null,
+    discoverySplash: raw.discovery_splash ?? null,
+    ownerId: raw.owner_id,
+    afkChannelId: raw.afk_channel_id ?? null,
+    afkTimeout: raw.afk_timeout ?? 0,
+    verificationLevel: raw.verification_level ?? 0,
+    defaultMessageNotifications: raw.default_message_notifications ?? 0,
+    explicitContentFilter: raw.explicit_content_filter ?? 0,
+    features: raw.features ?? [],
+    mfaLevel: raw.mfa_level ?? 0,
+    systemChannelId: raw.system_channel_id ?? null,
+    systemChannelFlags: raw.system_channel_flags ?? 0,
+    rulesChannelId: raw.rules_channel_id ?? null,
+    memberCount: raw.member_count ?? 0,
+    vanityUrlCode: raw.vanity_url_code ?? null,
+    description: raw.description ?? null,
+    banner: raw.banner ?? null,
+    premiumTier: raw.premium_tier ?? 0,
+    premiumSubscriptionCount: raw.premium_subscription_count ?? 0,
+    preferredLocale: raw.preferred_locale ?? "en-US",
+    publicUpdatesChannelId: raw.public_updates_channel_id ?? null,
+    nsfwLevel: raw.nsfw_level ?? 0,
+    premiumProgressBarEnabled: raw.premium_progress_bar_enabled ?? false,
+    roles: Array.isArray(raw.roles) ? raw.roles.map((r) => buildRole(r)) : [],
+    emojis: raw.emojis ?? [],
+    applicationId: raw.application_id ?? null,
+    large: raw.large ?? false
+  };
+}
+function buildRole(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    color: raw.color ?? 0,
+    hoist: raw.hoist ?? false,
+    position: raw.position ?? 0,
+    permissions: raw.permissions,
+    managed: raw.managed ?? false,
+    mentionable: raw.mentionable ?? false,
+    icon: raw.icon ?? null,
+    unicodeEmoji: raw.unicode_emoji ?? null,
+    flags: raw.flags ?? 0
+  };
+}
+function buildMember(raw, guildId, cache) {
+  let userObj;
+  if (raw.user) {
+    const user = buildUser(raw.user);
+    cache.users.set(user.id, user);
+    userObj = user;
+  }
+  return {
+    ...userObj ? { user: userObj } : {},
+    nick: raw.nick ?? null,
+    avatar: raw.avatar ?? null,
+    roles: raw.roles ?? [],
+    joinedAt: raw.joined_at ? Date.parse(raw.joined_at) : 0,
+    premiumSince: raw.premium_since ? Date.parse(raw.premium_since) : null,
+    deaf: raw.deaf ?? false,
+    mute: raw.mute ?? false,
+    pending: raw.pending ?? false,
+    flags: raw.flags ?? 0,
+    communicationDisabledUntil: raw.communication_disabled_until ? Date.parse(raw.communication_disabled_until) : null
+  };
+}
+function buildMessage(raw, cache, oldMessage) {
+  const authorRaw = raw.author;
+  const author = authorRaw ? buildUser(authorRaw) : oldMessage?.author ?? {};
+  if (authorRaw && author.id) {
+    cache.users.set(author.id, author);
+  }
+  const msgId = raw.id ?? oldMessage?.id;
+  const channelId = raw.channel_id ?? oldMessage?.channelId;
+  const guildId = raw.guild_id ? raw.guild_id : oldMessage?.guildId;
+  const msg = {
+    id: msgId,
+    channelId,
+    author,
+    ...guildId ? { guildId } : {},
+    url: `https://discord.com/channels/${guildId ?? "@me"}/${channelId}/${msgId}`,
+    content: raw.content ?? oldMessage?.content ?? "",
+    timestamp: raw.timestamp ? Date.parse(raw.timestamp) : oldMessage?.timestamp ?? Date.now(),
+    editedTimestamp: raw.edited_timestamp ? Date.parse(raw.edited_timestamp) : oldMessage?.editedTimestamp ?? null,
+    tts: raw.tts ?? oldMessage?.tts ?? false,
+    mentionEveryone: raw.mention_everyone ?? oldMessage?.mentionEveryone ?? false,
+    mentions: raw.mentions ? raw.mentions.map((m) => buildUser(m)) : oldMessage?.mentions ?? [],
+    mentionRoles: raw.mention_roles ?? oldMessage?.mentionRoles ?? [],
+    attachments: raw.attachments ?? oldMessage?.attachments ?? [],
+    embeds: raw.embeds ?? oldMessage?.embeds ?? [],
+    pinned: raw.pinned ?? oldMessage?.pinned ?? false,
+    type: raw.type ?? oldMessage?.type ?? 0
+  };
+  return msg;
+}
+function resolveChannel(channelId, cache) {
+  return cache.channels.get(channelId) ?? { id: channelId };
+}
+function resolveGuild(guildId, cache) {
+  return cache.guilds.get(guildId) ?? { id: guildId };
+}
+function resolveUser(userId, cache) {
+  return cache.users.get(userId) ?? { id: userId };
+}
+function resolveRole(roleId, cache) {
+  return cache.roles.get(roleId) ?? { id: roleId };
+}
+
+// src/commands/options.ts
+var opt = {
+  string: (description, options) => ({
+    type: "string",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  integer: (description, options) => ({
+    type: "integer",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  number: (description, options) => ({
+    type: "number",
+    description,
+    required: options?.required ?? false,
+    ...options
+  }),
+  boolean: (description, options) => ({
+    type: "boolean",
+    description,
+    required: options?.required ?? false
+  }),
+  user: (description, options) => ({
+    type: "user",
+    description,
+    required: options?.required ?? false
+  }),
+  channel: (description, options) => ({
+    type: "channel",
+    description,
+    required: options?.required ?? false
+  }),
+  role: (description, options) => ({
+    type: "role",
+    description,
+    required: options?.required ?? false
+  })
+};
+
+// src/commands/context.ts
+var CommandContext = class {
+  options;
+  user;
+  guild;
+  channel;
+  interactionId;
+  interactionToken;
+  _client;
+  _deferred = false;
+  _replied = false;
+  constructor(client, rawInteraction, parsedOptions, user, guild, channel) {
+    this._client = client;
+    this.interactionId = rawInteraction.id;
+    this.interactionToken = rawInteraction.token;
+    this.options = parsedOptions;
+    this.user = user;
+    this.guild = guild;
+    this.channel = channel;
+  }
+  get replied() {
+    return this._replied;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  async reply(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
+      data
+    });
+    this._replied = true;
+  }
+  async defer(options) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
+      data: {
+        flags: options?.ephemeral ? 64 : 0
+      }
+    });
+    this._deferred = true;
+  }
+  async followUp(payload) {
+    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged. Use reply or defer first.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  }
+  async showModal(modal) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const payload = modal.type === "modal" ? {
+      custom_id: modal.customId,
+      title: modal.title,
+      components: modal.fields.map((f) => ({
+        type: 1 /* ACTION_ROW */,
+        components: [{
+          type: 4 /* TEXT_INPUT */,
+          custom_id: f.id,
+          style: f.type,
+          // 1 short, 2 paragraph
+          label: f.label,
+          required: f.required,
+          min_length: f.minLength,
+          max_length: f.maxLength,
+          placeholder: f.placeholder,
+          value: f.value
+        }]
+      }))
+    } : modal;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 9 /* MODAL */,
+      data: payload
+    });
+    this._replied = true;
+  }
+};
+
+// src/commands/command.ts
+function defineSubcommand(def) {
+  return def;
+}
+function defineCommand(def) {
+  if (!def.execute && (!def.subcommands || Object.keys(def.subcommands).length === 0)) {
+    throw new Error(`Command ${def.name} must have an execute function or subcommands.`);
+  }
+  return def;
+}
+
+// src/commands/interactions.ts
+var ComponentContext = class {
+  customId;
+  user;
+  guild;
+  channel;
+  message;
+  interactionId;
+  interactionToken;
+  _client;
+  _deferred = false;
+  _replied = false;
+  constructor(client, raw, user, guild, channel) {
+    this._client = client;
+    this.interactionId = raw.id;
+    this.interactionToken = raw.token;
+    this.customId = raw.data?.custom_id ?? "";
+    this.message = raw.message;
+    this.user = user;
+    this.guild = guild;
+    this.channel = channel;
+  }
+  get replied() {
+    return this._replied;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  /** Values from a select menu interaction */
+  get values() {
+    return this._values ?? [];
+  }
+  async reply(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
+      data
+    });
+    this._replied = true;
+  }
+  async deferUpdate() {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 6 /* DEFERRED_UPDATE_MESSAGE */
+    });
+    this._deferred = true;
+  }
+  async update(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 7 /* UPDATE_MESSAGE */,
+      data
+    });
+    this._replied = true;
+  }
+  async followUp(payload) {
+    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  }
+};
+var ModalContext = class {
+  customId;
+  user;
+  guild;
+  channel;
+  interactionId;
+  interactionToken;
+  _fields = /* @__PURE__ */ new Map();
+  _client;
+  _replied = false;
+  _deferred = false;
+  constructor(client, raw, user, guild, channel) {
+    this._client = client;
+    this.interactionId = raw.id;
+    this.interactionToken = raw.token;
+    this.customId = raw.data?.custom_id ?? "";
+    this.user = user;
+    this.guild = guild;
+    this.channel = channel;
+    const rows = raw.data?.components ?? [];
+    for (const row of rows) {
+      for (const comp of row.components ?? []) {
+        if (comp.custom_id && comp.value !== void 0) {
+          this._fields.set(comp.custom_id, comp.value);
+        }
+      }
+    }
+  }
+  get replied() {
+    return this._replied;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  /** Get a text input value by its customId */
+  getField(customId) {
+    return this._fields.get(customId);
+  }
+  /** Get all field values as a plain object */
+  get fields() {
+    return Object.fromEntries(this._fields);
+  }
+  async reply(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
+      data
+    });
+    this._replied = true;
+  }
+  async defer(options) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
+      data: { flags: options?.ephemeral ? 64 : 0 }
+    });
+    this._deferred = true;
+  }
+  async followUp(payload) {
+    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  }
+};
+
+// src/commands/manager.ts
+import * as fs from "fs";
+import * as path from "path";
+var CommandManager = class {
+  _commands = /* @__PURE__ */ new Map();
+  _components = [];
+  _modals = [];
+  _client;
+  constructor(client) {
+    this._client = client;
+  }
+  register(...commands) {
+    for (const cmd of commands) {
+      this._commands.set(cmd.name, cmd);
+    }
+    this._deployCommands(commands).catch(console.error);
+  }
+  registerComponent(handler) {
+    this._components.push(handler);
+  }
+  registerModal(handler) {
+    this._modals.push(handler);
+  }
+  async load(directory) {
+    const fullPath = path.resolve(process.cwd(), directory);
+    if (!fs.existsSync(fullPath)) {
+      console.error(`[Chameleon] Command directory ${directory} does not exist.`);
+      return;
+    }
+    const files = fs.readdirSync(fullPath).filter((f) => f.endsWith(".js") || f.endsWith(".ts"));
+    const commands = [];
+    for (const file of files) {
+      const filePath = path.join(fullPath, file);
+      try {
+        const module = await import(`file://${filePath}`);
+        const command = module.default;
+        if (command && typeof command.name === "string") {
+          commands.push(command);
+        }
+      } catch (err) {
+        console.error(`[Chameleon] Failed to load command from ${file}:`, err);
+      }
+    }
+    if (commands.length > 0) {
+      this.register(...commands);
+    }
+  }
+  async _deployCommands(commands) {
+    const payload = commands.map((c) => this._transformCommand(c));
+    if (this._client.user?.id) {
+      await this._client.rest.put(`/applications/${this._client.user.id}/commands`, payload);
+    } else {
+      this._client.on("READY", async () => {
+        await this._client.rest.put(`/applications/${this._client.user.id}/commands`, payload);
+      });
+    }
+  }
+  _transformCommand(cmd) {
+    const mapType = (t) => {
+      switch (t) {
+        case "string":
+          return 3;
+        case "integer":
+          return 4;
+        case "boolean":
+          return 5;
+        case "user":
+          return 6;
+        case "channel":
+          return 7;
+        case "role":
+          return 8;
+        case "number":
+          return 10;
+        default:
+          return 3;
+      }
+    };
+    const options = [];
+    if (cmd.subcommands) {
+      for (const [subName, subDefRaw] of Object.entries(cmd.subcommands)) {
+        const subDef = subDefRaw;
+        const subOpts = [];
+        if (subDef.options) {
+          for (const [optName, optDef] of Object.entries(subDef.options)) {
+            subOpts.push({
+              type: mapType(optDef.type),
+              name: optName,
+              description: optDef.description,
+              required: optDef.required,
+              choices: optDef.choices,
+              min_value: optDef.min,
+              max_value: optDef.max
+            });
+          }
+        }
+        options.push({
+          type: 1 /* SUB_COMMAND */,
+          name: subName,
+          description: subDef.description,
+          options: subOpts
+        });
+      }
+    } else if (cmd.options) {
+      for (const [optName, optDef] of Object.entries(cmd.options)) {
+        options.push({
+          type: mapType(optDef.type),
+          name: optName,
+          description: optDef.description,
+          required: optDef.required,
+          choices: optDef.choices,
+          min_value: optDef.min,
+          max_value: optDef.max
+        });
+      }
+    }
+    return {
+      name: cmd.name,
+      description: cmd.description,
+      options: options.length ? options : void 0
+    };
+  }
+  async handleInteraction(raw) {
+    if (raw.type === 3 /* MESSAGE_COMPONENT */) return this._handleComponentInteraction(raw);
+    if (raw.type === 5 /* MODAL_SUBMIT */) return this._handleModalInteraction(raw);
+    if (raw.type !== 2 /* APPLICATION_COMMAND */) return;
+    const name = raw.data.name;
+    const command = this._commands.get(name);
+    if (!command) return;
+    const parsedOptions = {};
+    let targetExecute = command.execute;
+    const rawOptions = raw.data.options || [];
+    let actualOptions = rawOptions;
+    if (rawOptions.length > 0 && rawOptions[0].type === 1 /* SUB_COMMAND */) {
+      const subcommandName = rawOptions[0].name;
+      actualOptions = rawOptions[0].options || [];
+      if (command.subcommands && command.subcommands[subcommandName]) {
+        targetExecute = command.subcommands[subcommandName].execute;
+      }
+    }
+    for (const opt2 of actualOptions) {
+      if (opt2.type === 6 /* USER */ && raw.data.resolved?.users?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveUser(opt2.value, this._client.cache);
+      } else if (opt2.type === 7 /* CHANNEL */ && raw.data.resolved?.channels?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveChannel(opt2.value, this._client.cache);
+      } else if (opt2.type === 8 /* ROLE */ && raw.data.resolved?.roles?.[opt2.value]) {
+        parsedOptions[opt2.name] = resolveRole(opt2.value, this._client.cache);
+      } else {
+        parsedOptions[opt2.name] = opt2.value;
+      }
+    }
+    const member = raw.member || {};
+    const userRaw = member.user || raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new CommandContext(
+      this._client,
+      raw,
+      parsedOptions,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
+    );
+    if (targetExecute) {
+      try {
+        await targetExecute(ctx);
+      } catch (err) {
+        console.error(`[Chameleon] Error executing command ${name}:`, err);
+      }
+    }
+  }
+  async _handleComponentInteraction(raw) {
+    const customId = raw.data.custom_id;
+    const handler = this._components.find(
+      (h) => typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId)
+    );
+    if (!handler) return;
+    const userRaw = raw.member?.user || raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new ComponentContext(
+      this._client,
+      raw,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
+    );
+    if (raw.data.component_type === 3 /* STRING_SELECT */ || raw.data.component_type === 5 /* USER_SELECT */ || raw.data.component_type === 6 /* ROLE_SELECT */ || raw.data.component_type === 7 /* MENTIONABLE_SELECT */ || raw.data.component_type === 8 /* CHANNEL_SELECT */) {
+      ctx._values = raw.data.values || [];
+    }
+    try {
+      await handler.execute(ctx);
+    } catch (err) {
+      console.error(`[Chameleon] Error executing component ${customId}:`, err);
+    }
+  }
+  async _handleModalInteraction(raw) {
+    const customId = raw.data.custom_id;
+    const handler = this._modals.find(
+      (h) => typeof h.customId === "string" ? h.customId === customId : h.customId.test(customId)
+    );
+    if (!handler) return;
+    const userRaw = raw.member?.user || raw.user;
+    const user = buildUser(userRaw);
+    const ctx = new ModalContext(
+      this._client,
+      raw,
+      user,
+      raw.guild_id ? resolveGuild(raw.guild_id, this._client.cache) : void 0,
+      raw.channel_id ? resolveChannel(raw.channel_id, this._client.cache) : void 0
+    );
+    try {
+      await handler.execute(ctx);
+    } catch (err) {
+      console.error(`[Chameleon] Error executing modal ${customId}:`, err);
+    }
+  }
+};
+
+// src/components/context.ts
+var ComponentContext2 = class {
+  user;
+  guild;
+  channel;
+  interactionId;
+  interactionToken;
+  customId;
+  values;
+  fields;
+  _client;
+  _deferred = false;
+  _replied = false;
+  constructor(client, rawInteraction, user, guild, channel) {
+    this._client = client;
+    this.interactionId = rawInteraction.id;
+    this.interactionToken = rawInteraction.token;
+    this.customId = rawInteraction.data?.custom_id;
+    this.user = user;
+    this.guild = guild;
+    this.channel = channel;
+    this.values = rawInteraction.data?.values ?? [];
+    const fields = {};
+    if (rawInteraction.data?.components) {
+      for (const row of rawInteraction.data.components) {
+        for (const comp of row.components) {
+          fields[comp.custom_id] = comp.value;
+        }
+      }
+    }
+    this.fields = fields;
+  }
+  get replied() {
+    return this._replied;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  async reply(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
+      data
+    });
+    this._replied = true;
+  }
+  async defer(options) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
+      data: {
+        flags: options?.ephemeral ? 64 : 0
+      }
+    });
+    this._deferred = true;
+  }
+  async update(payload) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 7 /* UPDATE_MESSAGE */,
+      data
+    });
+    this._replied = true;
+  }
+  async deferUpdate() {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 6 /* DEFERRED_UPDATE_MESSAGE */
+    });
+    this._deferred = true;
+  }
+  async followUp(payload) {
+    if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged. Use reply or defer first.");
+    const data = typeof payload === "string" ? { content: payload } : { ...payload };
+    if (typeof payload === "object" && payload.ephemeral) data.flags = 64;
+    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+  }
+  async showModal(modal) {
+    if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
+    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+      type: 9 /* MODAL */,
+      data: modal.type === "modal" ? buildModalPayload(modal) : modal
+    });
+    this._replied = true;
+  }
+};
+function buildModalPayload(def) {
+  return {
+    custom_id: def.customId,
+    title: def.title,
+    components: def.fields.map((f) => ({
+      type: 1 /* ACTION_ROW */,
+      components: [{
+        type: 4 /* TEXT_INPUT */,
+        custom_id: f.id,
+        style: f.type,
+        // 1 short, 2 paragraph
+        label: f.label,
+        required: f.required,
+        min_length: f.minLength,
+        max_length: f.maxLength,
+        placeholder: f.placeholder,
+        value: f.value
+      }]
+    }))
+  };
+}
+
+// src/components/define.ts
+function resolveButtonStyle(style) {
+  if (typeof style === "number") return style;
+  const map = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5, premium: 6 };
+  return map[style] ?? 1;
+}
+function defineButton(def) {
+  return { ...def, type: "button" };
+}
+function defineStringSelect(def) {
+  return { ...def, type: "string_select" };
+}
+function defineUserSelect(def) {
+  return { ...def, type: "user_select" };
+}
+function defineRoleSelect(def) {
+  return { ...def, type: "role_select" };
+}
+function defineChannelSelect(def) {
+  return { ...def, type: "channel_select" };
+}
+function defineMentionableSelect(def) {
+  return { ...def, type: "mentionable_select" };
+}
+var field = {
+  short: (id, label, options) => ({
+    id,
+    type: 1 /* SHORT */,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  paragraph: (id, label, options) => ({
+    id,
+    type: 2 /* PARAGRAPH */,
+    label,
+    required: options?.required ?? true,
+    ...options
+  })
+};
+function defineModal(def) {
+  return { ...def, type: "modal" };
+}
+
+// src/components/actionRow.ts
+var ActionRow = {
+  of: (...components) => {
+    return {
+      type: 1 /* ACTION_ROW */,
+      components: components.map((c) => {
+        if (c.type === "button") {
+          return {
+            type: 2 /* BUTTON */,
+            custom_id: c.customId,
+            url: c.url,
+            label: c.label,
+            style: resolveButtonStyle(c.style),
+            disabled: c.disabled,
+            emoji: c.emoji,
+            sku_id: c.skuId
+          };
+        }
+        if (c.type === "string_select") {
+          return {
+            type: 3 /* STRING_SELECT */,
+            custom_id: c.customId,
+            options: c.options,
+            placeholder: c.placeholder,
+            min_values: c.minValues,
+            max_values: c.maxValues,
+            disabled: c.disabled
+          };
+        }
+        if (c.type === "user_select") {
+          return { type: 5 /* USER_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
+        }
+        if (c.type === "role_select") {
+          return { type: 6 /* ROLE_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
+        }
+        if (c.type === "mentionable_select") {
+          return { type: 7 /* MENTIONABLE_SELECT */, custom_id: c.customId, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
+        }
+        if (c.type === "channel_select") {
+          return { type: 8 /* CHANNEL_SELECT */, custom_id: c.customId, channel_types: c.channelTypes, placeholder: c.placeholder, min_values: c.minValues, max_values: c.maxValues, disabled: c.disabled };
+        }
+        if (c.type === 1 /* SHORT */ || c.type === 2 /* PARAGRAPH */) {
+          return {
+            type: 4 /* TEXT_INPUT */,
+            custom_id: c.id,
+            style: c.type,
+            label: c.label,
+            required: c.required,
+            min_length: c.minLength,
+            max_length: c.maxLength,
+            placeholder: c.placeholder,
+            value: c.value
+          };
+        }
+        return c;
+      }).map((obj) => {
+        const clean = {};
+        for (const [k, v] of Object.entries(obj)) {
+          if (v !== void 0) clean[k] = v;
+        }
+        return clean;
+      })
+    };
+  }
+};
+
+// src/components/manager.ts
+var ComponentManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  handlers = /* @__PURE__ */ new Map();
+  register(...components) {
+    for (const comp of components) {
+      if (comp.customId) {
+        this.handlers.set(comp.customId, comp);
+      }
+    }
+  }
+  async handleInteraction(raw) {
+    const data = raw.data;
+    const customId = data.custom_id;
+    if (!customId) return;
+    const handler = this.handlers.get(customId);
+    if (!handler || !handler.execute) return;
+    const user = buildUser(raw.user ?? raw.member?.user);
+    let guild;
+    if (raw.guild_id) {
+      guild = this.client.cache.guilds.get(raw.guild_id) ?? { id: raw.guild_id };
+    }
+    let channel;
+    if (raw.channel_id) {
+      channel = resolveChannel(raw.channel_id, this.client.cache) ?? { id: raw.channel_id };
+    }
+    if (data.resolved?.members && data.resolved?.users && raw.guild_id) {
+      for (const [id, memberData] of Object.entries(data.resolved.members)) {
+        const userData = data.resolved.users[id];
+        if (userData) {
+          const mergedMember = { ...memberData, user: userData };
+          const u = buildUser(userData);
+          this.client.cache.users.set(u.id, u);
+        }
+      }
+    }
+    const ctx = new ComponentContext2(this.client, raw, user, guild, channel);
+    if (handler.type === "user_select" && data.resolved?.users) {
+      ctx.values = ctx.values.map((id) => {
+        const uData = data.resolved.users[id];
+        return uData ? buildUser(uData) : { id };
+      });
+    } else if (handler.type === "channel_select" && data.resolved?.channels) {
+      ctx.values = ctx.values.map((id) => {
+        const cData = data.resolved.channels[id];
+        return cData ? buildChannel(cData, raw.guild_id) : { id };
+      });
+    }
+    try {
+      await handler.execute(ctx);
+    } catch (err) {
+      console.error(`[COMPONENTS] Error executing component ${customId}:`, err);
+    }
+  }
+};
+
+// src/managers/base.ts
+var BaseManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  rest;
+  store;
+  async fetch(id, force = false) {
+    if (!force) {
+      const tongue2 = this.store[this.storeKey];
+      const cached = tongue2.get(id);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(this.endpoint(id));
+    if (!result.ok) return result;
+    const entity = this.build(result.data);
+    const tongue = this.store[this.storeKey];
+    tongue.set(id, entity);
+    return { ok: true, data: entity };
+  }
+};
+
+// src/managers/user.ts
+var UserManager = class extends BaseManager {
+  storeKey = "users";
+  endpoint(id) {
+    return `/users/${id}`;
+  }
+  build = buildUser;
+};
+
+// src/managers/guild.ts
+var GuildManager = class extends BaseManager {
+  storeKey = "guilds";
+  endpoint(id) {
+    return `/guilds/${id}`;
+  }
+  build = buildGuild;
+  async fetchChannels(guildId) {
+    const result = await this.rest.get(`/guilds/${guildId}/channels`);
+    if (!result.ok) return result;
+    const channels = result.data.map((raw) => buildChannel(raw, guildId));
+    for (const c of channels) {
+      this.store.channels.set(c.id, c);
+    }
+    return { ok: true, data: channels };
+  }
+  async ban(guildId, userId, options) {
+    const payload = {};
+    if (options?.deleteMessageSeconds !== void 0) payload.delete_message_seconds = options.deleteMessageSeconds;
+    const headers = {};
+    if (options?.reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+    const result = await this.rest.put(`/guilds/${guildId}/bans/${userId}`, payload, headers);
+    return result;
+  }
+  async unban(guildId, userId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/bans/${userId}`, headers);
+    return result;
+  }
+  async kick(guildId, userId, reason) {
+    const headers = {};
+    if (reason) headers["X-Audit-Log-Reason"] = encodeURIComponent(reason);
+    const result = await this.rest.delete(`/guilds/${guildId}/members/${userId}`, headers);
+    if (result.ok) {
+      this.store.members.delete(TongueStore.memberKey(guildId, userId));
+    }
+    return result;
+  }
+};
+
+// src/managers/channel.ts
+var ChannelManager = class extends BaseManager {
+  storeKey = "channels";
+  endpoint(id) {
+    return `/channels/${id}`;
+  }
+  build = buildChannel;
+};
+
+// src/managers/member.ts
+var MemberManager = class {
+  constructor(rest, store, guildId) {
+    this.rest = rest;
+    this.store = store;
+    this.guildId = guildId;
+  }
+  rest;
+  store;
+  guildId;
+  async fetch(userId, force = false) {
+    const cacheKey = TongueStore.memberKey(this.guildId, userId);
+    if (!force) {
+      const cached = this.store.members.get(cacheKey);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(`/guilds/${this.guildId}/members/${userId}`);
+    if (!result.ok) return result;
+    const member = buildMember(result.data, this.guildId, this.store);
+    this.store.members.set(cacheKey, member);
+    return { ok: true, data: member };
+  }
+};
+
+// src/managers/message.ts
+var MessageManager = class {
+  constructor(rest, store) {
+    this.rest = rest;
+    this.store = store;
+  }
+  rest;
+  store;
+  async fetch(channelId, messageId, force = false) {
+    if (!force) {
+      const cached = this.store.messages.get(messageId);
+      if (cached) return { ok: true, data: cached };
+    }
+    const result = await this.rest.get(`/channels/${channelId}/messages/${messageId}`);
+    if (!result.ok) return result;
+    const message = buildMessage(result.data, this.store);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async send(channelId, payload) {
+    const data = typeof payload === "string" ? { content: payload } : payload;
+    const result = await this.rest.post(`/channels/${channelId}/messages`, data);
+    if (!result.ok) return result;
+    const message = buildMessage(result.data, this.store);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async edit(channelId, messageId, payload) {
+    const data = typeof payload === "string" ? { content: payload } : payload;
+    const result = await this.rest.patch(`/channels/${channelId}/messages/${messageId}`, data);
+    if (!result.ok) return result;
+    const oldMsg = this.store.messages.get(messageId);
+    const message = buildMessage(result.data, this.store, oldMsg);
+    this.store.messages.set(message.id, message);
+    return { ok: true, data: message };
+  }
+  async delete(channelId, messageId) {
+    const result = await this.rest.delete(`/channels/${channelId}/messages/${messageId}`);
+    if (result.ok) {
+      this.store.messages.delete(messageId);
+    }
+    return result;
+  }
+};
+
+// src/managers/collector.ts
+var CollectorManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Waits for a specified number of messages in a given channel that pass the filter, if the time limit
+   * is reached, resolves with the messages collected so far
+   */
+  async awaitMessages(channelId, options = {}) {
+    const { filter, max = 1, time = 15e3 } = options;
+    return new Promise((resolve2) => {
+      const messages = [];
+      let timeoutId = null;
+      const handler = (data) => {
+        const msg = data.message;
+        if (msg.channelId !== channelId) return;
+        if (filter && !filter(msg)) return;
+        messages.push(msg);
+        if (messages.length >= max) {
+          cleanup();
+          resolve2(messages);
+        }
+      };
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        this.client.off("MESSAGE_CREATE", handler);
+      };
+      this.client.on("MESSAGE_CREATE", handler);
+      if (time > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          resolve2(messages);
+        }, time);
+      }
+    });
+  }
+  /**
+   * waits for a single component interaction on a specific message,
+   * resolves with the ComponentContext if successful, or null if it timed out
+   */
+  async awaitComponent(messageId, options = {}) {
+    const { filter, time = 15e3 } = options;
+    return new Promise((resolve2) => {
+      let timeoutId = null;
+      const handler = (data) => {
+        const raw = data.interaction;
+        if (raw.type !== 3 /* MESSAGE_COMPONENT */) return;
+        if (raw.message?.id !== messageId) return;
+        const userRaw = raw.member?.user || raw.user;
+        const user = buildUser(userRaw);
+        const ctx = new ComponentContext(
+          this.client,
+          raw,
+          user,
+          raw.guild_id ? resolveGuild(raw.guild_id, this.client.cache) : void 0,
+          raw.channel_id ? resolveChannel(raw.channel_id, this.client.cache) : void 0
+        );
+        if (raw.data.component_type === 3 /* STRING_SELECT */ || raw.data.component_type === 5 /* USER_SELECT */ || raw.data.component_type === 6 /* ROLE_SELECT */ || raw.data.component_type === 7 /* MENTIONABLE_SELECT */ || raw.data.component_type === 8 /* CHANNEL_SELECT */) {
+          ctx._values = raw.data.values || [];
+        }
+        if (filter && !filter(ctx)) return;
+        cleanup();
+        resolve2(ctx);
+      };
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        this.client.off("INTERACTION_CREATE", handler);
+      };
+      this.client.on("INTERACTION_CREATE", handler);
+      if (time > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          resolve2(null);
+        }, time);
+      }
+    });
+  }
+};
+
+// src/client/client.ts
+var Client = class {
+  token;
+  intents;
+  cache;
+  rest;
+  gateways = /* @__PURE__ */ new Map();
+  totalShards = 1;
+  gateway;
+  user = null;
+  unavailableGuilds = /* @__PURE__ */ new Set();
+  outageGuilds = /* @__PURE__ */ new Set();
+  pendingChunks = /* @__PURE__ */ new Map();
+  debug;
+  commands;
+  components;
+  users;
+  guilds;
+  channels;
+  messages;
+  collectors;
+  listeners = /* @__PURE__ */ new Map();
+  middlewares = [];
+  constructor(options) {
+    this.token = options.token;
+    this.intents = this.resolveIntents(options.intents);
+    this.debug = options.debug ?? false;
+    this.cache = new TongueStore(options.cache);
+    this.rest = new ChameleonREST({ token: this.token });
+    this.commands = new CommandManager(this);
+    this.components = new ComponentManager(this);
+    this.users = new UserManager(this.rest, this.cache);
+    this.guilds = new GuildManager(this.rest, this.cache);
+    this.channels = new ChannelManager(this.rest, this.cache);
+    this.messages = new MessageManager(this.rest, this.cache);
+    this.collectors = new CollectorManager(this);
+    let shards = [0];
+    let totalShards = 1;
+    if (options.sharding === "auto") {
+      if (process.env.SHARD_LIST && process.env.TOTAL_SHARDS) {
+        shards = process.env.SHARD_LIST.split(",").map(Number);
+        totalShards = Number(process.env.TOTAL_SHARDS);
+      } else if (process.env.SHARD_ID !== void 0 && process.env.SHARD_COUNT !== void 0) {
+        shards = [Number(process.env.SHARD_ID)];
+        totalShards = Number(process.env.SHARD_COUNT);
+      }
+    } else if (typeof options.sharding === "object") {
+      shards = options.sharding.shards;
+      totalShards = options.sharding.total;
+    }
+    this.totalShards = totalShards;
+    for (const shardId of shards) {
+      const gatewayOptions = {
+        token: this.token,
+        intents: this.intents,
+        ...options.sharding ? { shard: [shardId, totalShards] } : {}
+      };
+      if (options.largeThreshold !== void 0) {
+        gatewayOptions.largeThreshold = options.largeThreshold;
+      }
+      const gw = new ChameleonGateway(gatewayOptions);
+      this.gateways.set(shardId, gw);
+    }
+    this.gateway = this.gateways.get(shards[0]);
+    this.setupGateway();
+  }
+  resolveIntents(intents) {
+    if (!Array.isArray(intents)) {
+      intents = [intents];
+    }
+    let resolved = 0;
+    for (const intent of intents) {
+      if (typeof intent === "number") {
+        resolved |= intent;
+      } else if (typeof intent === "string") {
+        const bit = IntentBits[intent];
+        if (bit !== void 0) {
+          resolved |= bit;
+        }
+      } else if (Array.isArray(intent)) {
+        resolved |= this.resolveIntents(intent);
+      }
+    }
+    return resolved;
+  }
+  /**
+   * register an event listener with full type-safety via discriminated unions
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(listener);
+    return this;
+  }
+  /**
+   * remove an event listener
+   */
+  off(event, listener) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) return this;
+    const index = handlers.indexOf(listener);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+    return this;
+  }
+  /**
+   * register middleware that runs between dispatch and event handlers
+   */
+  use(fn) {
+    this.middlewares.push(fn);
+    return this;
+  }
+  getShardForGuild(guildId) {
+    return Number(BigInt(guildId) >> 22n) % this.totalShards;
+  }
+  /**
+   * request offline/large guild members from the Gateway.
+   * This is used to lazy-load members into the cache or search for specific members
+   */
+  requestGuildMembers(options) {
+    const guildId = Array.isArray(options.guildId) ? options.guildId[0] : options.guildId;
+    if (!guildId) return;
+    const shardId = this.getShardForGuild(guildId);
+    const gw = this.gateways.get(shardId) ?? this.gateway;
+    if (gw) {
+      gw.requestGuildMembers(options);
+    }
+  }
+  /**
+   * Connect to all Gateways
+   */
+  async login() {
+    for (const gw of this.gateways.values()) {
+      gw.connect();
+      await new Promise((r) => setTimeout(r, 5e3));
+    }
+  }
+  /**
+   * Gracefully disconnect from all Gateways
+   */
+  destroy() {
+    for (const gw of this.gateways.values()) {
+      gw.disconnect(1e3, "Client destroyed");
+    }
+  }
+  /**
+   * Update presence/status across all shards
+   */
+  presence(options) {
+    for (const gw of this.gateways.values()) {
+      gw.updatePresence(options);
+    }
+  }
+  /**
+   * dispatch an event through the middleware pipeline, then to listeners
+   */
+  dispatch(event, data) {
+    if (this.middlewares.length === 0) {
+      this.emit(event, data);
+      return;
+    }
+    let index = 0;
+    const next = () => {
+      index++;
+      if (index >= this.middlewares.length) {
+        this.emit(event, data);
+        return;
+      }
+      const mw = this.middlewares[index];
+      if (mw) mw(data, next);
+    };
+    const first = this.middlewares[0];
+    if (first) first(data, next);
+  }
+  /**
+   * emit to registered listeners
+   */
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      handler(data);
+    }
+  }
+  setupGateway() {
+    for (const gw of this.gateways.values()) {
+      gw.on("dispatch", (payload) => {
+        this.handleDispatch(payload);
+      });
+    }
+  }
+  handleDispatch(payload) {
+    const { t } = payload;
+    const d = payload.d;
+    if (!t || !d) return;
+    switch (t) {
+      case "READY": {
+        if (d.user) {
+          this.user = buildUser(d.user);
+          this.cache.users.set(this.user.id, this.user);
+        }
+        if (Array.isArray(d.guilds)) {
+          for (const raw of d.guilds) {
+            if (raw.unavailable && typeof raw.id === "string") {
+              this.unavailableGuilds.add(raw.id);
+            }
+          }
+        }
+        this.dispatch("READY", { type: "READY" });
+        break;
+      }
+      case "RESUMED": {
+        this.dispatch("RESUMED", { type: "RESUMED" });
+        break;
+      }
+      case "GUILD_CREATE": {
+        const guild = buildGuild(d);
+        let reason = null;
+        if (this.unavailableGuilds.has(guild.id)) {
+          this.unavailableGuilds.delete(guild.id);
+          reason = "hydration";
+        } else if (this.outageGuilds.has(guild.id)) {
+          this.outageGuilds.delete(guild.id);
+          reason = "outage";
+        }
+        this.cache.guilds.set(guild.id, guild);
+        if (Array.isArray(d.channels)) {
+          for (const raw of d.channels) {
+            const ch = buildChannel(raw, guild.id);
+            this.cache.channels.set(ch.id, ch);
+          }
+        }
+        if (Array.isArray(d.roles)) {
+          for (const raw of d.roles) {
+            const role = buildRole(raw);
+            this.cache.roles.set(role.id, role);
+          }
+        }
+        if (Array.isArray(d.members)) {
+          for (const raw of d.members) {
+            const member = buildMember(raw, guild.id, this.cache);
+            if (member.user?.id) {
+              this.cache.members.set(TongueStore.memberKey(guild.id, member.user.id), member);
+            }
+          }
+        }
+        if (Array.isArray(d.emojis)) {
+          for (const raw of d.emojis) {
+            this.cache.emojis.set(raw.id, raw);
+          }
+        }
+        if (Array.isArray(d.stickers)) {
+          for (const raw of d.stickers) {
+            this.cache.stickers.set(raw.id, raw);
+          }
+        }
+        if (Array.isArray(d.stage_instances)) {
+          for (const raw of d.stage_instances) {
+            this.cache.stageInstances.set(raw.id, raw);
+          }
+        }
+        if (Array.isArray(d.guild_scheduled_events)) {
+          for (const raw of d.guild_scheduled_events) {
+            this.cache.scheduledEvents.set(raw.id, raw);
+          }
+        }
+        if (guild.large) {
+          this.pendingChunks.set(guild.id, {
+            received: 0,
+            total: -1,
+            reason,
+            guild,
+            timeout: setTimeout(() => {
+              if (this.pendingChunks.has(guild.id)) {
+                this.pendingChunks.delete(guild.id);
+                if (reason) {
+                  this.dispatch("GUILD_AVAILABLE", { type: "GUILD_AVAILABLE", guild, reason, partial: true });
+                } else {
+                  this.dispatch("GUILD_CREATE", { type: "GUILD_CREATE", guild, partial: true });
+                }
+              }
+            }, 15e3)
+          });
+          const shardId = this.getShardForGuild(guild.id);
+          const gw = this.gateways.get(shardId) ?? this.gateway;
+          if (gw) {
+            gw.requestGuildMembers({
+              guildId: guild.id,
+              query: "",
+              limit: 0
+            });
+          }
+        } else {
+          if (reason) {
+            this.dispatch("GUILD_AVAILABLE", { type: "GUILD_AVAILABLE", guild, reason });
+          } else {
+            this.dispatch("GUILD_CREATE", { type: "GUILD_CREATE", guild });
+          }
+        }
+        break;
+      }
+      case "GUILD_UPDATE": {
+        const oldGuild = this.cache.guilds.get(d.id);
+        const guild = buildGuild(d);
+        this.cache.guilds.set(guild.id, guild);
+        this.dispatch("GUILD_UPDATE", { type: "GUILD_UPDATE", guild, ...oldGuild ? { oldGuild } : {} });
+        break;
+      }
+      case "GUILD_DELETE": {
+        const guildId = d.id;
+        const unavailable = d.unavailable;
+        if (unavailable) {
+          this.outageGuilds.add(guildId);
+          this.dispatch("GUILD_UNAVAILABLE", { type: "GUILD_UNAVAILABLE", guildId });
+        } else {
+          this.cache.guilds.delete(guildId);
+          this.dispatch("GUILD_DELETE", { type: "GUILD_DELETE", guildId });
+        }
+        break;
+      }
+      case "CHANNEL_CREATE": {
+        const channel = buildChannel(d);
+        this.cache.channels.set(channel.id, channel);
+        this.dispatch("CHANNEL_CREATE", { type: "CHANNEL_CREATE", channel, ...d.guild_id ? { guild: { id: d.guild_id } } : {} });
+        break;
+      }
+      case "CHANNEL_UPDATE": {
+        const oldChannel = this.cache.channels.get(d.id);
+        const channel = buildChannel(d);
+        this.cache.channels.set(channel.id, channel);
+        this.dispatch("CHANNEL_UPDATE", { type: "CHANNEL_UPDATE", channel, ...oldChannel ? { oldChannel } : {}, ...d.guild_id ? { guild: { id: d.guild_id } } : {} });
+        break;
+      }
+      case "CHANNEL_DELETE": {
+        const channelId = d.id;
+        this.cache.channels.delete(channelId);
+        this.dispatch("CHANNEL_DELETE", { type: "CHANNEL_DELETE", channelId, ...d.guild_id ? { guild: { id: d.guild_id } } : {} });
+        break;
+      }
+      case "CHANNEL_PINS_UPDATE": {
+        this.dispatch("CHANNEL_PINS_UPDATE", {
+          type: "CHANNEL_PINS_UPDATE",
+          channelId: d.channel_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          ...d.last_pin_timestamp !== void 0 ? { lastPinTimestamp: d.last_pin_timestamp ? Date.parse(d.last_pin_timestamp) : null } : {}
+        });
+        break;
+      }
+      case "THREAD_CREATE": {
+        const channel = buildChannel(d);
+        this.cache.channels.set(channel.id, channel);
+        this.dispatch("THREAD_CREATE", { type: "THREAD_CREATE", channel });
+        break;
+      }
+      case "THREAD_UPDATE": {
+        const oldChannel = this.cache.channels.get(d.id);
+        const channel = buildChannel(d);
+        this.cache.channels.set(channel.id, channel);
+        this.dispatch("THREAD_UPDATE", { type: "THREAD_UPDATE", channel, ...oldChannel ? { oldChannel } : {} });
+        break;
+      }
+      case "THREAD_DELETE": {
+        const id = d.id;
+        this.cache.channels.delete(id);
+        this.dispatch("THREAD_DELETE", {
+          type: "THREAD_DELETE",
+          id,
+          guildId: d.guild_id,
+          parentId: d.parent_id,
+          channelType: d.type
+        });
+        break;
+      }
+      case "GUILD_MEMBER_ADD": {
+        const guildId = d.guild_id;
+        const member = buildMember(d, guildId, this.cache);
+        if (member.user?.id) {
+          this.cache.members.set(TongueStore.memberKey(guildId, member.user.id), member);
+        }
+        this.dispatch("GUILD_MEMBER_ADD", { type: "GUILD_MEMBER_ADD", member, guildId });
+        break;
+      }
+      case "GUILD_MEMBER_UPDATE": {
+        const guildId = d.guild_id;
+        const rawUser = d.user;
+        const user = buildUser(rawUser);
+        this.cache.users.set(user.id, user);
+        const memberKey = TongueStore.memberKey(guildId, user.id);
+        const oldMember = this.cache.members.get(memberKey);
+        const updatedMember = buildMember(d, guildId, this.cache);
+        this.cache.members.set(memberKey, updatedMember);
+        this.dispatch("GUILD_MEMBER_UPDATE", {
+          type: "GUILD_MEMBER_UPDATE",
+          guildId,
+          user,
+          roles: d.roles,
+          ...oldMember ? { oldMember } : {},
+          ...d.nick !== void 0 ? { nick: d.nick ?? null } : {},
+          ...d.joined_at !== void 0 ? { joinedAt: d.joined_at ? Date.parse(d.joined_at) : null } : {}
+        });
+        break;
+      }
+      case "GUILD_MEMBER_REMOVE": {
+        const guildId = d.guild_id;
+        const rawUser = d.user;
+        const user = buildUser(rawUser);
+        this.cache.members.delete(TongueStore.memberKey(guildId, user.id));
+        this.dispatch("GUILD_MEMBER_REMOVE", { type: "GUILD_MEMBER_REMOVE", user, guildId });
+        break;
+      }
+      case "GUILD_ROLE_CREATE": {
+        const role = buildRole(d.role);
+        this.cache.roles.set(role.id, role);
+        this.dispatch("GUILD_ROLE_CREATE", { type: "GUILD_ROLE_CREATE", guildId: d.guild_id, role });
+        break;
+      }
+      case "GUILD_ROLE_UPDATE": {
+        const rolePayload = d.role;
+        const oldRole = this.cache.roles.get(rolePayload.id);
+        const role = buildRole(rolePayload);
+        this.cache.roles.set(role.id, role);
+        this.dispatch("GUILD_ROLE_UPDATE", { type: "GUILD_ROLE_UPDATE", guildId: d.guild_id, role, ...oldRole ? { oldRole } : {} });
+        break;
+      }
+      case "GUILD_ROLE_DELETE": {
+        const roleId = d.role_id;
+        this.cache.roles.delete(roleId);
+        this.dispatch("GUILD_ROLE_DELETE", { type: "GUILD_ROLE_DELETE", guildId: d.guild_id, roleId });
+        break;
+      }
+      case "GUILD_BAN_ADD": {
+        const user = buildUser(d.user);
+        this.cache.users.set(user.id, user);
+        this.dispatch("GUILD_BAN_ADD", { type: "GUILD_BAN_ADD", guildId: d.guild_id, user });
+        break;
+      }
+      case "GUILD_BAN_REMOVE": {
+        const user = buildUser(d.user);
+        this.cache.users.set(user.id, user);
+        this.dispatch("GUILD_BAN_REMOVE", { type: "GUILD_BAN_REMOVE", guildId: d.guild_id, user });
+        break;
+      }
+      case "MESSAGE_CREATE": {
+        const message = buildMessage(d, this.cache);
+        this.cache.messages.set(message.id, message);
+        this.dispatch("MESSAGE_CREATE", {
+          type: "MESSAGE_CREATE",
+          message,
+          channel: resolveChannel(message.channelId, this.cache)
+        });
+        break;
+      }
+      case "MESSAGE_UPDATE": {
+        const oldMessage = this.cache.messages.get(d.id);
+        const message = buildMessage(d, this.cache, oldMessage);
+        this.cache.messages.set(message.id, message);
+        this.dispatch("MESSAGE_UPDATE", {
+          type: "MESSAGE_UPDATE",
+          message,
+          channel: resolveChannel(message.channelId, this.cache),
+          ...oldMessage ? { oldMessage } : {}
+        });
+        break;
+      }
+      case "MESSAGE_DELETE": {
+        const messageId = d.id;
+        const message = this.cache.messages.get(messageId);
+        this.cache.messages.delete(messageId);
+        this.dispatch("MESSAGE_DELETE", {
+          type: "MESSAGE_DELETE",
+          messageId,
+          channelId: d.channel_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          ...message ? { message } : {}
+        });
+        break;
+      }
+      case "MESSAGE_DELETE_BULK": {
+        const ids = d.ids;
+        const messages = [];
+        for (const id of ids) {
+          const msg = this.cache.messages.get(id);
+          if (msg) messages.push(msg);
+          this.cache.messages.delete(id);
+        }
+        this.dispatch("MESSAGE_DELETE_BULK", {
+          type: "MESSAGE_DELETE_BULK",
+          messageIds: ids,
+          channelId: d.channel_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          ...messages.length > 0 ? { messages } : {}
+        });
+        break;
+      }
+      case "MESSAGE_REACTION_ADD": {
+        let reactionMember;
+        if (d.member && d.guild_id) {
+          reactionMember = buildMember(d.member, d.guild_id, this.cache);
+          if (reactionMember.user?.id) {
+            this.cache.users.set(reactionMember.user.id, reactionMember.user);
+            this.cache.members.set(TongueStore.memberKey(d.guild_id, reactionMember.user.id), reactionMember);
+          }
+        }
+        this.dispatch("MESSAGE_REACTION_ADD", {
+          type: "MESSAGE_REACTION_ADD",
+          userId: d.user_id,
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          emoji: d.emoji,
+          ...reactionMember ? { member: reactionMember } : {}
+        });
+        break;
+      }
+      case "MESSAGE_REACTION_REMOVE": {
+        this.dispatch("MESSAGE_REACTION_REMOVE", {
+          type: "MESSAGE_REACTION_REMOVE",
+          userId: d.user_id,
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          emoji: d.emoji
+        });
+        break;
+      }
+      case "MESSAGE_REACTION_REMOVE_ALL": {
+        this.dispatch("MESSAGE_REACTION_REMOVE_ALL", {
+          type: "MESSAGE_REACTION_REMOVE_ALL",
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {}
+        });
+        break;
+      }
+      case "MESSAGE_REACTION_REMOVE_EMOJI": {
+        this.dispatch("MESSAGE_REACTION_REMOVE_EMOJI", {
+          type: "MESSAGE_REACTION_REMOVE_EMOJI",
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          emoji: d.emoji
+        });
+        break;
+      }
+      case "INTERACTION_CREATE": {
+        if (d.type === 2 /* APPLICATION_COMMAND */ || d.type === 4 /* APPLICATION_COMMAND_AUTOCOMPLETE */) {
+          this.commands.handleInteraction(d).catch(console.error);
+        } else if (d.type === 3 /* MESSAGE_COMPONENT */ || d.type === 5 /* MODAL_SUBMIT */) {
+          this.components.handleInteraction(d).catch(console.error);
+        }
+        this.dispatch("INTERACTION_CREATE", {
+          type: "INTERACTION_CREATE",
+          interaction: d
+        });
+        break;
+      }
+      case "VOICE_STATE_UPDATE": {
+        this.dispatch("VOICE_STATE_UPDATE", {
+          type: "VOICE_STATE_UPDATE",
+          voiceState: d
+        });
+        break;
+      }
+      case "VOICE_SERVER_UPDATE": {
+        this.dispatch("VOICE_SERVER_UPDATE", {
+          type: "VOICE_SERVER_UPDATE",
+          token: d.token,
+          guildId: d.guild_id,
+          endpoint: d.endpoint
+        });
+        break;
+      }
+      case "INVITE_CREATE": {
+        let inviter;
+        if (d.inviter) {
+          inviter = buildUser(d.inviter);
+          this.cache.users.set(inviter.id, inviter);
+        }
+        this.dispatch("INVITE_CREATE", {
+          type: "INVITE_CREATE",
+          channelId: d.channel_id,
+          code: d.code,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          ...inviter ? { inviter } : {},
+          maxAge: d.max_age,
+          maxUses: d.max_uses,
+          temporary: d.temporary
+        });
+        break;
+      }
+      case "INVITE_DELETE": {
+        this.dispatch("INVITE_DELETE", {
+          type: "INVITE_DELETE",
+          channelId: d.channel_id,
+          code: d.code,
+          ...d.guild_id ? { guildId: d.guild_id } : {}
+        });
+        break;
+      }
+      case "GUILD_INTEGRATIONS_UPDATE": {
+        this.dispatch("GUILD_INTEGRATIONS_UPDATE", {
+          type: "GUILD_INTEGRATIONS_UPDATE",
+          guildId: d.guild_id
+        });
+        break;
+      }
+      case "ENTITLEMENT_CREATE": {
+        this.dispatch("ENTITLEMENT_CREATE", { type: "ENTITLEMENT_CREATE", entitlement: d });
+        break;
+      }
+      case "ENTITLEMENT_UPDATE": {
+        this.dispatch("ENTITLEMENT_UPDATE", { type: "ENTITLEMENT_UPDATE", entitlement: d });
+        break;
+      }
+      case "ENTITLEMENT_DELETE": {
+        this.dispatch("ENTITLEMENT_DELETE", { type: "ENTITLEMENT_DELETE", entitlement: d });
+        break;
+      }
+      case "PRESENCE_UPDATE": {
+        this.dispatch("PRESENCE_UPDATE", {
+          type: "PRESENCE_UPDATE",
+          user: d.user,
+          guildId: d.guild_id,
+          status: d.status,
+          activities: d.activities,
+          clientStatus: d.client_status
+        });
+        break;
+      }
+      case "TYPING_START": {
+        let typingMember;
+        if (d.member && d.guild_id) {
+          typingMember = buildMember(d.member, d.guild_id, this.cache);
+          if (typingMember.user?.id) {
+            this.cache.users.set(typingMember.user.id, typingMember.user);
+            this.cache.members.set(TongueStore.memberKey(d.guild_id, typingMember.user.id), typingMember);
+          }
+        }
+        this.dispatch("TYPING_START", {
+          type: "TYPING_START",
+          channelId: d.channel_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          userId: d.user_id,
+          timestamp: d.timestamp,
+          ...typingMember ? { member: typingMember } : {}
+        });
+        break;
+      }
+      case "USER_UPDATE": {
+        const oldUser = this.cache.users.get(d.id);
+        const user = buildUser(d);
+        this.cache.users.set(user.id, user);
+        if (this.user && user.id === this.user.id) {
+          this.user = user;
+        }
+        this.dispatch("USER_UPDATE", { type: "USER_UPDATE", user, ...oldUser ? { oldUser } : {} });
+        break;
+      }
+      case "WEBHOOKS_UPDATE": {
+        this.dispatch("WEBHOOKS_UPDATE", {
+          type: "WEBHOOKS_UPDATE",
+          guildId: d.guild_id,
+          channelId: d.channel_id
+        });
+        break;
+      }
+      case "MESSAGE_POLL_VOTE_ADD": {
+        this.dispatch("MESSAGE_POLL_VOTE_ADD", {
+          type: "MESSAGE_POLL_VOTE_ADD",
+          userId: d.user_id,
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          answerId: d.answer_id
+        });
+        break;
+      }
+      case "MESSAGE_POLL_VOTE_REMOVE": {
+        this.dispatch("MESSAGE_POLL_VOTE_REMOVE", {
+          type: "MESSAGE_POLL_VOTE_REMOVE",
+          userId: d.user_id,
+          channelId: d.channel_id,
+          messageId: d.message_id,
+          ...d.guild_id ? { guildId: d.guild_id } : {},
+          answerId: d.answer_id
+        });
+        break;
+      }
+      case "GUILD_MEMBERS_CHUNK": {
+        const guildId = d.guild_id;
+        const members = [];
+        if (Array.isArray(d.members)) {
+          for (const raw of d.members) {
+            const member = buildMember(raw, guildId, this.cache);
+            if (member.user?.id) {
+              this.cache.users.set(member.user.id, member.user);
+              this.cache.members.set(TongueStore.memberKey(guildId, member.user.id), member);
+            }
+            members.push(member);
+          }
+        }
+        const chunkCount = d.chunk_count;
+        const state = this.pendingChunks.get(guildId);
+        if (state) {
+          state.total = chunkCount;
+          state.received++;
+          if (state.received >= state.total) {
+            clearTimeout(state.timeout);
+            this.pendingChunks.delete(guildId);
+            if (state.reason) {
+              this.dispatch("GUILD_AVAILABLE", { type: "GUILD_AVAILABLE", guild: state.guild, reason: state.reason });
+            } else {
+              this.dispatch("GUILD_CREATE", { type: "GUILD_CREATE", guild: state.guild });
+            }
+          }
+        }
+        this.dispatch("GUILD_MEMBERS_CHUNK", {
+          type: "GUILD_MEMBERS_CHUNK",
+          guildId,
+          members,
+          chunkIndex: d.chunk_index,
+          chunkCount: d.chunk_count,
+          ...d.not_found ? { notFound: d.not_found } : {},
+          ...d.nonce ? { nonce: d.nonce } : {}
+        });
+        break;
+      }
+      case "THREAD_LIST_SYNC": {
+        const guildId = d.guild_id;
+        const threads = [];
+        if (Array.isArray(d.threads)) {
+          for (const raw of d.threads) {
+            const ch = buildChannel(raw, guildId);
+            this.cache.channels.set(ch.id, ch);
+            threads.push(ch);
+          }
+        }
+        this.dispatch("THREAD_LIST_SYNC", {
+          type: "THREAD_LIST_SYNC",
+          guildId,
+          ...d.channel_ids ? { channelIds: d.channel_ids } : {},
+          threads,
+          members: d.members
+        });
+        break;
+      }
+      case "GUILD_EMOJIS_UPDATE": {
+        const emojis = d.emojis;
+        for (const emoji of emojis) {
+          if (emoji.id) this.cache.emojis.set(emoji.id, emoji);
+        }
+        this.dispatch("GUILD_EMOJIS_UPDATE", {
+          type: "GUILD_EMOJIS_UPDATE",
+          guildId: d.guild_id,
+          emojis
+        });
+        break;
+      }
+      case "GUILD_STICKERS_UPDATE": {
+        const stickers = d.stickers;
+        for (const sticker of stickers) {
+          this.cache.stickers.set(sticker.id, sticker);
+        }
+        this.dispatch("GUILD_STICKERS_UPDATE", {
+          type: "GUILD_STICKERS_UPDATE",
+          guildId: d.guild_id,
+          stickers
+        });
+        break;
+      }
+      case "STAGE_INSTANCE_CREATE": {
+        const stageInstance = d;
+        this.cache.stageInstances.set(stageInstance.id, stageInstance);
+        this.dispatch("STAGE_INSTANCE_CREATE", { type: "STAGE_INSTANCE_CREATE", stageInstance });
+        break;
+      }
+      case "STAGE_INSTANCE_UPDATE": {
+        const stageInstance = d;
+        this.cache.stageInstances.set(stageInstance.id, stageInstance);
+        this.dispatch("STAGE_INSTANCE_UPDATE", { type: "STAGE_INSTANCE_UPDATE", stageInstance });
+        break;
+      }
+      case "STAGE_INSTANCE_DELETE": {
+        const stageInstance = d;
+        this.cache.stageInstances.delete(stageInstance.id);
+        this.dispatch("STAGE_INSTANCE_DELETE", { type: "STAGE_INSTANCE_DELETE", stageInstance });
+        break;
+      }
+      case "GUILD_SCHEDULED_EVENT_CREATE": {
+        const scheduledEvent = d;
+        this.cache.scheduledEvents.set(scheduledEvent.id, scheduledEvent);
+        this.dispatch("GUILD_SCHEDULED_EVENT_CREATE", { type: "GUILD_SCHEDULED_EVENT_CREATE", scheduledEvent });
+        break;
+      }
+      case "GUILD_SCHEDULED_EVENT_UPDATE": {
+        const scheduledEvent = d;
+        this.cache.scheduledEvents.set(scheduledEvent.id, scheduledEvent);
+        this.dispatch("GUILD_SCHEDULED_EVENT_UPDATE", { type: "GUILD_SCHEDULED_EVENT_UPDATE", scheduledEvent });
+        break;
+      }
+      case "GUILD_SCHEDULED_EVENT_DELETE": {
+        const scheduledEvent = d;
+        this.cache.scheduledEvents.delete(scheduledEvent.id);
+        this.dispatch("GUILD_SCHEDULED_EVENT_DELETE", { type: "GUILD_SCHEDULED_EVENT_DELETE", scheduledEvent });
+        break;
+      }
+      case "GUILD_SCHEDULED_EVENT_USER_ADD": {
+        this.dispatch("GUILD_SCHEDULED_EVENT_USER_ADD", { type: "GUILD_SCHEDULED_EVENT_USER_ADD", guildScheduledEventId: d.guild_scheduled_event_id, userId: d.user_id, guildId: d.guild_id });
+        break;
+      }
+      case "GUILD_SCHEDULED_EVENT_USER_REMOVE": {
+        this.dispatch("GUILD_SCHEDULED_EVENT_USER_REMOVE", { type: "GUILD_SCHEDULED_EVENT_USER_REMOVE", guildScheduledEventId: d.guild_scheduled_event_id, userId: d.user_id, guildId: d.guild_id });
+        break;
+      }
+      case "AUTO_MODERATION_RULE_CREATE": {
+        const rule = d;
+        this.cache.autoModRules.set(rule.id, rule);
+        this.dispatch("AUTO_MODERATION_RULE_CREATE", { type: "AUTO_MODERATION_RULE_CREATE", rule });
+        break;
+      }
+      case "AUTO_MODERATION_RULE_UPDATE": {
+        const rule = d;
+        this.cache.autoModRules.set(rule.id, rule);
+        this.dispatch("AUTO_MODERATION_RULE_UPDATE", { type: "AUTO_MODERATION_RULE_UPDATE", rule });
+        break;
+      }
+      case "AUTO_MODERATION_RULE_DELETE": {
+        const rule = d;
+        this.cache.autoModRules.delete(rule.id);
+        this.dispatch("AUTO_MODERATION_RULE_DELETE", { type: "AUTO_MODERATION_RULE_DELETE", rule });
+        break;
+      }
+      case "AUTO_MODERATION_ACTION_EXECUTION": {
+        this.dispatch("AUTO_MODERATION_ACTION_EXECUTION", {
+          type: "AUTO_MODERATION_ACTION_EXECUTION",
+          guildId: d.guild_id,
+          action: d.action,
+          ruleId: d.rule_id,
+          ruleTriggerType: d.rule_trigger_type,
+          userId: d.user_id,
+          ...d.channel_id ? { channelId: d.channel_id } : {},
+          ...d.message_id ? { messageId: d.message_id } : {},
+          ...d.content !== void 0 ? { content: d.content } : {},
+          ...d.matched_keyword !== void 0 ? { matchedKeyword: d.matched_keyword } : {},
+          ...d.matched_content !== void 0 ? { matchedContent: d.matched_content } : {}
+        });
+        break;
+      }
+      case "INTEGRATION_CREATE": {
+        const integration = d;
+        this.cache.integrations.set(integration.id, integration);
+        this.dispatch("INTEGRATION_CREATE", { type: "INTEGRATION_CREATE", guildId: d.guild_id, integration });
+        break;
+      }
+      case "INTEGRATION_UPDATE": {
+        const integration = d;
+        this.cache.integrations.set(integration.id, integration);
+        this.dispatch("INTEGRATION_UPDATE", { type: "INTEGRATION_UPDATE", guildId: d.guild_id, integration });
+        break;
+      }
+      case "INTEGRATION_DELETE": {
+        this.cache.integrations.delete(d.id);
+        this.dispatch("INTEGRATION_DELETE", {
+          type: "INTEGRATION_DELETE",
+          id: d.id,
+          guildId: d.guild_id,
+          ...d.application_id ? { applicationId: d.application_id } : {}
+        });
+        break;
+      }
+    }
+  }
+};
+
+// src/utils/permissions.ts
+function hasPermission(permissions, flag) {
+  const bits = typeof permissions === "string" ? BigInt(permissions) : permissions;
+  return (bits & flag) === flag;
+}
+function hasAllPermissions(permissions, ...flags) {
+  const bits = typeof permissions === "string" ? BigInt(permissions) : permissions;
+  for (const flag of flags) {
+    if ((bits & flag) !== flag) return false;
+  }
+  return true;
+}
+function hasAnyPermission(permissions, ...flags) {
+  const bits = typeof permissions === "string" ? BigInt(permissions) : permissions;
+  for (const flag of flags) {
+    if ((bits & flag) === flag) return true;
+  }
+  return false;
+}
+function combinePermissions(...flags) {
+  let result = 0n;
+  for (const flag of flags) result |= flag;
+  return result;
+}
+function listPermissions(permissions) {
+  const bits = typeof permissions === "string" ? BigInt(permissions) : permissions;
+  const result = [];
+  for (const [name, flag] of Object.entries(DISCORD_PERMISSIONS)) {
+    if ((bits & flag) === flag) result.push(name);
+  }
+  return result;
+}
+
+// src/utils/chameleon.ts
+import os from "os";
+var Chameleon = class {
+  static get lifespan() {
+    return {
+      get ram() {
+        return Math.round(process.memoryUsage().rss / 1024 / 1024);
+      },
+      get cpu() {
+        return os.loadavg()[0];
+      }
+    };
+  }
+};
+export {
+  AUDIT_LOG_EVENT_TYPES,
+  ActionRow,
+  ActionRowBuilder,
+  Activity,
+  ActivityLocationKind,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ApplicationEventWebhookStatus,
+  ApplicationFlag,
+  ApplicationIntegrationType,
+  ApplicationRoleConnectionMetadataType,
+  AttachmentFlag,
+  AutoModerationActionType,
+  AutoModerationEventType,
+  AutoModerationKeywordPresetType,
+  AutoModerationTriggerType,
+  BaseManager,
+  ButtonBuilder,
+  ButtonStyle,
+  CHAMELEON_SELF_MAP,
+  Chameleon,
+  ChameleonGateway,
+  ChameleonREST,
+  ChannelFlag,
+  ChannelManager,
+  ChannelType,
+  Client,
+  CollectorManager,
+  Colors,
+  CommandContext,
+  CommandManager,
+  ComponentContext2 as ComponentContext,
+  ComponentManager,
+  ComponentType,
+  DISCORD_GATEWAY_OPCODES,
+  DISCORD_PERMISSIONS,
+  DefaultMessageNotificationLevel,
+  EmbedBuilder,
+  EmbedType,
+  EntitlementType,
+  ExplicitContentFilterLevel,
+  ForumLayoutType,
+  GuildInviteFlag,
+  GuildManager,
+  GuildMemberFlag,
+  GuildNSFWLevel,
+  GuildScheduledEventEntityType,
+  GuildScheduledEventPrivacyLevel,
+  GuildScheduledEventStatus,
+  IntegrationExpireBehavior,
+  IntentBits,
+  Intents,
+  InviteTargetType,
+  InviteType,
+  LobbyMemberFlag,
+  MFALevel,
+  MemberManager,
+  MessageActivityType,
+  MessageFlag,
+  MessageManager,
+  MessageReferenceType,
+  MessageType,
+  ModalBuilder,
+  PremiumTier,
+  PremiumType,
+  SelectMenuBuilder,
+  SkuFlag,
+  SkuType,
+  SortOrderType,
+  StagePrivacyLevel,
+  StickerFormatType,
+  StickerType,
+  SubscriptionStatus,
+  SystemChannelFlag,
+  TextInputBuilder,
+  Tongue,
+  TongueStore,
+  UserFlag,
+  UserManager,
+  VerificationLevel,
+  VideoQualityMode,
+  VisibilityType,
+  WebhookType,
+  buildChannel,
+  buildGuild,
+  buildMember,
+  buildMessage,
+  buildModalPayload,
+  buildRole,
+  buildUser,
+  combinePermissions,
+  defineButton,
+  defineChannelSelect,
+  defineCommand,
+  defineMentionableSelect,
+  defineModal,
+  defineRoleSelect,
+  defineStringSelect,
+  defineSubcommand,
+  defineUserSelect,
+  field,
+  hasAllPermissions,
+  hasAnyPermission,
+  hasPermission,
+  listPermissions,
+  opt,
+  resolveButtonStyle,
+  resolveChannel,
+  resolveGuild,
+  resolveRole,
+  resolveUser
+};