@sillyfrogster/eunia 0.1.0-alpha.1

package/dist/index.d.mts

@@ -0,0 +1,4188 @@
+import { EventEmitter } from "node:events";
+//#region packages/cache/src/adapter.d.ts
+interface CacheAdapter {
+  get(namespace: string, key: string): Promise<unknown | undefined>;
+  set(namespace: string, key: string, value: unknown, ttl?: number): Promise<void>;
+  delete(namespace: string, key: string): Promise<void>;
+  clear(namespace: string): Promise<void>;
+  close(): Promise<void>;
+}
+type CacheAdapterOperation = "get" | "set" | "delete" | "clear" | "close";
+interface CacheErrorContext {
+  operation: CacheAdapterOperation;
+  namespace: string;
+  key?: string;
+}
+type CacheErrorHandler = (error: unknown, context: CacheErrorContext) => unknown;
+//#endregion
+//#region packages/cache/src/memory.d.ts
+interface MemoryStoreOptions {
+  maxSize?: number;
+  ttl?: number;
+  now?: () => number;
+}
+declare class MemoryStore<T> {
+  readonly maxSize: number;
+  readonly ttl: number | undefined;
+  private readonly items;
+  private readonly now;
+  constructor(options?: MemoryStoreOptions | number);
+  resolve(id: string): T | undefined;
+  get(id: string): T | undefined;
+  set(id: string, value: T, ttl?: number | undefined): void;
+  delete(id: string): boolean;
+  has(id: string): boolean;
+  clear(): void;
+  get size(): number;
+  values(): IterableIterator<T>;
+  keys(): IterableIterator<string>;
+  entries(): IterableIterator<[string, T]>;
+  private evictOverflow;
+  private isExpired;
+  private removeExpired;
+}
+//#endregion
+//#region packages/cache/src/store.d.ts
+interface CachePolicy {
+  maxSize?: number;
+  ttl?: number;
+  readThroughTtl?: number;
+  maxPendingOperations?: number;
+}
+interface ResolvedCachePolicy {
+  maxSize: number;
+  ttl?: number;
+  readThroughTtl: number;
+  maxPendingOperations: number;
+}
+interface CacheStoreOptions {
+  namespace: string;
+  policy?: CachePolicy;
+  adapter?: CacheAdapter;
+  onError?: CacheErrorHandler;
+  now?: () => number;
+}
+type CacheBackpressureOperation = Exclude<CacheAdapterOperation, "close">;
+declare class CacheBackpressureError extends Error {
+  readonly namespace: string;
+  readonly operation: CacheBackpressureOperation;
+  readonly limit: number;
+  readonly pendingOperations: number;
+  readonly code = "CACHE_BACKPRESSURE";
+  constructor(namespace: string, operation: CacheBackpressureOperation, limit: number, pendingOperations: number);
+}
+declare const DEFAULT_CACHE_READ_THROUGH_TTL: number;
+declare const DEFAULT_CACHE_MAX_PENDING_OPERATIONS = 1000;
+declare class CacheStore<T> {
+  readonly namespace: string;
+  readonly policy: Readonly<ResolvedCachePolicy>;
+  readonly hot: MemoryStore<T>;
+  private readonly adapter;
+  private readonly onError;
+  private readonly keyWrites;
+  private readonly pendingWrites;
+  private readonly reads;
+  private readonly keyVersions;
+  private clearVersion;
+  private clearWrite;
+  private clearPending;
+  constructor(options: CacheStoreOptions);
+  resolve(id: string): T | undefined;
+  get(id: string): Promise<T | undefined>;
+  has(id: string): boolean;
+  set(id: string, value: T, ttl?: number | undefined): void;
+  delete(id: string): boolean;
+  clear(): void;
+  get size(): number;
+  get pendingOperations(): number;
+  values(): IterableIterator<T>;
+  keys(): IterableIterator<string>;
+  entries(): IterableIterator<[string, T]>;
+  flush(): Promise<void>;
+  private readThrough;
+  private enqueueKeyWrite;
+  private executeKeyWrite;
+  private settleWrite;
+  private trackWrite;
+  private waitForWrites;
+  private canCoalesceKeyWrite;
+  private assertCapacity;
+  private bumpVersion;
+  private finishRead;
+  private removeVersionWhenIdle;
+  private report;
+}
+//#endregion
+//#region packages/cache/src/cache.d.ts
+interface CacheShape {
+  user: unknown;
+  guild: unknown;
+  channel: unknown;
+  message: unknown;
+  member?: unknown;
+  role?: unknown;
+}
+type BuiltInCacheDomain = "users" | "guilds" | "channels" | "messages" | "members" | "roles";
+declare const DEFAULT_CACHE_POLICIES: {
+  readonly users: {
+    readonly maxSize: 10000;
+  };
+  readonly guilds: {
+    readonly maxSize: 1000;
+  };
+  readonly channels: {
+    readonly maxSize: 10000;
+  };
+  readonly messages: {
+    readonly maxSize: 1000;
+    readonly ttl: number;
+  };
+  readonly members: {
+    readonly maxSize: 25000;
+  };
+  readonly roles: {
+    readonly maxSize: 5000;
+  };
+};
+interface RedisAdapterConfig {
+  driver: "redis" | "valkey";
+  url?: string;
+  prefix?: string;
+}
+interface MemoryAdapterConfig {
+  driver: "memory";
+}
+type BuiltInCacheAdapterConfig = MemoryAdapterConfig | RedisAdapterConfig;
+interface CacheOptions {
+  adapter?: CacheAdapter | BuiltInCacheAdapterConfig;
+  policies?: Partial<Record<BuiltInCacheDomain, CachePolicy>>;
+  onError?: CacheErrorHandler;
+}
+type ShapeValue<S, K extends PropertyKey> = K extends keyof S ? S[K] : unknown;
+declare class Cache<S extends CacheShape = CacheShape> {
+  readonly users: CacheStore<ShapeValue<S, "user">>;
+  readonly guilds: CacheStore<ShapeValue<S, "guild">>;
+  readonly channels: CacheStore<ShapeValue<S, "channel">>;
+  readonly messages: CacheStore<ShapeValue<S, "message">>;
+  readonly members: CacheStore<ShapeValue<S, "member">>;
+  readonly roles: CacheStore<ShapeValue<S, "role">>;
+  private readonly adapter;
+  private readonly onError;
+  private readonly domains;
+  private closePromise;
+  constructor(options?: CacheOptions);
+  domain<T>(name: string, policy?: CachePolicy): CacheStore<T>;
+  flush(): Promise<void>;
+  close(): Promise<void>;
+  private createDomain;
+  private closeAdapter;
+}
+//#endregion
+//#region packages/cache/src/redis.d.ts
+interface RedisClientLike {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<unknown>;
+  set(key: string, value: string, px: "PX", milliseconds: number): Promise<unknown>;
+  del(...keys: string[]): Promise<number>;
+  scan(cursor: string | number, match: "MATCH", pattern: string, count: "COUNT", hint: number): Promise<[string, string[]]>;
+  close(): void | Promise<void>;
+}
+interface RedisCacheAdapterOptions {
+  url?: string;
+  prefix?: string;
+  client?: RedisClientLike;
+}
+declare class RedisCacheAdapter implements CacheAdapter {
+  readonly prefix: string;
+  private readonly client;
+  constructor(options?: RedisCacheAdapterOptions);
+  get(namespace: string, key: string): Promise<unknown | undefined>;
+  set(namespace: string, key: string, value: unknown, ttl?: number): Promise<void>;
+  delete(namespace: string, key: string): Promise<void>;
+  clear(namespace: string): Promise<void>;
+  close(): Promise<void>;
+  private key;
+  private namespacePrefix;
+}
+declare class ValkeyCacheAdapter extends RedisCacheAdapter {}
+//#endregion
+//#region packages/types/src/common.d.ts
+type Snowflake = string;
+type BitfieldString = `${bigint}`;
+type ISO8601Timestamp = string;
+type Awaitable$1<T> = T | PromiseLike<T>;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type Locale = "id" | "da" | "de" | "en-GB" | "en-US" | "es-ES" | "es-419" | "fr" | "hr" | "it" | "lt" | "hu" | "nl" | "no" | "pl" | "pt-BR" | "ro" | "fi" | "sv-SE" | "vi" | "tr" | "cs" | "el" | "bg" | "ru" | "uk" | "hi" | "th" | "zh-CN" | "ja" | "zh-TW" | "ko";
+type Localizations = Partial<Record<Locale, string | null>>;
+//#endregion
+//#region packages/types/src/user.d.ts
+declare enum PremiumType {
+  None = 0,
+  NitroClassic = 1,
+  Nitro = 2,
+  NitroBasic = 3
+}
+declare enum UserFlags {
+  Staff = 1,
+  Partner = 2,
+  HypeSquad = 4,
+  BugHunterLevel1 = 8,
+  HypeSquadBravery = 64,
+  HypeSquadBrilliance = 128,
+  HypeSquadBalance = 256,
+  PremiumEarlySupporter = 512,
+  TeamPseudoUser = 1024,
+  BugHunterLevel2 = 16384,
+  VerifiedBot = 65536,
+  VerifiedDeveloper = 131072,
+  CertifiedModerator = 262144,
+  BotHTTPInteractions = 524288
+}
+interface AvatarDecorationData {
+  asset: string;
+  sku_id: Snowflake;
+}
+type NameplatePalette = "crimson" | "berry" | "sky" | "teal" | "forest" | "bubble_gum" | "violet" | "cobalt" | "clover" | "lemon" | "white";
+interface Nameplate {
+  sku_id: Snowflake;
+  asset: string;
+  label: string;
+  palette: NameplatePalette;
+}
+interface Collectibles {
+  nameplate?: Nameplate;
+}
+interface UserPrimaryGuild {
+  identity_guild_id: Snowflake | null;
+  identity_enabled: boolean | null;
+  tag: string | null;
+  badge: string | null;
+}
+/** A user returned by the HTTP API or gateway. */
+interface User$1 {
+  id: Snowflake;
+  username: string;
+  discriminator: string;
+  global_name: string | null;
+  avatar: string | null;
+  bot?: boolean;
+  system?: boolean;
+  mfa_enabled?: boolean;
+  banner?: string | null;
+  accent_color?: number | null;
+  locale?: Locale;
+  verified?: boolean;
+  email?: string | null;
+  flags?: number;
+  premium_type?: PremiumType;
+  public_flags?: number;
+  avatar_decoration_data?: AvatarDecorationData | null;
+  collectibles?: Collectibles | null;
+  primary_guild?: UserPrimaryGuild | null;
+}
+type PartialUser = Pick<User$1, "id"> & Partial<Omit<User$1, "id">>;
+//#endregion
+//#region packages/types/src/emoji.d.ts
+interface Emoji {
+  id: Snowflake | null;
+  name: string | null;
+  roles?: Snowflake[];
+  user?: User$1;
+  require_colons?: boolean;
+  managed?: boolean;
+  animated?: boolean;
+  available?: boolean;
+}
+type PartialEmoji = Pick<Emoji, "id" | "name"> & Partial<Omit<Emoji, "id" | "name">>;
+//#endregion
+//#region packages/types/src/sticker.d.ts
+declare enum StickerType {
+  Standard = 1,
+  Guild = 2
+}
+declare enum StickerFormatType {
+  PNG = 1,
+  APNG = 2,
+  Lottie = 3,
+  GIF = 4
+}
+interface Sticker {
+  id: Snowflake;
+  pack_id?: Snowflake;
+  name: string;
+  description: string | null;
+  tags: string;
+  type: StickerType;
+  format_type: StickerFormatType;
+  available?: boolean;
+  guild_id?: Snowflake;
+  user?: User$1;
+  sort_value?: number;
+}
+interface StickerItem {
+  id: Snowflake;
+  name: string;
+  format_type: StickerFormatType;
+}
+interface StickerPack {
+  id: Snowflake;
+  stickers: Sticker[];
+  name: string;
+  sku_id: Snowflake;
+  cover_sticker_id?: Snowflake;
+  description: string;
+  banner_asset_id?: Snowflake;
+}
+//#endregion
+//#region packages/types/src/guild.d.ts
+declare enum GuildVerificationLevel {
+  None = 0,
+  Low = 1,
+  Medium = 2,
+  High = 3,
+  VeryHigh = 4
+}
+declare enum GuildDefaultMessageNotificationLevel {
+  AllMessages = 0,
+  OnlyMentions = 1
+}
+declare enum GuildExplicitContentFilterLevel {
+  Disabled = 0,
+  MembersWithoutRoles = 1,
+  AllMembers = 2
+}
+declare enum GuildMFALevel {
+  None = 0,
+  Elevated = 1
+}
+declare enum GuildPremiumTier {
+  None = 0,
+  Tier1 = 1,
+  Tier2 = 2,
+  Tier3 = 3
+}
+declare enum GuildNSFWLevel {
+  Default = 0,
+  Explicit = 1,
+  Safe = 2,
+  AgeRestricted = 3
+}
+declare enum SystemChannelFlags {
+  SuppressJoinNotifications = 1,
+  SuppressPremiumSubscriptions = 2,
+  SuppressGuildReminderNotifications = 4,
+  SuppressJoinNotificationReplies = 8,
+  SuppressRoleSubscriptionPurchaseNotifications = 16,
+  SuppressRoleSubscriptionPurchaseNotificationReplies = 32
+}
+declare const PermissionFlags: {
+  readonly CreateInstantInvite: bigint;
+  readonly KickMembers: bigint;
+  readonly BanMembers: bigint;
+  readonly Administrator: bigint;
+  readonly ManageChannels: bigint;
+  readonly ManageGuild: bigint;
+  readonly AddReactions: bigint;
+  readonly ViewAuditLog: bigint;
+  readonly PrioritySpeaker: bigint;
+  readonly Stream: bigint;
+  readonly ViewChannel: bigint;
+  readonly SendMessages: bigint;
+  readonly SendTtsMessages: bigint;
+  readonly ManageMessages: bigint;
+  readonly EmbedLinks: bigint;
+  readonly AttachFiles: bigint;
+  readonly ReadMessageHistory: bigint;
+  readonly MentionEveryone: bigint;
+  readonly UseExternalEmojis: bigint;
+  readonly ViewGuildInsights: bigint;
+  readonly Connect: bigint;
+  readonly Speak: bigint;
+  readonly MuteMembers: bigint;
+  readonly DeafenMembers: bigint;
+  readonly MoveMembers: bigint;
+  readonly UseVad: bigint;
+  readonly ChangeNickname: bigint;
+  readonly ManageNicknames: bigint;
+  readonly ManageRoles: bigint;
+  readonly ManageWebhooks: bigint;
+  readonly ManageGuildExpressions: bigint;
+  readonly UseApplicationCommands: bigint;
+  readonly RequestToSpeak: bigint;
+  readonly ManageEvents: bigint;
+  readonly ManageThreads: bigint;
+  readonly CreatePublicThreads: bigint;
+  readonly CreatePrivateThreads: bigint;
+  readonly UseExternalStickers: bigint;
+  readonly SendMessagesInThreads: bigint;
+  readonly UseEmbeddedActivities: bigint;
+  readonly ModerateMembers: bigint;
+  readonly ViewCreatorMonetizationAnalytics: bigint;
+  readonly UseSoundboard: bigint;
+  readonly CreateGuildExpressions: bigint;
+  readonly CreateEvents: bigint;
+  readonly UseExternalSounds: bigint;
+  readonly SendVoiceMessages: bigint;
+  readonly SetVoiceChannelStatus: bigint;
+  readonly SendPolls: bigint;
+  readonly UseExternalApps: bigint;
+  readonly PinMessages: bigint;
+  readonly BypassSlowmode: bigint;
+};
+type PermissionFlag = (typeof PermissionFlags)[keyof typeof PermissionFlags];
+type PermissionFlagName = keyof typeof PermissionFlags;
+type PermissionInput = bigint | BitfieldString | readonly PermissionFlag[];
+/** Folds a PermissionInput into a single bigint bitfield. */
+declare function toPermissionBits(value: PermissionInput): bigint;
+/** Returns true when the bitfield contains every flag in `required` (Administrator implies all). */
+declare function can(permissions: bigint, required: bigint): boolean;
+/** Returns true when the bitfield contains at least one flag in `anyOf` (Administrator implies all). */
+declare function canAny(permissions: bigint, anyOf: bigint): boolean;
+/** Names the flags in `required` that the bitfield lacks (empty for Administrator). */
+declare function missing(permissions: bigint, required: bigint): PermissionFlagName[];
+/** Names every flag set in the bitfield. */
+declare function toFlagNames(permissions: bigint): PermissionFlagName[];
+declare enum RoleFlags {
+  InPrompt = 1
+}
+declare enum GuildMemberFlags {
+  DidRejoin = 1,
+  CompletedOnboarding = 2,
+  BypassesVerification = 4,
+  StartedOnboarding = 8,
+  IsGuest = 16,
+  StartedHomeActions = 32,
+  CompletedHomeActions = 64,
+  AutoModQuarantinedUsername = 128,
+  DMSettingsUpsellAcknowledged = 512,
+  AutoModQuarantinedGuildTag = 1024
+}
+interface RoleColors {
+  primary_color: number;
+  secondary_color: number | null;
+  tertiary_color: number | null;
+}
+interface RoleTags {
+  bot_id?: Snowflake;
+  integration_id?: Snowflake;
+  premium_subscriber?: null;
+  subscription_listing_id?: Snowflake;
+  available_for_purchase?: null;
+  guild_connections?: null;
+}
+interface Role$1 {
+  id: Snowflake;
+  name: string;
+  color: number;
+  colors: RoleColors;
+  hoist: boolean;
+  icon: string | null;
+  unicode_emoji: string | null;
+  position: number;
+  permissions: BitfieldString;
+  managed: boolean;
+  mentionable: boolean;
+  tags?: RoleTags;
+  flags: number;
+}
+interface GuildMember$1 {
+  user?: User$1;
+  nick?: string | null;
+  avatar?: string | null;
+  banner?: string | null;
+  roles: Snowflake[];
+  joined_at: ISO8601Timestamp | null;
+  premium_since?: ISO8601Timestamp | null;
+  deaf: boolean;
+  mute: boolean;
+  flags: number;
+  pending?: boolean;
+  permissions?: BitfieldString;
+  communication_disabled_until?: ISO8601Timestamp | null;
+  avatar_decoration_data?: User$1["avatar_decoration_data"];
+  collectibles?: Collectibles | null;
+}
+interface GuildBan {
+  reason: string | null;
+  user: User$1;
+}
+interface WelcomeScreenChannel {
+  channel_id: Snowflake;
+  description: string;
+  emoji_id: Snowflake | null;
+  emoji_name: string | null;
+}
+interface WelcomeScreen {
+  description: string | null;
+  welcome_channels: WelcomeScreenChannel[];
+}
+interface GuildIncidentsData {
+  invites_disabled_until?: ISO8601Timestamp | null;
+  dms_disabled_until?: ISO8601Timestamp | null;
+  dm_spam_detected_at?: ISO8601Timestamp | null;
+  raid_detected_at?: ISO8601Timestamp | null;
+}
+interface UnavailableGuild {
+  id: Snowflake;
+  unavailable: true;
+}
+/** A guild returned by the HTTP API or gateway. */
+interface Guild$1 {
+  id: Snowflake;
+  name: string;
+  icon: string | null;
+  splash: string | null;
+  discovery_splash: string | null;
+  owner?: boolean;
+  owner_id: Snowflake;
+  permissions?: BitfieldString;
+  afk_channel_id: Snowflake | null;
+  afk_timeout: number;
+  widget_enabled?: boolean;
+  widget_channel_id?: Snowflake | null;
+  verification_level: GuildVerificationLevel;
+  default_message_notifications: GuildDefaultMessageNotificationLevel;
+  explicit_content_filter: GuildExplicitContentFilterLevel;
+  roles: Role$1[];
+  emojis: Emoji[];
+  features: string[];
+  mfa_level: GuildMFALevel;
+  application_id: Snowflake | null;
+  system_channel_id: Snowflake | null;
+  system_channel_flags: number;
+  rules_channel_id: Snowflake | null;
+  max_presences?: number | null;
+  max_members?: number;
+  vanity_url_code: string | null;
+  description: string | null;
+  banner: string | null;
+  premium_tier: GuildPremiumTier;
+  premium_subscription_count?: number;
+  preferred_locale: Locale;
+  public_updates_channel_id: Snowflake | null;
+  max_video_channel_users?: number;
+  max_stage_video_channel_users?: number;
+  approximate_member_count?: number;
+  approximate_presence_count?: number;
+  nsfw_level: GuildNSFWLevel;
+  welcome_screen?: WelcomeScreen;
+  stickers?: Sticker[];
+  premium_progress_bar_enabled: boolean;
+  safety_alerts_channel_id: Snowflake | null;
+  incidents_data: GuildIncidentsData | null;
+  channels?: Channel$1[];
+  threads?: Channel$1[];
+  members?: GuildMember$1[];
+  unavailable?: boolean;
+  member_count?: number;
+  joined_at?: ISO8601Timestamp;
+  large?: boolean;
+}
+type PartialGuild = Pick<Guild$1, "id" | "name" | "icon" | "banner" | "owner" | "permissions" | "features"> & Pick<Guild$1, "approximate_member_count" | "approximate_presence_count">;
+//#endregion
+//#region packages/types/src/channel.d.ts
+declare enum ChannelType {
+  GuildText = 0,
+  DM = 1,
+  GuildVoice = 2,
+  GroupDM = 3,
+  GuildCategory = 4,
+  GuildAnnouncement = 5,
+  AnnouncementThread = 10,
+  PublicThread = 11,
+  PrivateThread = 12,
+  GuildStageVoice = 13,
+  GuildDirectory = 14,
+  GuildForum = 15,
+  GuildMedia = 16
+}
+declare enum OverwriteType {
+  Role = 0,
+  Member = 1
+}
+declare enum VideoQualityMode {
+  Auto = 1,
+  Full = 2
+}
+declare enum ChannelFlags {
+  Pinned = 2,
+  RequireTag = 16,
+  HideMediaDownloadOptions = 32768,
+  IsSpoilerChannel = 2097152
+}
+declare enum SortOrderType {
+  LatestActivity = 0,
+  CreationDate = 1
+}
+declare enum ForumLayoutType {
+  NotSet = 0,
+  ListView = 1,
+  GalleryView = 2
+}
+type ThreadAutoArchiveDuration = 60 | 1_440 | 4_320 | 10_080;
+interface PermissionOverwrite {
+  id: Snowflake;
+  type: OverwriteType;
+  allow: BitfieldString;
+  deny: BitfieldString;
+}
+interface ThreadMetadata {
+  archived: boolean;
+  auto_archive_duration: ThreadAutoArchiveDuration;
+  archive_timestamp: ISO8601Timestamp;
+  locked: boolean;
+  invitable?: boolean;
+  create_timestamp?: ISO8601Timestamp | null;
+}
+interface ThreadMember {
+  id?: Snowflake;
+  user_id?: Snowflake;
+  join_timestamp: ISO8601Timestamp;
+  flags: number;
+  member?: GuildMember$1;
+}
+interface ForumTagBase {
+  id: Snowflake;
+  name: string;
+  moderated: boolean;
+}
+type ForumTag = ForumTagBase & ({
+  emoji_id: Snowflake;
+  emoji_name: null;
+} | {
+  emoji_id: null;
+  emoji_name: string;
+} | {
+  emoji_id: null;
+  emoji_name: null;
+});
+type DefaultReaction = {
+  emoji_id: Snowflake;
+  emoji_name: null;
+} | {
+  emoji_id: null;
+  emoji_name: string;
+};
+/** A channel returned by the HTTP API or gateway. */
+interface Channel$1 {
+  id: Snowflake;
+  type: ChannelType;
+  guild_id?: Snowflake;
+  position?: number;
+  permission_overwrites?: PermissionOverwrite[];
+  name?: string | null;
+  topic?: string | null;
+  nsfw?: boolean;
+  last_message_id?: Snowflake | null;
+  bitrate?: number;
+  user_limit?: number;
+  rate_limit_per_user?: number;
+  recipients?: User$1[];
+  icon?: string | null;
+  owner_id?: Snowflake;
+  application_id?: Snowflake;
+  managed?: boolean;
+  parent_id?: Snowflake | null;
+  last_pin_timestamp?: ISO8601Timestamp | null;
+  rtc_region?: string | null;
+  video_quality_mode?: VideoQualityMode;
+  message_count?: number;
+  member_count?: number;
+  thread_metadata?: ThreadMetadata;
+  member?: ThreadMember;
+  default_auto_archive_duration?: ThreadAutoArchiveDuration;
+  permissions?: BitfieldString;
+  app_permissions?: BitfieldString;
+  flags?: number;
+  total_message_sent?: number;
+  available_tags?: ForumTag[];
+  applied_tags?: Snowflake[];
+  default_reaction_emoji?: DefaultReaction | null;
+  default_thread_rate_limit_per_user?: number;
+  default_sort_order?: SortOrderType | null;
+  default_forum_layout?: ForumLayoutType;
+}
+//#endregion
+//#region packages/types/src/application.d.ts
+declare enum ApplicationCommandType {
+  ChatInput = 1,
+  User = 2,
+  Message = 3,
+  PrimaryEntryPoint = 4
+}
+declare enum ApplicationCommandOptionType {
+  Subcommand = 1,
+  SubcommandGroup = 2,
+  String = 3,
+  Integer = 4,
+  Boolean = 5,
+  User = 6,
+  Channel = 7,
+  Role = 8,
+  Mentionable = 9,
+  Number = 10,
+  Attachment = 11
+}
+declare enum ApplicationIntegrationType {
+  GuildInstall = 0,
+  UserInstall = 1
+}
+declare enum InteractionContextType {
+  Guild = 0,
+  BotDM = 1,
+  PrivateChannel = 2
+}
+declare enum EntryPointCommandHandlerType {
+  AppHandler = 1,
+  DiscordLaunchActivity = 2
+}
+declare enum ApplicationCommandPermissionType {
+  Role = 1,
+  User = 2,
+  Channel = 3
+}
+interface InstallParams {
+  scopes: string[];
+  permissions: BitfieldString;
+}
+interface ApplicationIntegrationTypeConfiguration {
+  oauth2_install_params?: InstallParams;
+}
+interface TeamMember {
+  membership_state: 1 | 2;
+  team_id: Snowflake;
+  user: PartialUser;
+  role?: string;
+  permissions?: string[];
+}
+interface Team {
+  icon: string | null;
+  id: Snowflake;
+  members: TeamMember[];
+  name: string;
+  owner_user_id: Snowflake;
+}
+interface Application {
+  id: Snowflake;
+  name: string;
+  icon: string | null;
+  description: string;
+  rpc_origins?: string[];
+  bot_public: boolean;
+  bot_require_code_grant: boolean;
+  bot?: PartialUser;
+  terms_of_service_url?: string;
+  privacy_policy_url?: string;
+  owner?: PartialUser;
+  verify_key: string;
+  team: Team | null;
+  guild_id?: Snowflake;
+  guild?: PartialGuild;
+  primary_sku_id?: Snowflake;
+  slug?: string;
+  cover_image?: string;
+  flags?: number;
+  flags_new?: BitfieldString;
+  approximate_guild_count?: number;
+  approximate_user_install_count?: number;
+  approximate_user_authorization_count?: number;
+  redirect_uris?: string[];
+  interactions_endpoint_url?: string | null;
+  role_connections_verification_url?: string | null;
+  event_webhooks_url?: string | null;
+  event_webhooks_status?: 1 | 2 | 3;
+  event_webhooks_types?: string[];
+  tags?: string[];
+  install_params?: InstallParams;
+  integration_types_config?: Partial<Record<ApplicationIntegrationType, ApplicationIntegrationTypeConfiguration>>;
+  custom_install_url?: string;
+}
+interface ApplicationCommandChoice<T extends string | number = string | number> {
+  name: string;
+  name_localizations?: Localizations | null;
+  value: T;
+}
+interface ApplicationCommandOptionBase<T extends ApplicationCommandOptionType> {
+  type: T;
+  name: string;
+  name_localizations?: Localizations | null;
+  description: string;
+  description_localizations?: Localizations | null;
+}
+type CommandOptionChoices<T extends string | number> = {
+  choices?: ApplicationCommandChoice<T>[];
+  autocomplete?: false;
+} | {
+  choices?: never;
+  autocomplete: true;
+};
+type ApplicationCommandSubcommandOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.Subcommand> & {
+  options?: ApplicationCommandBasicOption[];
+};
+type ApplicationCommandSubcommandGroupOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.SubcommandGroup> & {
+  options: ApplicationCommandSubcommandOption[];
+};
+type ApplicationCommandStringOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.String> & CommandOptionChoices<string> & {
+  required?: boolean;
+  min_length?: number;
+  max_length?: number;
+};
+type ApplicationCommandNumericOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.Integer | ApplicationCommandOptionType.Number> & CommandOptionChoices<number> & {
+  required?: boolean;
+  min_value?: number;
+  max_value?: number;
+};
+type ApplicationCommandChannelOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.Channel> & {
+  required?: boolean;
+  channel_types?: ChannelType[];
+};
+type ApplicationCommandSimpleOption = ApplicationCommandOptionBase<ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.User | ApplicationCommandOptionType.Role | ApplicationCommandOptionType.Mentionable | ApplicationCommandOptionType.Attachment> & {
+  required?: boolean;
+};
+type ApplicationCommandBasicOption = ApplicationCommandStringOption | ApplicationCommandNumericOption | ApplicationCommandChannelOption | ApplicationCommandSimpleOption;
+type ApplicationCommandOption = ApplicationCommandSubcommandOption | ApplicationCommandSubcommandGroupOption | ApplicationCommandBasicOption;
+interface ApplicationCommandCreateBase {
+  name: string;
+  name_localizations?: Localizations | null;
+  default_member_permissions?: BitfieldString | null;
+  dm_permission?: boolean;
+  default_permission?: boolean | null;
+  contexts?: InteractionContextType[] | null;
+  integration_types?: ApplicationIntegrationType[];
+  nsfw?: boolean;
+}
+type ChatInputApplicationCommandCreate = ApplicationCommandCreateBase & {
+  type?: ApplicationCommandType.ChatInput;
+  description: string;
+  description_localizations?: Localizations | null;
+  options?: ApplicationCommandOption[];
+  handler?: never;
+};
+type ContextMenuApplicationCommandCreate = ApplicationCommandCreateBase & {
+  type: ApplicationCommandType.User | ApplicationCommandType.Message;
+  description?: never;
+  description_localizations?: never;
+  options?: never;
+  handler?: never;
+};
+type PrimaryEntryPointApplicationCommandCreate = ApplicationCommandCreateBase & {
+  type: ApplicationCommandType.PrimaryEntryPoint;
+  description: string;
+  description_localizations?: Localizations | null;
+  options?: never;
+  handler?: EntryPointCommandHandlerType;
+};
+type ApplicationCommandCreate = ChatInputApplicationCommandCreate | ContextMenuApplicationCommandCreate | PrimaryEntryPointApplicationCommandCreate;
+interface ApplicationCommandBase extends ApplicationCommandCreateBase {
+  id: Snowflake;
+  application_id: Snowflake;
+  guild_id?: Snowflake;
+  description: string;
+  description_localizations?: Localizations | null;
+  version: Snowflake;
+  name_localized?: string;
+  description_localized?: string;
+}
+type ApplicationCommand = (ApplicationCommandBase & {
+  type: ApplicationCommandType.ChatInput;
+  options?: ApplicationCommandOption[];
+  handler?: never;
+}) | (ApplicationCommandBase & {
+  type: ApplicationCommandType.User | ApplicationCommandType.Message;
+  description: "";
+  options?: never;
+  handler?: never;
+}) | (ApplicationCommandBase & {
+  type: ApplicationCommandType.PrimaryEntryPoint;
+  options?: never;
+  handler?: EntryPointCommandHandlerType;
+});
+type WithPermissionInput<T> = T extends ApplicationCommandCreate ? Omit<T, "default_member_permissions"> & {
+  default_member_permissions?: PermissionInput | null;
+} : never;
+type ApplicationCommandDefinition = WithPermissionInput<ApplicationCommandCreate>;
+interface ApplicationCommandPermission {
+  id: Snowflake;
+  type: ApplicationCommandPermissionType;
+  permission: boolean;
+}
+interface ApplicationCommandPermissions {
+  id: Snowflake;
+  application_id: Snowflake;
+  guild_id: Snowflake;
+  permissions: ApplicationCommandPermission[];
+}
+type ApplicationCommandLocalization = Partial<Record<Locale, string>>;
+//#endregion
+//#region packages/types/src/auto-moderation.d.ts
+declare enum AutoModerationRuleEventType {
+  MessageSend = 1,
+  MemberUpdate = 2
+}
+declare enum AutoModerationRuleTriggerType {
+  Keyword = 1,
+  Spam = 3,
+  KeywordPreset = 4,
+  MentionSpam = 5,
+  MemberProfile = 6
+}
+declare enum AutoModerationKeywordPresetType {
+  Profanity = 1,
+  SexualContent = 2,
+  Slurs = 3
+}
+declare enum AutoModerationActionType {
+  BlockMessage = 1,
+  SendAlertMessage = 2,
+  Timeout = 3,
+  BlockMemberInteraction = 4
+}
+interface AutoModerationRuleTriggerMetadata {
+  keyword_filter?: string[];
+  regex_patterns?: string[];
+  presets?: AutoModerationKeywordPresetType[];
+  allow_list?: string[];
+  mention_total_limit?: number;
+  mention_raid_protection_enabled?: boolean;
+}
+type AutoModerationAction = {
+  type: AutoModerationActionType.BlockMessage;
+  metadata?: {
+    custom_message?: string;
+  };
+} | {
+  type: AutoModerationActionType.SendAlertMessage;
+  metadata: {
+    channel_id: Snowflake;
+  };
+} | {
+  type: AutoModerationActionType.Timeout;
+  metadata: {
+    duration_seconds: number;
+  };
+} | {
+  type: AutoModerationActionType.BlockMemberInteraction;
+  metadata?: never;
+};
+interface AutoModerationRule {
+  id: Snowflake;
+  guild_id: Snowflake;
+  name: string;
+  creator_id: Snowflake;
+  event_type: AutoModerationRuleEventType;
+  trigger_type: AutoModerationRuleTriggerType;
+  trigger_metadata: AutoModerationRuleTriggerMetadata;
+  actions: AutoModerationAction[];
+  enabled: boolean;
+  exempt_roles: Snowflake[];
+  exempt_channels: Snowflake[];
+}
+interface AutoModerationRuleCreate {
+  name: string;
+  event_type: AutoModerationRuleEventType;
+  trigger_type: AutoModerationRuleTriggerType;
+  trigger_metadata?: AutoModerationRuleTriggerMetadata;
+  actions: AutoModerationAction[];
+  enabled?: boolean;
+  exempt_roles?: Snowflake[];
+  exempt_channels?: Snowflake[];
+}
+type AutoModerationRuleModify = Partial<Pick<AutoModerationRule, "name" | "event_type" | "trigger_metadata" | "actions" | "enabled" | "exempt_roles" | "exempt_channels">>;
+//#endregion
+//#region packages/types/src/entitlement.d.ts
+declare enum EntitlementType {
+  Purchase = 1,
+  PremiumSubscription = 2,
+  DeveloperGift = 3,
+  TestModePurchase = 4,
+  FreePurchase = 5,
+  UserGift = 6,
+  PremiumPurchase = 7,
+  ApplicationSubscription = 8
+}
+interface Entitlement {
+  id: Snowflake;
+  sku_id: Snowflake;
+  application_id: Snowflake;
+  user_id?: Snowflake;
+  type: EntitlementType;
+  deleted: boolean;
+  starts_at?: ISO8601Timestamp;
+  ends_at?: ISO8601Timestamp;
+  guild_id?: Snowflake;
+  consumed?: boolean;
+  subscription_id?: Snowflake;
+}
+//#endregion
+//#region packages/types/src/message.d.ts
+declare enum MessageType {
+  Default = 0,
+  RecipientAdd = 1,
+  RecipientRemove = 2,
+  Call = 3,
+  ChannelNameChange = 4,
+  ChannelIconChange = 5,
+  ChannelPinnedMessage = 6,
+  UserJoin = 7,
+  GuildBoost = 8,
+  GuildBoostTier1 = 9,
+  GuildBoostTier2 = 10,
+  GuildBoostTier3 = 11,
+  ChannelFollowAdd = 12,
+  GuildDiscoveryDisqualified = 14,
+  GuildDiscoveryRequalified = 15,
+  GuildDiscoveryGracePeriodInitialWarning = 16,
+  GuildDiscoveryGracePeriodFinalWarning = 17,
+  ThreadCreated = 18,
+  Reply = 19,
+  ChatInputCommand = 20,
+  ThreadStarterMessage = 21,
+  GuildInviteReminder = 22,
+  ContextMenuCommand = 23,
+  AutoModerationAction = 24,
+  RoleSubscriptionPurchase = 25,
+  InteractionPremiumUpsell = 26,
+  StageStart = 27,
+  StageEnd = 28,
+  StageSpeaker = 29,
+  StageTopic = 31,
+  GuildApplicationPremiumSubscription = 32,
+  GuildIncidentAlertModeEnabled = 36,
+  GuildIncidentAlertModeDisabled = 37,
+  GuildIncidentReportRaid = 38,
+  GuildIncidentReportFalseAlarm = 39,
+  PurchaseNotification = 44,
+  PollResult = 46
+}
+declare enum MessageReferenceType {
+  Default = 0,
+  Forward = 1
+}
+declare enum MessageActivityType {
+  Join = 1,
+  Spectate = 2,
+  Listen = 3,
+  JoinRequest = 5
+}
+declare enum ReactionType {
+  Normal = 0,
+  Burst = 1
+}
+declare enum AttachmentFlags {
+  IsClip = 1,
+  IsThumbnail = 2,
+  IsRemix = 4,
+  IsSpoiler = 8,
+  IsAnimated = 32
+}
+declare enum EmbedFlags {
+  IsContentInventoryEntry = 32
+}
+declare enum BaseThemeType {
+  Unset = 0,
+  Dark = 1,
+  Light = 2,
+  Darker = 3,
+  Midnight = 4
+}
+declare enum PollLayoutType {
+  Default = 1
+}
+declare enum MessageFlags {
+  Crossposted = 1,
+  IsCrosspost = 2,
+  SuppressEmbeds = 4,
+  SourceMessageDeleted = 8,
+  Urgent = 16,
+  HasThread = 32,
+  Ephemeral = 64,
+  Loading = 128,
+  FailedToMentionSomeRolesInThread = 256,
+  SuppressNotifications = 4096,
+  IsVoiceMessage = 8192,
+  HasSnapshot = 16384,
+  IsComponentsV2 = 32768
+}
+declare enum ComponentType {
+  ActionRow = 1,
+  Button = 2,
+  StringSelect = 3,
+  TextInput = 4,
+  UserSelect = 5,
+  RoleSelect = 6,
+  MentionableSelect = 7,
+  ChannelSelect = 8,
+  Section = 9,
+  TextDisplay = 10,
+  Thumbnail = 11,
+  MediaGallery = 12,
+  File = 13,
+  Separator = 14,
+  Container = 17,
+  Label = 18,
+  FileUpload = 19,
+  RadioGroup = 21,
+  CheckboxGroup = 22,
+  Checkbox = 23
+}
+declare enum ButtonStyle {
+  Primary = 1,
+  Secondary = 2,
+  Success = 3,
+  Danger = 4,
+  Link = 5,
+  Premium = 6
+}
+declare enum TextInputStyle {
+  Short = 1,
+  Paragraph = 2
+}
+interface EmbedMedia {
+  url: string;
+  proxy_url?: string;
+  height?: number;
+  width?: number;
+  content_type?: string;
+  placeholder?: string;
+  placeholder_version?: number;
+  description?: string;
+  flags?: number;
+}
+interface EmbedVideo extends Omit<EmbedMedia, "url"> {
+  url?: string;
+}
+interface Embed {
+  title?: string;
+  type?: string;
+  description?: string;
+  url?: string;
+  timestamp?: string;
+  color?: number;
+  footer?: {
+    text: string;
+    icon_url?: string;
+    proxy_icon_url?: string;
+  };
+  image?: EmbedMedia;
+  thumbnail?: EmbedMedia;
+  video?: EmbedVideo;
+  provider?: {
+    name?: string;
+    url?: string;
+  };
+  author?: {
+    name: string;
+    url?: string;
+    icon_url?: string;
+    proxy_icon_url?: string;
+  };
+  fields?: Array<{
+    name: string;
+    value: string;
+    inline?: boolean;
+  }>;
+  flags?: number;
+}
+interface Attachment {
+  id: Snowflake;
+  filename: string;
+  title?: string;
+  description?: string;
+  content_type?: string;
+  size: number;
+  url: string;
+  proxy_url: string;
+  height?: number | null;
+  width?: number | null;
+  ephemeral?: boolean;
+  duration_secs?: number;
+  waveform?: string;
+  flags?: number;
+  placeholder?: string;
+  placeholder_version?: number;
+  clip_participants?: User$1[];
+  clip_created_at?: ISO8601Timestamp;
+  application?: Partial<Application> | null;
+}
+interface AttachmentRequest {
+  id: Snowflake | number;
+  filename?: string;
+  title?: string;
+  description?: string;
+  duration_secs?: number;
+  waveform?: string;
+  is_spoiler?: boolean;
+}
+interface ChannelMention {
+  id: Snowflake;
+  guild_id: Snowflake;
+  type: ChannelType;
+  name: string;
+}
+interface Reaction {
+  count: number;
+  count_details: {
+    burst: number;
+    normal: number;
+  };
+  me: boolean;
+  me_burst: boolean;
+  emoji: Pick<Emoji, "id" | "name" | "animated">;
+  burst_colors: string[];
+}
+type AllowedMentionType = "roles" | "users" | "everyone";
+interface AllowedMentions {
+  parse?: readonly AllowedMentionType[];
+  roles?: readonly Snowflake[];
+  users?: readonly Snowflake[];
+  replied_user?: boolean;
+}
+interface MessageReference {
+  type?: MessageReferenceType;
+  message_id?: Snowflake;
+  channel_id?: Snowflake;
+  guild_id?: Snowflake;
+  fail_if_not_exists?: boolean;
+}
+interface MessageActivity {
+  type: MessageActivityType;
+  party_id?: string;
+}
+interface RoleSubscriptionData {
+  role_subscription_listing_id: Snowflake;
+  tier_name: string;
+  total_months_subscribed: number;
+  is_renewal: boolean;
+}
+interface SharedClientTheme {
+  colors: string[];
+  gradient_angle: number;
+  base_mix: number;
+  base_theme?: BaseThemeType | null;
+}
+interface SelectOption {
+  label: string;
+  value: string;
+  description?: string;
+  emoji?: ComponentEmoji;
+  default?: boolean;
+}
+type ComponentEmoji = {
+  id: Snowflake;
+  name?: string;
+  animated?: boolean;
+} | {
+  id?: null;
+  name: string;
+  animated?: boolean;
+};
+interface ComponentBase<T extends ComponentType> {
+  type: T;
+  id?: number;
+}
+interface ButtonComponentBase extends ComponentBase<ComponentType.Button> {
+  label?: string;
+  emoji?: ComponentEmoji;
+  disabled?: boolean;
+}
+type ButtonComponent = (ButtonComponentBase & {
+  style: ButtonStyle.Primary | ButtonStyle.Secondary | ButtonStyle.Success | ButtonStyle.Danger;
+  custom_id: string;
+  sku_id?: never;
+  url?: never;
+}) | (ButtonComponentBase & {
+  style: ButtonStyle.Link;
+  url: string;
+  custom_id?: never;
+  sku_id?: never;
+}) | (Omit<ButtonComponentBase, "emoji" | "label"> & {
+  style: ButtonStyle.Premium;
+  sku_id: Snowflake;
+  custom_id?: never;
+  emoji?: never;
+  label?: never;
+  url?: never;
+});
+interface StringSelectComponent extends ComponentBase<ComponentType.StringSelect> {
+  custom_id: string;
+  options: SelectOption[];
+  placeholder?: string;
+  min_values?: number;
+  max_values?: number;
+  disabled?: boolean;
+  required?: boolean;
+}
+interface AutoSelectComponentBase<T extends ComponentType.UserSelect | ComponentType.RoleSelect | ComponentType.MentionableSelect | ComponentType.ChannelSelect> extends ComponentBase<T> {
+  custom_id: string;
+  placeholder?: string;
+  min_values?: number;
+  max_values?: number;
+  disabled?: boolean;
+  required?: boolean;
+}
+type UserSelectComponent = AutoSelectComponentBase<ComponentType.UserSelect> & {
+  default_values?: Array<{
+    id: Snowflake;
+    type: "user";
+  }>;
+  channel_types?: never;
+};
+type RoleSelectComponent = AutoSelectComponentBase<ComponentType.RoleSelect> & {
+  default_values?: Array<{
+    id: Snowflake;
+    type: "role";
+  }>;
+  channel_types?: never;
+};
+type MentionableSelectComponent = AutoSelectComponentBase<ComponentType.MentionableSelect> & {
+  default_values?: Array<{
+    id: Snowflake;
+    type: "user" | "role";
+  }>;
+  channel_types?: never;
+};
+type ChannelSelectComponent = AutoSelectComponentBase<ComponentType.ChannelSelect> & {
+  default_values?: Array<{
+    id: Snowflake;
+    type: "channel";
+  }>;
+  channel_types?: ChannelType[];
+};
+type AutoSelectComponent = UserSelectComponent | RoleSelectComponent | MentionableSelectComponent | ChannelSelectComponent;
+type MessageStringSelectComponent = Omit<StringSelectComponent, "required"> & {
+  required?: never;
+};
+type ModalStringSelectComponent = Omit<StringSelectComponent, "disabled"> & {
+  disabled?: never;
+};
+type MessageAutoSelectOf<T> = T extends AutoSelectComponent ? Omit<T, "required"> & {
+  required?: never;
+} : never;
+type ModalAutoSelectOf<T> = T extends AutoSelectComponent ? Omit<T, "disabled"> & {
+  disabled?: never;
+} : never;
+type MessageAutoSelectComponent = MessageAutoSelectOf<AutoSelectComponent>;
+type ModalAutoSelectComponent = ModalAutoSelectOf<AutoSelectComponent>;
+interface TextInputComponent extends ComponentBase<ComponentType.TextInput> {
+  custom_id: string;
+  style: TextInputStyle;
+  label?: string;
+  min_length?: number;
+  max_length?: number;
+  required?: boolean;
+  value?: string;
+  placeholder?: string;
+}
+type MessageActionRowComponent = ComponentBase<ComponentType.ActionRow> & ({
+  components: ButtonComponent[];
+} | {
+  components: [MessageStringSelectComponent | MessageAutoSelectComponent];
+});
+type ModalActionRowComponent = ComponentBase<ComponentType.ActionRow> & {
+  components: [TextInputComponent];
+};
+type ActionRowComponent = MessageActionRowComponent | ModalActionRowComponent;
+interface TextDisplayComponent extends ComponentBase<ComponentType.TextDisplay> {
+  content: string;
+}
+interface UnfurledMediaItem {
+  url: string;
+  proxy_url?: string;
+  height?: number | null;
+  width?: number | null;
+  content_type?: string;
+  attachment_id?: Snowflake;
+}
+interface ThumbnailComponent extends ComponentBase<ComponentType.Thumbnail> {
+  media: UnfurledMediaItem;
+  description?: string | null;
+  spoiler?: boolean;
+}
+interface SectionComponent extends ComponentBase<ComponentType.Section> {
+  components: TextDisplayComponent[];
+  accessory: ThumbnailComponent | ButtonComponent;
+}
+interface MediaGalleryComponent extends ComponentBase<ComponentType.MediaGallery> {
+  items: Array<{
+    media: UnfurledMediaItem;
+    description?: string | null;
+    spoiler?: boolean;
+  }>;
+}
+interface FileComponent extends ComponentBase<ComponentType.File> {
+  file: UnfurledMediaItem;
+  spoiler?: boolean;
+  name?: string;
+  size?: number;
+}
+interface SeparatorComponent extends ComponentBase<ComponentType.Separator> {
+  divider?: boolean;
+  spacing?: 1 | 2;
+}
+interface ContainerComponent extends ComponentBase<ComponentType.Container> {
+  components: Array<MessageActionRowComponent | TextDisplayComponent | SectionComponent | MediaGalleryComponent | FileComponent | SeparatorComponent>;
+  accent_color?: number | null;
+  spoiler?: boolean;
+}
+interface LabelComponent extends ComponentBase<ComponentType.Label> {
+  label: string;
+  description?: string;
+  component: ModalStringSelectComponent | ModalAutoSelectComponent | TextInputComponent | FileUploadComponent | RadioGroupComponent | CheckboxGroupComponent | CheckboxComponent;
+}
+interface FileUploadComponent extends ComponentBase<ComponentType.FileUpload> {
+  custom_id: string;
+  min_values?: number;
+  max_values?: number;
+  required?: boolean;
+}
+interface RadioGroupComponent extends ComponentBase<ComponentType.RadioGroup> {
+  custom_id: string;
+  options: RadioGroupOption[];
+  required?: boolean;
+}
+interface RadioGroupOption {
+  value: string;
+  label: string;
+  description?: string;
+  default?: boolean;
+}
+interface CheckboxGroupComponent extends ComponentBase<ComponentType.CheckboxGroup> {
+  custom_id: string;
+  options: CheckboxGroupOption[];
+  min_values?: number;
+  max_values?: number;
+  required?: boolean;
+}
+interface CheckboxGroupOption {
+  value: string;
+  label: string;
+  description?: string;
+  default?: boolean;
+}
+interface CheckboxComponent extends ComponentBase<ComponentType.Checkbox> {
+  custom_id: string;
+  default?: boolean;
+}
+type MessageComponent = MessageActionRowComponent | SectionComponent | TextDisplayComponent | MediaGalleryComponent | FileComponent | SeparatorComponent | ContainerComponent;
+type ModalComponent = ModalActionRowComponent | LabelComponent | TextDisplayComponent;
+interface TextInputInteractionResponse {
+  type: ComponentType.TextInput;
+  id: number;
+  custom_id: string;
+  value: string;
+}
+interface StringSelectInteractionResponse {
+  type: ComponentType.StringSelect;
+  id: number;
+  custom_id: string;
+  values: string[];
+}
+interface AutoSelectInteractionResponse {
+  type: ComponentType.UserSelect | ComponentType.RoleSelect | ComponentType.MentionableSelect | ComponentType.ChannelSelect;
+  id: number;
+  custom_id: string;
+  values: Snowflake[];
+  resolved: ResolvedData;
+}
+interface FileUploadInteractionResponse {
+  type: ComponentType.FileUpload;
+  id: number;
+  custom_id: string;
+  values: Snowflake[];
+}
+interface RadioGroupInteractionResponse {
+  type: ComponentType.RadioGroup;
+  id: number;
+  custom_id: string;
+  value: string | null;
+}
+interface CheckboxGroupInteractionResponse {
+  type: ComponentType.CheckboxGroup;
+  id: number;
+  custom_id: string;
+  values: string[];
+}
+interface CheckboxInteractionResponse {
+  type: ComponentType.Checkbox;
+  id: number;
+  custom_id: string;
+  value: boolean;
+}
+type LabelInteractionResponseChild = TextInputInteractionResponse | StringSelectInteractionResponse | AutoSelectInteractionResponse | FileUploadInteractionResponse | RadioGroupInteractionResponse | CheckboxGroupInteractionResponse | CheckboxInteractionResponse;
+interface LabelInteractionResponse {
+  type: ComponentType.Label;
+  id: number;
+  component: LabelInteractionResponseChild;
+}
+interface TextDisplayInteractionResponse {
+  type: ComponentType.TextDisplay;
+  id: number;
+}
+interface ActionRowInteractionResponse {
+  type: ComponentType.ActionRow;
+  id: number;
+  components: [TextInputInteractionResponse];
+}
+type ModalSubmitComponent = ActionRowInteractionResponse | LabelInteractionResponse | TextDisplayInteractionResponse;
+interface Poll {
+  question: {
+    text: string;
+  };
+  answers: Array<{
+    answer_id: number;
+    poll_media: {
+      text?: string;
+      emoji?: ComponentEmoji;
+    };
+  }>;
+  expiry: ISO8601Timestamp | null;
+  allow_multiselect: boolean;
+  layout_type: PollLayoutType;
+  results?: {
+    is_finalized: boolean;
+    answer_counts: Array<{
+      id: number;
+      count: number;
+      me_voted: boolean;
+    }>;
+  };
+}
+interface PollCreate {
+  question: {
+    text: string;
+  };
+  answers: Array<{
+    poll_media: {
+      text?: string;
+      emoji?: ComponentEmoji;
+    };
+  }>;
+  duration?: number;
+  allow_multiselect?: boolean;
+  layout_type?: PollLayoutType.Default;
+}
+interface MessageInteractionMetadataBase {
+  id: Snowflake;
+  type: InteractionType;
+  user: User$1;
+  authorizing_integration_owners: Record<string, Snowflake>;
+  original_response_message_id?: Snowflake;
+}
+interface ApplicationCommandMessageInteractionMetadata extends MessageInteractionMetadataBase {
+  type: InteractionType.ApplicationCommand;
+  target_user?: User$1;
+  target_message_id?: Snowflake;
+}
+interface MessageComponentMessageInteractionMetadata extends MessageInteractionMetadataBase {
+  type: InteractionType.MessageComponent;
+  interacted_message_id: Snowflake;
+}
+interface ModalSubmitMessageInteractionMetadata extends MessageInteractionMetadataBase {
+  type: InteractionType.ModalSubmit;
+  triggering_interaction_metadata: ApplicationCommandMessageInteractionMetadata | MessageComponentMessageInteractionMetadata;
+}
+type MessageInteractionMetadata = ApplicationCommandMessageInteractionMetadata | MessageComponentMessageInteractionMetadata | ModalSubmitMessageInteractionMetadata;
+interface MessageInteraction {
+  id: Snowflake;
+  type: InteractionType;
+  name: string;
+  user: User$1;
+  member?: Partial<Omit<GuildMember$1, "user">>;
+}
+interface MessageCall {
+  participants: Snowflake[];
+  ended_timestamp?: ISO8601Timestamp | null;
+}
+interface MessageSnapshot {
+  message: Partial<Pick<Message$1, "type" | "content" | "embeds" | "attachments" | "timestamp" | "edited_timestamp" | "flags" | "mentions" | "mention_roles" | "stickers" | "sticker_items" | "components">>;
+}
+interface Message$1 {
+  id: Snowflake;
+  channel_id: Snowflake;
+  guild_id?: Snowflake;
+  author: User$1;
+  member?: GuildMember$1;
+  content: string;
+  timestamp: ISO8601Timestamp;
+  edited_timestamp: ISO8601Timestamp | null;
+  tts: boolean;
+  mention_everyone: boolean;
+  mentions: Array<User$1 & {
+    member?: Omit<GuildMember$1, "user">;
+  }>;
+  mention_roles: Snowflake[];
+  mention_channels?: ChannelMention[];
+  attachments: Attachment[];
+  embeds: Embed[];
+  reactions?: Reaction[];
+  nonce?: string | number;
+  pinned: boolean;
+  webhook_id?: Snowflake;
+  type: MessageType;
+  activity?: MessageActivity;
+  application?: Partial<Application>;
+  application_id?: Snowflake;
+  message_reference?: MessageReference;
+  flags?: number;
+  message_snapshots?: MessageSnapshot[];
+  referenced_message?: Message$1 | null;
+  interaction_metadata?: MessageInteractionMetadata;
+  interaction?: MessageInteraction;
+  thread?: Channel$1;
+  components?: MessageComponent[];
+  sticker_items?: StickerItem[];
+  stickers?: Sticker[];
+  position?: number;
+  role_subscription_data?: RoleSubscriptionData;
+  resolved?: ResolvedData;
+  poll?: Poll;
+  call?: MessageCall;
+  shared_client_theme?: SharedClientTheme;
+  channel_type?: ChannelType;
+}
+interface ResolvedData {
+  users?: Record<Snowflake, User$1>;
+  members?: Record<Snowflake, Omit<GuildMember$1, "user" | "deaf" | "mute">>;
+  roles?: Record<Snowflake, Role$1>;
+  channels?: Record<Snowflake, ResolvedChannel$1>;
+  messages?: Record<Snowflake, Partial<Message$1>>;
+  attachments?: Record<Snowflake, Attachment>;
+}
+type ResolvedChannel$1 = Pick<Channel$1, "id" | "type"> & Partial<Pick<Channel$1, "name" | "permissions" | "app_permissions" | "last_message_id" | "last_pin_timestamp" | "nsfw" | "parent_id" | "guild_id" | "flags" | "rate_limit_per_user" | "topic" | "position" | "thread_metadata">>;
+interface FileUpload {
+  data: Blob | ArrayBuffer | ArrayBufferView;
+  name: string;
+  description?: string;
+}
+interface MessageCreate {
+  content?: string;
+  nonce?: string | number;
+  tts?: boolean;
+  embeds?: Embed[];
+  allowed_mentions?: AllowedMentions;
+  message_reference?: MessageReference;
+  components?: MessageComponent[];
+  sticker_ids?: Snowflake[];
+  files?: FileUpload[];
+  attachments?: AttachmentRequest[];
+  flags?: number;
+  enforce_nonce?: boolean;
+  poll?: PollCreate;
+  shared_client_theme?: SharedClientTheme;
+}
+interface MessageEdit {
+  content?: string | null;
+  embeds?: Embed[] | null;
+  flags?: number;
+  allowed_mentions?: AllowedMentions | null;
+  components?: MessageComponent[] | null;
+  files?: FileUpload[];
+  attachments?: AttachmentRequest[];
+}
+//#endregion
+//#region packages/types/src/interaction.d.ts
+declare enum InteractionType {
+  Ping = 1,
+  ApplicationCommand = 2,
+  MessageComponent = 3,
+  ApplicationCommandAutocomplete = 4,
+  ModalSubmit = 5
+}
+declare enum InteractionCallbackType {
+  Pong = 1,
+  ChannelMessageWithSource = 4,
+  DeferredChannelMessageWithSource = 5,
+  DeferredUpdateMessage = 6,
+  UpdateMessage = 7,
+  ApplicationCommandAutocompleteResult = 8,
+  Modal = 9,
+  PremiumRequired = 10,
+  LaunchActivity = 12
+}
+interface ApplicationCommandInteractionOption {
+  name: string;
+  type: ApplicationCommandOptionType;
+  value?: string | number | boolean;
+  options?: ApplicationCommandInteractionOption[];
+  focused?: boolean;
+}
+interface ApplicationCommandInteractionData {
+  id: Snowflake;
+  name: string;
+  type: ApplicationCommandType;
+  resolved?: ResolvedData;
+  options?: ApplicationCommandInteractionOption[];
+  guild_id?: Snowflake;
+  target_id?: Snowflake;
+}
+type MessageComponentType = ComponentType.Button | ComponentType.StringSelect | ComponentType.UserSelect | ComponentType.RoleSelect | ComponentType.MentionableSelect | ComponentType.ChannelSelect;
+interface MessageComponentInteractionData {
+  custom_id: string;
+  component_type: MessageComponentType;
+  id?: number;
+  values?: string[];
+  resolved?: ResolvedData;
+}
+interface ModalSubmitInteractionData {
+  custom_id: string;
+  components: ModalSubmitComponent[];
+  resolved?: ResolvedData;
+}
+type InteractionData = ApplicationCommandInteractionData | MessageComponentInteractionData | ModalSubmitInteractionData;
+/** An interaction received from the gateway or an HTTP endpoint. */
+interface InteractionBase {
+  id: Snowflake;
+  application_id: Snowflake;
+  guild?: {
+    id: Snowflake;
+    locale?: Locale;
+    features?: string[];
+  };
+  guild_id?: Snowflake;
+  channel?: ResolvedChannel$1;
+  channel_id?: Snowflake;
+  member?: GuildMember$1;
+  user?: User$1;
+  token: string;
+  version: 1;
+  message?: Message$1;
+  app_permissions?: BitfieldString;
+  locale?: Locale;
+  guild_locale?: Locale;
+  entitlements: Entitlement[];
+  authorizing_integration_owners: Partial<Record<`${ApplicationIntegrationType}`, Snowflake>>;
+  context?: InteractionContextType;
+  attachment_size_limit: number;
+}
+interface InteractionResponseData extends Pick<MessageCreate, "tts" | "content" | "embeds" | "allowed_mentions" | "flags" | "attachments" | "poll"> {
+  components?: MessageCreate["components"];
+  files?: MessageCreate["files"];
+}
+interface AutocompleteInteractionResponseData {
+  choices: ApplicationCommandChoice[];
+}
+interface ModalInteractionResponseData {
+  custom_id: string;
+  title: string;
+  components: ModalComponent[];
+}
+type InteractionResponse = {
+  type: InteractionCallbackType.Pong | InteractionCallbackType.DeferredUpdateMessage | InteractionCallbackType.PremiumRequired | InteractionCallbackType.LaunchActivity;
+  data?: never;
+} | {
+  type: InteractionCallbackType.ChannelMessageWithSource | InteractionCallbackType.UpdateMessage;
+  data?: InteractionResponseData;
+} | {
+  type: InteractionCallbackType.DeferredChannelMessageWithSource;
+  data?: Pick<InteractionResponseData, "flags">;
+} | {
+  type: InteractionCallbackType.ApplicationCommandAutocompleteResult;
+  data: AutocompleteInteractionResponseData;
+} | {
+  type: InteractionCallbackType.Modal;
+  data: ModalInteractionResponseData;
+};
+interface InteractionCallback {
+  id: Snowflake;
+  type: InteractionType;
+  activity_instance_id?: string;
+  response_message_id?: Snowflake;
+  response_message_loading?: boolean;
+  response_message_ephemeral?: boolean;
+}
+interface InteractionCallbackResource {
+  type: InteractionCallbackType;
+  activity_instance?: {
+    id: string;
+  };
+  message?: Message$1;
+}
+interface InteractionCallbackResponse {
+  interaction: InteractionCallback;
+  resource?: InteractionCallbackResource;
+}
+type PingInteraction = InteractionBase & {
+  type: InteractionType.Ping;
+  data?: never;
+};
+type ApplicationCommandInteraction = InteractionBase & {
+  type: InteractionType.ApplicationCommand;
+  data: ApplicationCommandInteractionData;
+};
+type AutocompleteInteraction = InteractionBase & {
+  type: InteractionType.ApplicationCommandAutocomplete;
+  data: ApplicationCommandInteractionData;
+};
+type MessageComponentInteraction = InteractionBase & {
+  type: InteractionType.MessageComponent;
+  data: MessageComponentInteractionData;
+};
+type ModalSubmitInteraction = InteractionBase & {
+  type: InteractionType.ModalSubmit;
+  data: ModalSubmitInteractionData;
+};
+type Interaction$1 = PingInteraction | ApplicationCommandInteraction | AutocompleteInteraction | MessageComponentInteraction | ModalSubmitInteraction;
+//#endregion
+//#region packages/types/src/scheduled-event.d.ts
+declare enum GuildScheduledEventPrivacyLevel {
+  GuildOnly = 2
+}
+declare enum GuildScheduledEventEntityType {
+  StageInstance = 1,
+  Voice = 2,
+  External = 3
+}
+declare enum GuildScheduledEventStatus {
+  Scheduled = 1,
+  Active = 2,
+  Completed = 3,
+  Canceled = 4
+}
+declare enum GuildScheduledEventRecurrenceFrequency {
+  Yearly = 0,
+  Monthly = 1,
+  Weekly = 2,
+  Daily = 3
+}
+declare enum GuildScheduledEventRecurrenceWeekday {
+  Monday = 0,
+  Tuesday = 1,
+  Wednesday = 2,
+  Thursday = 3,
+  Friday = 4,
+  Saturday = 5,
+  Sunday = 6
+}
+declare enum GuildScheduledEventRecurrenceMonth {
+  January = 1,
+  February = 2,
+  March = 3,
+  April = 4,
+  May = 5,
+  June = 6,
+  July = 7,
+  August = 8,
+  September = 9,
+  October = 10,
+  November = 11,
+  December = 12
+}
+interface GuildScheduledEventRecurrenceNWeekday {
+  n: number;
+  day: GuildScheduledEventRecurrenceWeekday;
+}
+interface GuildScheduledEventRecurrenceRule {
+  start: ISO8601Timestamp;
+  end: ISO8601Timestamp | null;
+  frequency: GuildScheduledEventRecurrenceFrequency;
+  interval: number;
+  by_weekday: GuildScheduledEventRecurrenceWeekday[] | null;
+  by_n_weekday: GuildScheduledEventRecurrenceNWeekday[] | null;
+  by_month: GuildScheduledEventRecurrenceMonth[] | null;
+  by_month_day: number[] | null;
+  by_year_day: number[] | null;
+  count: number | null;
+}
+interface GuildScheduledEventRecurrenceRuleCreate {
+  start: ISO8601Timestamp;
+  frequency: GuildScheduledEventRecurrenceFrequency;
+  interval: number;
+  by_weekday?: GuildScheduledEventRecurrenceWeekday[];
+  by_n_weekday?: GuildScheduledEventRecurrenceNWeekday[];
+  by_month?: GuildScheduledEventRecurrenceMonth[];
+  by_month_day?: number[];
+}
+interface GuildScheduledEventBase {
+  id: Snowflake;
+  guild_id: Snowflake;
+  creator_id?: Snowflake | null;
+  name: string;
+  description?: string | null;
+  scheduled_start_time: ISO8601Timestamp;
+  privacy_level: GuildScheduledEventPrivacyLevel;
+  status: GuildScheduledEventStatus;
+  entity_id: Snowflake | null;
+  creator?: User$1;
+  user_count?: number;
+  image?: string | null;
+  recurrence_rule: GuildScheduledEventRecurrenceRule | null;
+}
+type GuildScheduledEvent = (GuildScheduledEventBase & {
+  entity_type: GuildScheduledEventEntityType.StageInstance | GuildScheduledEventEntityType.Voice;
+  channel_id: Snowflake;
+  entity_metadata: null;
+  scheduled_end_time: ISO8601Timestamp | null;
+}) | (GuildScheduledEventBase & {
+  entity_type: GuildScheduledEventEntityType.External;
+  channel_id: null;
+  entity_metadata: {
+    location: string;
+  };
+  scheduled_end_time: ISO8601Timestamp;
+});
+interface GuildScheduledEventCreateBase {
+  name: string;
+  privacy_level: GuildScheduledEventPrivacyLevel;
+  scheduled_start_time: ISO8601Timestamp;
+  description?: string;
+  image?: string;
+  recurrence_rule?: GuildScheduledEventRecurrenceRuleCreate;
+}
+type GuildScheduledEventCreate = (GuildScheduledEventCreateBase & {
+  entity_type: GuildScheduledEventEntityType.StageInstance | GuildScheduledEventEntityType.Voice;
+  channel_id: Snowflake;
+  entity_metadata?: never;
+  scheduled_end_time?: ISO8601Timestamp;
+}) | (GuildScheduledEventCreateBase & {
+  entity_type: GuildScheduledEventEntityType.External;
+  channel_id?: null;
+  entity_metadata: {
+    location: string;
+  };
+  scheduled_end_time: ISO8601Timestamp;
+});
+interface GuildScheduledEventModify {
+  channel_id?: Snowflake | null;
+  entity_metadata?: {
+    location?: string;
+  } | null;
+  name?: string;
+  privacy_level?: GuildScheduledEventPrivacyLevel;
+  scheduled_start_time?: ISO8601Timestamp;
+  scheduled_end_time?: ISO8601Timestamp;
+  description?: string | null;
+  entity_type?: GuildScheduledEventEntityType;
+  status?: GuildScheduledEventStatus;
+  image?: string | null;
+  recurrence_rule?: GuildScheduledEventRecurrenceRuleCreate | null;
+}
+interface GuildScheduledEventUser {
+  guild_scheduled_event_id: Snowflake;
+  user: User$1;
+  member?: GuildMember$1;
+}
+interface GuildScheduledEventUserEvent {
+  guild_scheduled_event_id: Snowflake;
+  user_id: Snowflake;
+  guild_id: Snowflake;
+}
+//#endregion
+//#region packages/types/src/invite.d.ts
+declare enum InviteType {
+  Guild = 0,
+  GroupDM = 1,
+  Friend = 2
+}
+declare enum InviteTargetType {
+  Stream = 1,
+  EmbeddedApplication = 2
+}
+declare enum InviteFlags {
+  IsGuestInvite = 1
+}
+type InviteGuild = Pick<Guild$1, "id" | "name" | "icon" | "splash" | "banner" | "description" | "features" | "verification_level" | "vanity_url_code" | "nsfw_level" | "premium_subscription_count">;
+interface InviteChannel {
+  id: Snowflake;
+  name: string | null;
+  type: ChannelType;
+}
+type InviteTargetApplication = Pick<Application, "id" | "name" | "icon" | "description">;
+type InviteRole = Pick<Role$1, "id" | "name" | "position" | "color" | "colors" | "icon" | "unicode_emoji">;
+interface Invite {
+  type: InviteType;
+  code: string;
+  guild?: InviteGuild;
+  channel?: InviteChannel | null;
+  inviter?: User$1;
+  target_type?: InviteTargetType;
+  target_user?: User$1;
+  target_application?: InviteTargetApplication;
+  approximate_presence_count?: number;
+  approximate_member_count?: number;
+  expires_at?: ISO8601Timestamp | null;
+  guild_scheduled_event?: GuildScheduledEvent;
+  flags?: number;
+  roles?: InviteRole[];
+}
+interface InviteMetadata {
+  uses: number;
+  max_uses: number;
+  max_age: number;
+  temporary: boolean;
+  created_at: ISO8601Timestamp;
+}
+type InviteWithMetadata = Invite & InviteMetadata;
+interface InviteCreateEvent extends InviteMetadata {
+  channel_id: Snowflake;
+  code: string;
+  guild_id?: Snowflake;
+  inviter?: User$1;
+  target_type?: InviteTargetType;
+  target_user?: User$1;
+  target_application?: InviteTargetApplication;
+  expires_at?: ISO8601Timestamp | null;
+  role_ids?: Snowflake[];
+}
+interface InviteDeleteEvent {
+  channel_id: Snowflake;
+  guild_id?: Snowflake;
+  code: string;
+}
+//#endregion
+//#region packages/types/src/subscription.d.ts
+declare enum SubscriptionStatus {
+  Active = 0,
+  Inactive = 1,
+  Ending = 2
+}
+interface Subscription {
+  id: Snowflake;
+  user_id: Snowflake;
+  sku_ids: Snowflake[];
+  entitlement_ids: Snowflake[];
+  renewal_sku_ids: Snowflake[] | null;
+  current_period_start: ISO8601Timestamp;
+  current_period_end: ISO8601Timestamp;
+  status: SubscriptionStatus;
+  canceled_at: ISO8601Timestamp | null;
+  country?: string;
+}
+//#endregion
+//#region packages/types/src/gateway.d.ts
+declare enum ActivityType$1 {
+  Playing = 0,
+  Streaming = 1,
+  Listening = 2,
+  Watching = 3,
+  Custom = 4,
+  Competing = 5
+}
+declare enum ActivityStatusDisplayType {
+  Name = 0,
+  State = 1,
+  Details = 2
+}
+type PresenceStatus = "idle" | "dnd" | "online" | "offline";
+interface ActivityEmoji {
+  name: string;
+  id?: Snowflake;
+  animated?: boolean;
+}
+interface Activity {
+  name: string;
+  type: ActivityType$1;
+  url?: string | null;
+  created_at: number;
+  timestamps?: {
+    start?: number;
+    end?: number;
+  };
+  application_id?: Snowflake;
+  status_display_type?: ActivityStatusDisplayType | null;
+  details?: string | null;
+  details_url?: string | null;
+  state?: string | null;
+  state_url?: string | null;
+  emoji?: ActivityEmoji | null;
+  party?: {
+    id?: string;
+    size?: [currentSize: number, maxSize: number];
+  };
+  assets?: {
+    large_image?: string;
+    large_text?: string;
+    large_url?: string;
+    small_image?: string;
+    small_text?: string;
+    small_url?: string;
+    invite_cover_image?: string;
+  };
+  secrets?: {
+    join?: string;
+    spectate?: string;
+    match?: string;
+  };
+  instance?: boolean;
+  flags?: number;
+  buttons?: string[];
+}
+interface ReadyEvent {
+  v: number;
+  user: User$1;
+  guilds: UnavailableGuild[];
+  session_id: string;
+  resume_gateway_url: string;
+  shard?: [shardId: number, shardCount: number];
+  application: {
+    id: Snowflake;
+    flags: number;
+  };
+}
+interface ResumedEvent {
+  _trace?: string[];
+}
+type GuildCreateEvent = (Guild$1 & {
+  joined_at: ISO8601Timestamp;
+  large: boolean;
+  unavailable?: false;
+  member_count: number;
+  members: GuildMember$1[];
+  channels: Channel$1[];
+  threads: Channel$1[];
+  guild_scheduled_events: GuildScheduledEvent[];
+  presences: Array<Omit<PresenceUpdateEvent, "guild_id">>;
+}) | UnavailableGuild;
+interface GuildUpdateEvent extends Guild$1 {}
+interface GuildDeleteEvent {
+  id: Snowflake;
+  unavailable?: boolean;
+}
+interface ChannelCreateEvent extends Channel$1 {}
+interface ChannelUpdateEvent extends Channel$1 {}
+interface ChannelDeleteEvent extends Channel$1 {}
+interface ThreadCreateEvent extends Channel$1 {
+  newly_created?: boolean;
+}
+interface ThreadDeleteEvent {
+  id: Snowflake;
+  guild_id: Snowflake;
+  parent_id: Snowflake;
+  type: ChannelType;
+}
+interface ThreadListSyncEvent {
+  guild_id: Snowflake;
+  channel_ids?: Snowflake[];
+  threads: Channel$1[];
+  members: ThreadMember[];
+}
+interface ThreadMemberUpdateEvent extends ThreadMember {
+  guild_id: Snowflake;
+}
+interface ThreadMembersUpdateEvent {
+  id: Snowflake;
+  guild_id: Snowflake;
+  member_count: number;
+  added_members?: Array<ThreadMember & {
+    member: GuildMember$1;
+    presence: PresenceUpdateEvent | null;
+  }>;
+  removed_member_ids?: Snowflake[];
+}
+interface ChannelPinsUpdateEvent {
+  guild_id?: Snowflake;
+  channel_id: Snowflake;
+  last_pin_timestamp?: ISO8601Timestamp | null;
+}
+interface MessageCreateEvent extends Message$1 {}
+type MessageUpdateEvent = Partial<Message$1> & Pick<Message$1, "id" | "channel_id">;
+interface MessageDeleteEvent {
+  id: Snowflake;
+  channel_id: Snowflake;
+  guild_id?: Snowflake;
+}
+interface MessageDeleteBulkEvent {
+  ids: Snowflake[];
+  channel_id: Snowflake;
+  guild_id?: Snowflake;
+}
+interface MessageReactionAddEvent {
+  user_id: Snowflake;
+  channel_id: Snowflake;
+  message_id: Snowflake;
+  guild_id?: Snowflake;
+  member?: GuildMember$1;
+  emoji: PartialEmoji;
+  message_author_id?: Snowflake;
+  burst: boolean;
+  burst_colors?: string[];
+  type: ReactionType;
+}
+interface MessageReactionRemoveEvent {
+  user_id: Snowflake;
+  channel_id: Snowflake;
+  message_id: Snowflake;
+  guild_id?: Snowflake;
+  emoji: PartialEmoji;
+  burst: boolean;
+  type: ReactionType;
+}
+interface MessageReactionRemoveAllEvent {
+  channel_id: Snowflake;
+  message_id: Snowflake;
+  guild_id?: Snowflake;
+}
+interface MessageReactionRemoveEmojiEvent extends MessageReactionRemoveAllEvent {
+  emoji: PartialEmoji;
+}
+interface MessagePollVoteEvent {
+  user_id: Snowflake;
+  channel_id: Snowflake;
+  message_id: Snowflake;
+  guild_id?: Snowflake;
+  answer_id: number;
+}
+interface GuildMemberAddEvent extends GuildMember$1 {
+  guild_id: Snowflake;
+  user: User$1;
+}
+interface GuildMemberUpdateEvent {
+  guild_id: Snowflake;
+  roles: Snowflake[];
+  user: User$1;
+  nick?: string | null;
+  avatar: string | null;
+  banner: string | null;
+  joined_at: ISO8601Timestamp | null;
+  premium_since?: ISO8601Timestamp | null;
+  deaf?: boolean;
+  mute?: boolean;
+  pending?: boolean;
+  communication_disabled_until?: ISO8601Timestamp | null;
+  avatar_decoration_data?: AvatarDecorationData | null;
+  collectibles?: Collectibles | null;
+}
+interface GuildMemberRemoveEvent {
+  guild_id: Snowflake;
+  user: User$1;
+}
+interface GuildMembersChunkEvent {
+  guild_id: Snowflake;
+  members: GuildMember$1[];
+  chunk_index: number;
+  chunk_count: number;
+  not_found?: Snowflake[];
+  presences?: PresenceUpdateEvent[];
+  nonce?: string;
+}
+interface GuildRoleEvent {
+  guild_id: Snowflake;
+  role: Role$1;
+}
+interface GuildRoleDeleteEvent {
+  guild_id: Snowflake;
+  role_id: Snowflake;
+}
+interface GuildBanEvent {
+  guild_id: Snowflake;
+  user: User$1;
+}
+interface GuildEmojisUpdateEvent {
+  guild_id: Snowflake;
+  emojis: Emoji[];
+}
+interface GuildStickersUpdateEvent {
+  guild_id: Snowflake;
+  stickers: Sticker[];
+}
+interface GuildIntegrationsUpdateEvent {
+  guild_id: Snowflake;
+}
+interface PresenceUpdateEvent {
+  user: PartialUser;
+  guild_id: Snowflake;
+  status: PresenceStatus;
+  activities: Activity[];
+  client_status: {
+    desktop?: Exclude<PresenceStatus, "offline">;
+    mobile?: Exclude<PresenceStatus, "offline">;
+    web?: Exclude<PresenceStatus, "offline">;
+  };
+}
+interface TypingStartEvent {
+  channel_id: Snowflake;
+  guild_id?: Snowflake;
+  user_id: Snowflake;
+  timestamp: number;
+  member?: GuildMember$1;
+}
+interface WebhooksUpdateEvent {
+  guild_id: Snowflake;
+  channel_id: Snowflake;
+}
+interface AutoModerationActionExecutionEvent {
+  guild_id: Snowflake;
+  action: AutoModerationAction;
+  rule_id: Snowflake;
+  rule_trigger_type: AutoModerationRuleTriggerType;
+  user_id: Snowflake;
+  channel_id?: Snowflake;
+  message_id?: Snowflake;
+  alert_system_message_id?: Snowflake;
+  content: string;
+  matched_keyword?: string;
+  matched_content: string | null;
+}
+interface GatewayRequestGuildMembersRateLimitMetadata {
+  guild_id: Snowflake;
+  nonce?: string;
+}
+interface GatewayRateLimitedEvent {
+  opcode: number;
+  retry_after: number;
+  meta: GatewayRequestGuildMembersRateLimitMetadata;
+}
+type InteractionCreateEvent = Interaction$1;
+interface GatewayDispatchMap {
+  READY: ReadyEvent;
+  RESUMED: ResumedEvent;
+  APPLICATION_COMMAND_PERMISSIONS_UPDATE: ApplicationCommandPermissions;
+  AUTO_MODERATION_RULE_CREATE: AutoModerationRule;
+  AUTO_MODERATION_RULE_UPDATE: AutoModerationRule;
+  AUTO_MODERATION_RULE_DELETE: AutoModerationRule;
+  AUTO_MODERATION_ACTION_EXECUTION: AutoModerationActionExecutionEvent;
+  CHANNEL_CREATE: ChannelCreateEvent;
+  CHANNEL_UPDATE: ChannelUpdateEvent;
+  CHANNEL_DELETE: ChannelDeleteEvent;
+  CHANNEL_PINS_UPDATE: ChannelPinsUpdateEvent;
+  ENTITLEMENT_CREATE: Entitlement;
+  ENTITLEMENT_UPDATE: Entitlement;
+  ENTITLEMENT_DELETE: Entitlement;
+  GUILD_CREATE: GuildCreateEvent;
+  GUILD_UPDATE: GuildUpdateEvent;
+  GUILD_DELETE: GuildDeleteEvent;
+  GUILD_BAN_ADD: GuildBanEvent;
+  GUILD_BAN_REMOVE: GuildBanEvent;
+  GUILD_EMOJIS_UPDATE: GuildEmojisUpdateEvent;
+  GUILD_STICKERS_UPDATE: GuildStickersUpdateEvent;
+  GUILD_INTEGRATIONS_UPDATE: GuildIntegrationsUpdateEvent;
+  GUILD_MEMBER_ADD: GuildMemberAddEvent;
+  GUILD_MEMBER_UPDATE: GuildMemberUpdateEvent;
+  GUILD_MEMBER_REMOVE: GuildMemberRemoveEvent;
+  GUILD_MEMBERS_CHUNK: GuildMembersChunkEvent;
+  GUILD_ROLE_CREATE: GuildRoleEvent;
+  GUILD_ROLE_UPDATE: GuildRoleEvent;
+  GUILD_ROLE_DELETE: GuildRoleDeleteEvent;
+  GUILD_SCHEDULED_EVENT_CREATE: GuildScheduledEvent;
+  GUILD_SCHEDULED_EVENT_UPDATE: GuildScheduledEvent;
+  GUILD_SCHEDULED_EVENT_DELETE: GuildScheduledEvent;
+  GUILD_SCHEDULED_EVENT_USER_ADD: GuildScheduledEventUserEvent;
+  GUILD_SCHEDULED_EVENT_USER_REMOVE: GuildScheduledEventUserEvent;
+  INVITE_CREATE: InviteCreateEvent;
+  INVITE_DELETE: InviteDeleteEvent;
+  THREAD_CREATE: ThreadCreateEvent;
+  THREAD_UPDATE: ChannelUpdateEvent;
+  THREAD_DELETE: ThreadDeleteEvent;
+  THREAD_LIST_SYNC: ThreadListSyncEvent;
+  THREAD_MEMBER_UPDATE: ThreadMemberUpdateEvent;
+  THREAD_MEMBERS_UPDATE: ThreadMembersUpdateEvent;
+  MESSAGE_CREATE: MessageCreateEvent;
+  MESSAGE_UPDATE: MessageUpdateEvent;
+  MESSAGE_DELETE: MessageDeleteEvent;
+  MESSAGE_DELETE_BULK: MessageDeleteBulkEvent;
+  MESSAGE_REACTION_ADD: MessageReactionAddEvent;
+  MESSAGE_REACTION_REMOVE: MessageReactionRemoveEvent;
+  MESSAGE_REACTION_REMOVE_ALL: MessageReactionRemoveAllEvent;
+  MESSAGE_REACTION_REMOVE_EMOJI: MessageReactionRemoveEmojiEvent;
+  MESSAGE_POLL_VOTE_ADD: MessagePollVoteEvent;
+  MESSAGE_POLL_VOTE_REMOVE: MessagePollVoteEvent;
+  PRESENCE_UPDATE: PresenceUpdateEvent;
+  TYPING_START: TypingStartEvent;
+  USER_UPDATE: User$1;
+  WEBHOOKS_UPDATE: WebhooksUpdateEvent;
+  INTERACTION_CREATE: InteractionCreateEvent;
+  SUBSCRIPTION_CREATE: Subscription;
+  SUBSCRIPTION_UPDATE: Subscription;
+  SUBSCRIPTION_DELETE: Subscription;
+}
+type GatewayDispatchName = keyof GatewayDispatchMap;
+declare namespace index_d_exports {
+  export { ActionRowComponent, ActionRowInteractionResponse, Activity, ActivityEmoji, ActivityStatusDisplayType, ActivityType$1 as ActivityType, AllowedMentionType, AllowedMentions, Application, ApplicationCommand, ApplicationCommandBase, ApplicationCommandBasicOption, ApplicationCommandChannelOption, ApplicationCommandChoice, ApplicationCommandCreate, ApplicationCommandCreateBase, ApplicationCommandDefinition, ApplicationCommandInteraction, ApplicationCommandInteractionData, ApplicationCommandInteractionOption, ApplicationCommandLocalization, ApplicationCommandMessageInteractionMetadata, ApplicationCommandNumericOption, ApplicationCommandOption, ApplicationCommandOptionBase, ApplicationCommandOptionType, ApplicationCommandPermission, ApplicationCommandPermissionType, ApplicationCommandPermissions, ApplicationCommandSimpleOption, ApplicationCommandStringOption, ApplicationCommandSubcommandGroupOption, ApplicationCommandSubcommandOption, ApplicationCommandType, ApplicationIntegrationType, ApplicationIntegrationTypeConfiguration, Attachment, AttachmentFlags, AttachmentRequest, AutoModerationAction, AutoModerationActionExecutionEvent, AutoModerationActionType, AutoModerationKeywordPresetType, AutoModerationRule, AutoModerationRuleCreate, AutoModerationRuleEventType, AutoModerationRuleModify, AutoModerationRuleTriggerMetadata, AutoModerationRuleTriggerType, AutoSelectComponent, AutoSelectComponentBase, AutoSelectInteractionResponse, AutocompleteInteraction, AutocompleteInteractionResponseData, AvatarDecorationData, Awaitable$1 as Awaitable, BaseThemeType, BitfieldString, ButtonComponent, ButtonComponentBase, ButtonStyle, Channel$1 as Channel, ChannelCreateEvent, ChannelDeleteEvent, ChannelFlags, ChannelMention, ChannelPinsUpdateEvent, ChannelSelectComponent, ChannelType, ChannelUpdateEvent, ChatInputApplicationCommandCreate, CheckboxComponent, CheckboxGroupComponent, CheckboxGroupInteractionResponse, CheckboxGroupOption, CheckboxInteractionResponse, Collectibles, ComponentBase, ComponentEmoji, ComponentType, ContainerComponent, ContextMenuApplicationCommandCreate, DefaultReaction, Embed, EmbedFlags, EmbedMedia, EmbedVideo, Emoji, Entitlement, EntitlementType, EntryPointCommandHandlerType, FileComponent, FileUpload, FileUploadComponent, FileUploadInteractionResponse, ForumLayoutType, ForumTag, GatewayDispatchMap, GatewayDispatchName, GatewayRateLimitedEvent, GatewayRequestGuildMembersRateLimitMetadata, Guild$1 as Guild, GuildBan, GuildBanEvent, GuildCreateEvent, GuildDefaultMessageNotificationLevel, GuildDeleteEvent, GuildEmojisUpdateEvent, GuildExplicitContentFilterLevel, GuildIncidentsData, GuildIntegrationsUpdateEvent, GuildMFALevel, GuildMember$1 as GuildMember, GuildMemberAddEvent, GuildMemberFlags, GuildMemberRemoveEvent, GuildMemberUpdateEvent, GuildMembersChunkEvent, GuildNSFWLevel, GuildPremiumTier, GuildRoleDeleteEvent, GuildRoleEvent, GuildScheduledEvent, GuildScheduledEventCreate, GuildScheduledEventEntityType, GuildScheduledEventModify, GuildScheduledEventPrivacyLevel, GuildScheduledEventRecurrenceFrequency, GuildScheduledEventRecurrenceMonth, GuildScheduledEventRecurrenceNWeekday, GuildScheduledEventRecurrenceRule, GuildScheduledEventRecurrenceRuleCreate, GuildScheduledEventRecurrenceWeekday, GuildScheduledEventStatus, GuildScheduledEventUser, GuildScheduledEventUserEvent, GuildStickersUpdateEvent, GuildUpdateEvent, GuildVerificationLevel, ISO8601Timestamp, InstallParams, Interaction$1 as Interaction, InteractionBase, InteractionCallback, InteractionCallbackResource, InteractionCallbackResponse, InteractionCallbackType, InteractionContextType, InteractionCreateEvent, InteractionData, InteractionResponse, InteractionResponseData, InteractionType, Invite, InviteChannel, InviteCreateEvent, InviteDeleteEvent, InviteFlags, InviteGuild, InviteMetadata, InviteRole, InviteTargetApplication, InviteTargetType, InviteType, InviteWithMetadata, JsonPrimitive, JsonValue, LabelComponent, LabelInteractionResponse, LabelInteractionResponseChild, Locale, Localizations, MediaGalleryComponent, MentionableSelectComponent, Message$1 as Message, MessageActionRowComponent, MessageActivity, MessageActivityType, MessageAutoSelectComponent, MessageCall, MessageComponent, MessageComponentInteraction, MessageComponentInteractionData, MessageComponentMessageInteractionMetadata, MessageComponentType, MessageCreate, MessageCreateEvent, MessageDeleteBulkEvent, MessageDeleteEvent, MessageEdit, MessageFlags, MessageInteraction, MessageInteractionMetadata, MessageInteractionMetadataBase, MessagePollVoteEvent, MessageReactionAddEvent, MessageReactionRemoveAllEvent, MessageReactionRemoveEmojiEvent, MessageReactionRemoveEvent, MessageReference, MessageReferenceType, MessageSnapshot, MessageStringSelectComponent, MessageType, MessageUpdateEvent, ModalActionRowComponent, ModalAutoSelectComponent, ModalComponent, ModalInteractionResponseData, ModalStringSelectComponent, ModalSubmitComponent, ModalSubmitInteraction, ModalSubmitInteractionData, ModalSubmitMessageInteractionMetadata, Nameplate, NameplatePalette, OverwriteType, PartialEmoji, PartialGuild, PartialUser, PermissionFlag, PermissionFlagName, PermissionFlags, PermissionInput, PermissionOverwrite, PingInteraction, Poll, PollCreate, PollLayoutType, PremiumType, PresenceStatus, PresenceUpdateEvent, PrimaryEntryPointApplicationCommandCreate, RadioGroupComponent, RadioGroupInteractionResponse, RadioGroupOption, Reaction, ReactionType, ReadyEvent, ResolvedChannel$1 as ResolvedChannel, ResolvedData, ResumedEvent, Role$1 as Role, RoleColors, RoleFlags, RoleSelectComponent, RoleSubscriptionData, RoleTags, SectionComponent, SelectOption, SeparatorComponent, SharedClientTheme, Snowflake, SortOrderType, Sticker, StickerFormatType, StickerItem, StickerPack, StickerType, StringSelectComponent, StringSelectInteractionResponse, Subscription, SubscriptionStatus, SystemChannelFlags, Team, TeamMember, TextDisplayComponent, TextDisplayInteractionResponse, TextInputComponent, TextInputInteractionResponse, TextInputStyle, ThreadAutoArchiveDuration, ThreadCreateEvent, ThreadDeleteEvent, ThreadListSyncEvent, ThreadMember, ThreadMemberUpdateEvent, ThreadMembersUpdateEvent, ThreadMetadata, ThumbnailComponent, TypingStartEvent, UnavailableGuild, UnfurledMediaItem, User$1 as User, UserFlags, UserPrimaryGuild, UserSelectComponent, VideoQualityMode, WebhooksUpdateEvent, WelcomeScreen, WelcomeScreenChannel, can, canAny, missing, toFlagNames, toPermissionBits };
+}
+//#endregion
+//#region packages/helpers/src/templates.d.ts
+/**
+ * Content templates. Three verbs: define (code only, one object of plain
+ * fill-to-payload functions), invoke with fills, override (third argument;
+ * an override key replaces that key entirely, with no deep merge).
+ */
+type TemplateMap<P> = Record<string, (fills: any) => P>;
+type FillsOf<F> = F extends ((fills: infer P) => unknown) ? P : never;
+/** A callable template registry for one content domain. */
+interface TemplateRegistry<P, T extends TemplateMap<P> = TemplateMap<P>> {
+  <K extends keyof T & string>(name: K, fills: FillsOf<T[K]>, override?: Partial<P>): P;
+  /** The template names this registry defines. */
+  readonly names: readonly (keyof T & string)[];
+}
+//#endregion
+//#region packages/helpers/src/index.d.ts
+type EmbedTemplates = TemplateMap<Embed>;
+type ComponentTemplates = TemplateMap<MessageComponent>;
+/** Modal templates omit custom_id; listener fields derive the wire id. */
+type ModalTemplatePayload = Omit<ModalInteractionResponseData, "custom_id"> & {
+  custom_id?: string;
+};
+type ModalTemplates = TemplateMap<ModalTemplatePayload>;
+type EmbedRegistry<T extends EmbedTemplates = EmbedTemplates> = TemplateRegistry<Embed, T>;
+type ComponentRegistry<T extends ComponentTemplates = ComponentTemplates> = TemplateRegistry<MessageComponent, T>;
+type ModalRegistry<T extends ModalTemplates = ModalTemplates> = TemplateRegistry<ModalTemplatePayload, T>;
+/** Defines embed templates; keys are the template names. */
+declare function defineEmbeds<T extends EmbedTemplates>(templates: T): EmbedRegistry<T>;
+/** Defines component templates; keys are the template names. */
+declare function defineComponents<T extends ComponentTemplates>(templates: T): ComponentRegistry<T>;
+/** Defines modal templates; keys are the template names. */
+declare function defineModals<T extends ModalTemplates>(templates: T): ModalRegistry<T>;
+/** Wires an embed registry onto the client as `client.embeds(...)`. */
+declare function embedTemplates<T extends EmbedTemplates>(templates: T | EmbedRegistry<T>): EuniaModule;
+/** Wires a component registry onto the client as `client.components(...)`. */
+declare function componentTemplates<T extends ComponentTemplates>(templates: T | ComponentRegistry<T>): EuniaModule;
+/** Wires a modal registry onto the client as `client.modals(...)`. */
+declare function modalTemplates<T extends ModalTemplates>(templates: T | ModalRegistry<T>): EuniaModule;
+//#endregion
+//#region packages/commands/src/cooldown.d.ts
+interface CooldownRequest {
+  readonly key: string;
+  readonly limit: number;
+  readonly windowMs: number;
+  readonly now: number;
+}
+interface CooldownResult {
+  readonly allowed: boolean;
+  readonly remaining: number;
+  readonly resetAt: number;
+  readonly saturated?: boolean;
+}
+interface CooldownStore {
+  /** Count and test one command use as one atomic operation. */
+  consume(request: CooldownRequest): Awaitable<CooldownResult>;
+}
+interface MemoryCooldownStoreOptions {
+  readonly maxEntries?: number;
+  readonly sweepIntervalMs?: number;
+}
+declare class MemoryCooldownStore implements CooldownStore {
+  private readonly entries;
+  private readonly maxEntries;
+  private readonly sweepIntervalMs;
+  private nextSweepAt;
+  constructor(options?: MemoryCooldownStoreOptions);
+  get size(): number;
+  consume(request: CooldownRequest): CooldownResult;
+  clear(): void;
+  private sweepIfDue;
+  private sweep;
+  private earliestResetAt;
+}
+//#endregion
+//#region packages/shared/src/logger.d.ts
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+interface Logger {
+  debug(...values: unknown[]): void;
+  info(...values: unknown[]): void;
+  warn(...values: unknown[]): void;
+  error(...values: unknown[]): void;
+  child(scope: string): Logger;
+}
+interface LoggerOptions {
+  level?: LogLevel;
+  scope?: string;
+  write?: (level: Exclude<LogLevel, "silent">, scope: string, values: unknown[]) => void;
+}
+/** Writes timestamped diagnostics to stderr. */
+declare class ConsoleLogger implements Logger {
+  private readonly level;
+  private readonly scope;
+  private readonly write;
+  constructor(options?: LoggerOptions);
+  debug(...values: unknown[]): void;
+  info(...values: unknown[]): void;
+  warn(...values: unknown[]): void;
+  error(...values: unknown[]): void;
+  child(scope: string): Logger;
+  private log;
+}
+/** Drops every diagnostic message. */
+declare class SilentLogger implements Logger {
+  debug(): void;
+  info(): void;
+  warn(): void;
+  error(): void;
+  child(_scope: string): Logger;
+}
+/** Reads EUNIA_LOG for the level; unset or invalid means silent. */
+declare function createLogger(scope: string): Logger;
+/** Renders the "time LEVEL scope" prefix for one log line. */
+declare function formatLogPrefix(level: Exclude<LogLevel, "silent">, scope: string, options: {
+  colors: boolean;
+  at?: Date;
+}): string;
+//#endregion
+//#region packages/rest/src/routes.d.ts
+/**
+ * Route binding. A caller binds a path template ("/channels/{channelId}/messages")
+ * to parameter values once; the uninterpolated template doubles as the
+ * rate-limit route key, so no per-request pattern matching is needed.
+ */
+type QueryValue = string | number | boolean | null | undefined;
+/** A bound route: interpolated request path plus its rate-limit identity. */
+interface RoutePath {
+  /** Interpolated path sent on the wire, e.g. "/channels/123/messages". */
+  path: string;
+  /** Uninterpolated template; used directly as the rate-limit route key. */
+  template: string;
+  /** Major rate-limit parameter (channel/guild/webhook scope), "global" when none. */
+  majorParam: string;
+}
+/** Binds a path template to parameter values. */
+declare function routePath(template: string, params?: Readonly<Record<string, string>>): RoutePath;
+/** Adds defined query parameters to a route or raw path. */
+declare function withQuery(route: string, query: Readonly<Record<string, QueryValue | readonly QueryValue[]>>): string;
+declare function withQuery(route: RoutePath, query: Readonly<Record<string, QueryValue | readonly QueryValue[]>>): RoutePath;
+//#endregion
+//#region packages/rest/src/rest.d.ts
+type HttpMethod = "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+/** A bound route, or a raw path string as the last-resort trapdoor. */
+type RequestPath = string | RoutePath;
+interface RestFile {
+  data: Blob | ArrayBuffer | ArrayBufferView;
+  name: string;
+  description?: string;
+}
+interface RestRequestOptions {
+  body?: unknown;
+  files?: readonly RestFile[];
+  auth?: boolean;
+  global?: boolean;
+  reason?: string;
+  headers?: HeadersInit;
+  signal?: AbortSignal;
+  idempotent?: boolean;
+}
+/** Configures the HTTP client. */
+interface RestOptions {
+  token: string;
+  version?: number;
+  baseUrl?: string;
+  userAgent?: string;
+  timeoutMs?: number;
+  retries?: number;
+  globalRequestsPerSecond?: number;
+  maxBuckets?: number;
+  bucketTtlMs?: number;
+  invalidRequestWarning?: number;
+  onInvalidRequestWarning?: (count: number) => void;
+  logger?: Logger;
+  fetch?: typeof fetch;
+}
+interface RestDiagnostics {
+  readonly buckets: number;
+  readonly learnedRoutes: number;
+  readonly invalidRequests: number;
+}
+/** Sends authenticated, rate-limited requests to Discord. */
+declare class EuniaRest {
+  private readonly log;
+  private readonly buckets;
+  private readonly hashes;
+  private readonly botGlobal;
+  private readonly ipGlobal;
+  private readonly unrestricted;
+  private readonly token;
+  private readonly opts;
+  private readonly invalidRequests;
+  private requestCount;
+  private warnedInvalidCount;
+  constructor(options: RestOptions);
+  get diagnostics(): RestDiagnostics;
+  get<T = unknown>(path: RequestPath, options?: Omit<RestRequestOptions, "body" | "files">): Promise<T>;
+  post<T = unknown>(path: RequestPath, body?: unknown, options?: Omit<RestRequestOptions, "body">): Promise<T>;
+  patch<T = unknown>(path: RequestPath, body?: unknown, options?: Omit<RestRequestOptions, "body">): Promise<T>;
+  put<T = unknown>(path: RequestPath, body?: unknown, options?: Omit<RestRequestOptions, "body">): Promise<T>;
+  delete<T = unknown>(path: RequestPath, options?: RestRequestOptions): Promise<T>;
+  request<T = unknown>(method: HttpMethod, path: RequestPath, options?: RestRequestOptions): Promise<T>;
+  private validateOptions;
+  private bucketFor;
+  private execute;
+  private prepareBody;
+  private observe;
+  private reconcileBucket;
+  private read429;
+  private parseBody;
+  private intoApiError;
+  private recordInvalidRequest;
+  private sweepBucketsIfNeeded;
+  private sweepAfterRequest;
+  private sweepBuckets;
+  private pruneInvalidRequests;
+}
+//#endregion
+//#region packages/rest/src/errors.d.ts
+/**
+ * An error response from Discord: a 4xx, or a 5xx after retries ran out.
+ * `status` is the HTTP status, `code` is Discord's own error code from the
+ * body (0 when absent), and `raw` is the parsed body including any
+ * field-level detail. Messages never include the token or request body.
+ */
+declare class DiscordError extends Error {
+  readonly status: number;
+  readonly code: number;
+  readonly method: string;
+  readonly routeKey: string;
+  readonly raw: unknown;
+  readonly name = "DiscordError";
+  constructor(status: number, code: number, message: string, method: string, routeKey: string, raw: unknown);
+}
+/**
+ * Thrown when a request kept hitting 429s past the retry budget. Ordinarily
+ * 429s are absorbed by waiting and retrying; this surfaces only when that
+ * budget runs out. `scope` is "user", "global", or "shared"; `global` means
+ * the 429 counted against the whole bot rather than one bucket.
+ */
+declare class RateLimitExhaustedError extends Error {
+  readonly method: string;
+  readonly routeKey: string;
+  readonly retryAfterMs: number;
+  readonly scope: string;
+  readonly global: boolean;
+  readonly name = "RateLimitExhaustedError";
+  constructor(method: string, routeKey: string, retryAfterMs: number, scope: string, global: boolean);
+}
+//#endregion
+//#region packages/rest/src/constants.d.ts
+/**
+ * Constants for Discord's REST API (v10). Protocol values are defined by
+ * Discord; library defaults are Eunia's and can all be overridden
+ * through `RestOptions`.
+ */
+/** REST API version, the `/v10` in every request URL. */
+declare const API_VERSION = 10;
+//#endregion
+//#region packages/structures/src/context.d.ts
+interface StructureCacheShape {
+  user: User$1;
+  guild: Guild$1;
+  channel: Channel$1;
+  message: Message$1;
+  member: GuildMember$1;
+  role: Role$1;
+}
+type StructureCache = Cache<StructureCacheShape>;
+interface StructureContext {
+  rest: EuniaRest;
+  cache: StructureCache;
+}
+declare function memberCacheKey(guildId: string, userId: string): string;
+declare function upsertCachedGuildChannel(ctx: StructureContext, raw: Channel$1): void;
+declare function removeCachedGuildChannel(ctx: StructureContext, guildId: string | undefined, channelId: string): void;
+declare function upsertCachedGuildMembers(ctx: StructureContext, guildId: string, entries: readonly {
+  userId: string;
+  raw: GuildMember$1;
+}[]): void;
+declare function upsertCachedGuildMember(ctx: StructureContext, guildId: string, userId: string, raw: GuildMember$1): void;
+declare function removeCachedGuildMember(ctx: StructureContext, guildId: string, userId: string): void;
+//#endregion
+//#region packages/structures/src/utils/messages.d.ts
+/**
+ * The universal content input accepted by every content-bearing verb:
+ * a plain string, one embed, an embed list, or the full payload object.
+ */
+type Sendable = string | Embed | readonly Embed[] | MessageCreate | MessageEdit;
+interface MessageRequestParts<T> {
+  body: Omit<T, "files">;
+  files: MessageCreate["files"] | undefined;
+}
+/** Normalizes a Sendable into a wire payload; "edit" permits null resets. */
+declare function normalizeSendable(input: Sendable, mode?: "create"): MessageCreate;
+declare function normalizeSendable(input: Sendable, mode: "edit"): MessageEdit;
+declare function splitMessageFiles<T extends {
+  files?: MessageCreate["files"];
+}>(data: T): MessageRequestParts<T>;
+//#endregion
+//#region packages/structures/src/utils/rest.d.ts
+interface AuditLogOptions {
+  reason?: string;
+}
+//#endregion
+//#region packages/structures/src/structures/BaseStructure.d.ts
+declare abstract class BaseStructure<Raw extends {
+  id: Snowflake;
+}> {
+  protected readonly ctx: StructureContext;
+  readonly raw: Readonly<Raw>;
+  protected constructor(raw: Raw, ctx: StructureContext);
+  get id(): Snowflake;
+  get createdTimestamp(): number;
+  get createdAt(): Date;
+  toJSON(): Raw;
+}
+//#endregion
+//#region packages/structures/src/utils/discord.d.ts
+declare const DISCORD_EPOCH = 1420070400000;
+declare const CDN_BASE_URL = "https://cdn.discordapp.com";
+type ImageExtension = "png" | "jpeg" | "webp" | "gif";
+interface CDNImageOptions {
+  extension?: ImageExtension;
+  size?: 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
+}
+declare function snowflakeTimestamp(snowflake: string): number;
+declare function cdnAssetUrl(path: readonly string[], hash: string, options?: CDNImageOptions): string;
+//#endregion
+//#region packages/structures/src/structures/Role.d.ts
+interface RoleEditInput {
+  name?: string;
+  permissions?: PermissionInput;
+  color?: number;
+  hoist?: boolean;
+  icon?: string | null;
+  unicodeEmoji?: string | null;
+  mentionable?: boolean;
+}
+declare class Role extends BaseStructure<Role$1> {
+  readonly guildId: string;
+  constructor(raw: Role$1, ctx: StructureContext, guildId: string);
+  get name(): string;
+  get mention(): string;
+  get permissions(): bigint;
+  get guild(): Guild | undefined;
+  iconURL(options?: CDNImageOptions): string | undefined;
+  fetchGuild(): Promise<Guild>;
+  edit(options: RoleEditInput, audit?: AuditLogOptions): Promise<Role>;
+  delete(audit?: AuditLogOptions): Promise<void>;
+  private updateCachedGuildRoles;
+}
+//#endregion
+//#region packages/structures/src/structures/Message.d.ts
+declare class Message extends BaseStructure<Message$1> {
+  readonly author: User;
+  constructor(raw: Message$1, ctx: StructureContext);
+  get content(): string;
+  get channelId(): string;
+  get guildId(): string | undefined;
+  get editedAt(): Date | undefined;
+  get channel(): Channel | undefined;
+  get guild(): Guild | undefined;
+  get url(): string;
+  fetchChannel(): Promise<Channel>;
+  fetchGuild(): Promise<Guild | undefined>;
+  reply(input: Sendable): Promise<Message>;
+  edit(input: Sendable): Promise<Message>;
+  delete(): Promise<void>;
+  react(emoji: string): Promise<void>;
+  removeOwnReaction(emoji: string): Promise<void>;
+  pin(): Promise<void>;
+  unpin(): Promise<void>;
+  private cacheMessage;
+  private cachePinnedState;
+}
+//#endregion
+//#region packages/structures/src/structures/User.d.ts
+declare class User extends BaseStructure<User$1> {
+  constructor(raw: User$1, ctx: StructureContext);
+  get username(): string;
+  get displayName(): string;
+  get isBot(): boolean;
+  get mention(): string;
+  get tag(): string;
+  avatarURL(options?: CDNImageOptions): string | undefined;
+  displayAvatarURL(options?: CDNImageOptions): string;
+  get defaultAvatarURL(): string;
+  bannerURL(options?: CDNImageOptions): string | undefined;
+  createDM(): Promise<Channel>;
+  send(input: Sendable): Promise<Message>;
+}
+//#endregion
+//#region packages/structures/src/structures/GuildMember.d.ts
+interface MemberEditInput extends AuditLogOptions {
+  nickname?: string | null;
+  roles?: readonly Snowflake[];
+  mute?: boolean;
+  deaf?: boolean;
+  channelId?: Snowflake | null;
+  communicationDisabledUntil?: Date | number | string | null;
+}
+interface BanInput extends AuditLogOptions {
+  deleteMessageSeconds?: number;
+}
+declare class GuildMember {
+  private readonly ctx;
+  readonly guildId: string;
+  readonly id: string;
+  readonly raw: Readonly<GuildMember$1>;
+  constructor(raw: GuildMember$1, ctx: StructureContext, guildId: string, id?: string);
+  get createdTimestamp(): number;
+  get createdAt(): Date;
+  get joinedAt(): Date | undefined;
+  get mention(): string;
+  get user(): User | undefined;
+  get guild(): Guild | undefined;
+  get displayName(): string;
+  /** The interaction-provided channel permissions when present, guild-wide otherwise. */
+  get permissions(): bigint;
+  /** Guild-wide permissions from cached roles; the owner holds every flag. */
+  get guildPermissions(): bigint;
+  /** Returns true when the member holds every flag in `required`. */
+  can(required: bigint): boolean;
+  /** Returns true when the member holds at least one flag in `anyOf`. */
+  canAny(anyOf: bigint): boolean;
+  /** Names the flags in `required` that the member lacks. */
+  missing(required: bigint): PermissionFlagName[];
+  get roles(): ReadonlyMap<string, Role>;
+  get highestRole(): Role | undefined;
+  displayAvatarURL(options?: CDNImageOptions): string | undefined;
+  fetchUser(): Promise<User>;
+  fetchGuild(): Promise<Guild>;
+  edit(options: MemberEditInput): Promise<GuildMember>;
+  setNickname(nickname: string | null, audit?: AuditLogOptions): Promise<GuildMember>;
+  timeout(until: Date | number | string | null, audit?: AuditLogOptions): Promise<GuildMember>;
+  kick(audit?: AuditLogOptions): Promise<void>;
+  ban(options?: BanInput): Promise<void>;
+  addRole(role: string | Role, audit?: AuditLogOptions): Promise<void>;
+  removeRole(role: string | Role, audit?: AuditLogOptions): Promise<void>;
+  toJSON(): GuildMember$1;
+  private cacheMember;
+  private cachedPayload;
+}
+//#endregion
+//#region packages/structures/src/structures/Guild.d.ts
+interface GuildBanInput extends AuditLogOptions {
+  deleteMessageSeconds?: number;
+}
+type RoleCreateInput = RoleEditInput;
+declare class Guild extends BaseStructure<Guild$1> {
+  constructor(raw: Guild$1, ctx: StructureContext);
+  get name(): string;
+  get ownerId(): string;
+  get owner(): User | undefined;
+  get channels(): ReadonlyMap<string, Channel>;
+  get roles(): ReadonlyMap<string, Role>;
+  get members(): ReadonlyMap<string, GuildMember>;
+  iconURL(options?: CDNImageOptions): string | undefined;
+  bannerURL(options?: CDNImageOptions): string | undefined;
+  splashURL(options?: CDNImageOptions): string | undefined;
+  channel(channelId: string): Channel | undefined;
+  member(userId: string): GuildMember | undefined;
+  role(roleId: string): Role | undefined;
+  fetchOwner(): Promise<User>;
+  fetchChannel(channelId: string): Promise<Channel>;
+  fetchMember(userId: string): Promise<GuildMember>;
+  fetchRoles(): Promise<ReadonlyMap<string, Role>>;
+  fetchRole(roleId: string): Promise<Role>;
+  ban(userId: string, options?: GuildBanInput): Promise<void>;
+  unban(userId: string, audit?: AuditLogOptions): Promise<void>;
+  createRole(options?: RoleCreateInput, audit?: AuditLogOptions): Promise<Role>;
+  applicationCommands(applicationId: string): Promise<ApplicationCommand[]>;
+  createApplicationCommand(applicationId: string, definition: ApplicationCommandDefinition): Promise<ApplicationCommand>;
+  private updateCachedRoles;
+  private cachedPayload;
+}
+//#endregion
+//#region packages/structures/src/structures/Channel.d.ts
+type ChannelEditInput = Partial<Pick<Channel$1, "name" | "position" | "topic" | "nsfw" | "rate_limit_per_user" | "bitrate" | "user_limit" | "permission_overwrites" | "parent_id" | "rtc_region" | "video_quality_mode" | "default_auto_archive_duration" | "flags" | "available_tags" | "default_reaction_emoji" | "default_thread_rate_limit_per_user" | "default_sort_order" | "default_forum_layout" | "applied_tags">>;
+declare class Channel extends BaseStructure<Channel$1> {
+  constructor(raw: Channel$1, ctx: StructureContext);
+  get name(): string | null | undefined;
+  get topic(): string | null | undefined;
+  get guildId(): string | undefined;
+  get mention(): string;
+  get isDM(): boolean;
+  get isThread(): boolean;
+  get isTextBased(): boolean;
+  /** Computes the member's effective permission bitfield in this channel. */
+  permissionsFor(member: GuildMember): bigint;
+  get guild(): Guild | undefined;
+  fetchGuild(): Promise<Guild | undefined>;
+  send(input: Sendable): Promise<Message>;
+  fetchMessage(messageId: string): Promise<Message>;
+  edit(options: ChannelEditInput, audit?: AuditLogOptions): Promise<Channel>;
+  updateTopic(topic: string | null): Promise<Channel>;
+  delete(audit?: AuditLogOptions): Promise<Channel>;
+  triggerTyping(): Promise<void>;
+  private cacheMessage;
+}
+//#endregion
+//#region packages/structures/src/structures/Interaction.d.ts
+type InteractionKind = "command" | "autocomplete" | "button" | "select" | "modal";
+type InteractionState = "pending" | "replying" | "deferring" | "autocompleting" | "replied" | "deferred" | "autocomplete" | "uncertain";
+interface DeferOptions {
+  ephemeral?: boolean;
+}
+type ModalFieldValue = string | readonly string[] | boolean | null;
+declare class InteractionAlreadyAcknowledgedError extends Error {
+  readonly state: InteractionState;
+  constructor(state: InteractionState);
+}
+declare class InteractionNotAcknowledgedError extends Error {
+  readonly state: InteractionState;
+  constructor(state: InteractionState);
+}
+/** Handle on the @original response message. */
+interface OriginalMessage {
+  get(): Promise<Message>;
+  edit(input: Sendable): Promise<Message>;
+  delete(): Promise<void>;
+}
+interface InteractionCommon {
+  readonly raw: Readonly<Interaction$1>;
+  readonly id: string;
+  readonly kind: InteractionKind;
+  readonly applicationId: string;
+  readonly token: string;
+  readonly guildId: string | undefined;
+  readonly channelId: string | undefined;
+  readonly state: InteractionState;
+  readonly acknowledged: boolean;
+  readonly user: User | undefined;
+  readonly member: GuildMember | undefined;
+  readonly channel: Channel | undefined;
+  readonly guild: Guild | undefined;
+  fetchChannel(): Promise<Channel | undefined>;
+  fetchGuild(): Promise<Guild | undefined>;
+  resolvedUser(id: string): User | undefined;
+  resolvedChannel(id: string): Channel | undefined;
+  resolvedRole(id: string): Role | undefined;
+  toJSON(): Interaction$1;
+}
+interface RespondingInteraction extends InteractionCommon {
+  /** Sends the initial message response. */
+  respond(input: Sendable): Promise<void>;
+  /** Acknowledges now, answers later; picks the deferred mode from the kind. */
+  defer(options?: DeferOptions): Promise<void>;
+  /** The @original response message handle. */
+  readonly original: OriginalMessage;
+  /** Sends an additional message after acknowledgement. */
+  followup(input: Sendable): Promise<Message>;
+}
+interface CommandInteractionShape extends RespondingInteraction {
+  readonly kind: "command";
+  readonly commandName: string;
+  /** Opens a modal as the initial response. */
+  modal(input: ModalInteractionResponseData): Promise<void>;
+}
+interface AutocompleteInteractionShape extends InteractionCommon {
+  readonly kind: "autocomplete";
+  readonly commandName: string;
+  /** Sends the suggestion list; the only valid response for this kind. */
+  autocomplete(choices: readonly ApplicationCommandChoice[]): Promise<void>;
+}
+interface ButtonInteractionShape extends RespondingInteraction {
+  readonly kind: "button";
+  readonly customId: string;
+  readonly message: Message | undefined;
+  /** Edits the message the component sits on, as the initial response. */
+  update(input: Sendable): Promise<void>;
+  modal(input: ModalInteractionResponseData): Promise<void>;
+}
+interface SelectInteractionShape extends RespondingInteraction {
+  readonly kind: "select";
+  readonly customId: string;
+  readonly message: Message | undefined;
+  readonly values: readonly string[];
+  update(input: Sendable): Promise<void>;
+  modal(input: ModalInteractionResponseData): Promise<void>;
+}
+interface ModalInteractionShape extends RespondingInteraction {
+  readonly kind: "modal";
+  readonly customId: string;
+  readonly message: Message | undefined;
+  update(input: Sendable): Promise<void>;
+  /** Reads one submitted field by custom id. */
+  field(customId: string): ModalFieldValue | undefined;
+  /** Reads one submitted text input by custom id. */
+  textField(customId: string): string | undefined;
+}
+type InteractionShapes = CommandInteractionShape | AutocompleteInteractionShape | ButtonInteractionShape | SelectInteractionShape | ModalInteractionShape;
+/**
+ * A received interaction, narrowed through the `kind` discriminant:
+ * `if (interaction.kind === "button")` exposes button-only members.
+ */
+type Interaction<K extends InteractionKind = InteractionKind> = Extract<InteractionShapes, {
+  kind: K;
+}>;
+/** Hydrates a raw interaction payload into its kind-narrowed form. */
+declare function createInteraction(raw: ApplicationCommandInteraction, ctx: StructureContext): Interaction<"command">;
+declare function createInteraction(raw: AutocompleteInteraction, ctx: StructureContext): Interaction<"autocomplete">;
+declare function createInteraction(raw: MessageComponentInteraction, ctx: StructureContext): Interaction<"button" | "select">;
+declare function createInteraction(raw: ModalSubmitInteraction, ctx: StructureContext): Interaction<"modal">;
+declare function createInteraction(raw: Interaction$1, ctx: StructureContext): Interaction;
+/** Returns true when the value is an interaction produced by createInteraction. */
+declare function isInteraction(value: unknown): value is Interaction;
+//#endregion
+//#region packages/commands/src/errors.d.ts
+type CommandErrorCode = "invalid_definition" | "duplicate_command" | "registration_frozen" | "invalid_option" | "middleware_next_called_twice" | "execution_failed" | "autocomplete_failed" | "cooldown_store_failed";
+type CommandRejectionCode = "guild_only" | "owner_only" | "missing_user_permissions" | "missing_bot_permissions" | "permission_data_unavailable" | "cooldown" | "guard" | "invalid_input" | "command_unavailable";
+declare class CommandError extends Error {
+  readonly code: CommandErrorCode;
+  constructor(message: string, code: CommandErrorCode, options?: ErrorOptions);
+}
+declare class CommandValidationError extends CommandError {
+  constructor(message: string);
+}
+declare class DuplicateCommandError extends CommandError {
+  constructor(name: string);
+}
+declare class RegistrationFrozenError extends CommandError {
+  constructor();
+}
+declare class CommandOptionError extends CommandError {
+  constructor(message: string);
+}
+declare class MiddlewareError extends CommandError {
+  constructor(message?: string);
+}
+declare class CommandExecutionError extends CommandError {
+  constructor(path: readonly string[], cause: unknown);
+}
+declare class AutocompleteError extends CommandError {
+  constructor(path: readonly string[], cause: unknown);
+}
+declare class CooldownStoreError extends CommandError {
+  constructor(cause: unknown);
+}
+declare class CommandRejection extends Error {
+  readonly code: CommandRejectionCode;
+  readonly details: Readonly<Record<string, unknown>>;
+  constructor(code: CommandRejectionCode, message: string, details?: Readonly<Record<string, unknown>>);
+}
+//#endregion
+//#region packages/commands/src/fields.d.ts
+interface OptionConfigBase {
+  readonly description?: string;
+  readonly nameLocalizations?: Localizations;
+  readonly descriptionLocalizations?: Localizations;
+  readonly required?: boolean;
+}
+interface StringOptionConfig extends OptionConfigBase {
+  readonly choices?: readonly CommandChoice<string>[];
+  readonly autocomplete?: boolean;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  /** Prefix parsing: `rest: true` consumes the remaining input as one value. */
+  readonly prefix?: {
+    readonly rest?: boolean;
+  };
+}
+interface NumericOptionConfig extends OptionConfigBase {
+  readonly choices?: readonly CommandChoice<number>[];
+  readonly autocomplete?: boolean;
+  readonly minValue?: number;
+  readonly maxValue?: number;
+}
+interface BooleanOptionConfig extends OptionConfigBase {}
+interface UserOptionConfig extends OptionConfigBase {}
+interface RoleOptionConfig extends OptionConfigBase {}
+interface MentionableOptionConfig extends OptionConfigBase {}
+interface AttachmentOptionConfig extends OptionConfigBase {}
+interface ChannelOptionConfig extends OptionConfigBase {
+  readonly channelTypes?: readonly ChannelType[];
+}
+type OptionConfig = StringOptionConfig | NumericOptionConfig | BooleanOptionConfig | ChannelOptionConfig;
+declare class OptionField<Value, Required extends boolean = boolean> {
+  readonly type: ApplicationCommandOptionType;
+  readonly config: OptionConfig;
+  /** Wire name; assigned from the class field key at registration. */
+  name: string;
+  readonly valueType: Value;
+  readonly requiredType: Required;
+  constructor(type: ApplicationCommandOptionType, config: OptionConfig);
+  get required(): boolean;
+}
+type RequiredOf<C extends OptionConfigBase | undefined> = C extends {
+  required: true;
+} ? true : false;
+declare const option: {
+  string<const C extends StringOptionConfig | undefined = undefined>(config?: C): OptionField<string, RequiredOf<C>>;
+  integer<const C extends NumericOptionConfig | undefined = undefined>(config?: C): OptionField<number, RequiredOf<C>>;
+  number<const C extends NumericOptionConfig | undefined = undefined>(config?: C): OptionField<number, RequiredOf<C>>;
+  boolean<const C extends BooleanOptionConfig | undefined = undefined>(config?: C): OptionField<boolean, RequiredOf<C>>;
+  user<const C extends UserOptionConfig | undefined = undefined>(config?: C): OptionField<ResolvedUser, RequiredOf<C>>;
+  channel<const C extends ChannelOptionConfig | undefined = undefined>(config?: C): OptionField<ResolvedChannel, RequiredOf<C>>;
+  role<const C extends RoleOptionConfig | undefined = undefined>(config?: C): OptionField<ResolvedRole, RequiredOf<C>>;
+  mentionable<const C extends MentionableOptionConfig | undefined = undefined>(config?: C): OptionField<ResolvedMentionable, RequiredOf<C>>;
+  attachment<const C extends AttachmentOptionConfig | undefined = undefined>(config?: C): OptionField<ResolvedAttachment, RequiredOf<C>>;
+};
+//#endregion
+//#region packages/commands/src/types.d.ts
+type Awaitable<T> = T | Promise<T>;
+interface CommandChoice<T extends string | number = string | number> {
+  readonly name: string;
+  readonly nameLocalizations?: Localizations;
+  readonly value: T;
+}
+type CooldownScope = "user" | "channel" | "guild" | "global";
+interface CommandRateLimit {
+  readonly limit: number;
+  readonly windowMs: number;
+  readonly scope?: CooldownScope;
+}
+interface AutoDeferOptions {
+  readonly afterMs?: number;
+  readonly ephemeral?: boolean;
+}
+interface CommandGuardFailure {
+  readonly allowed: false;
+  readonly reason?: string;
+  readonly details?: Readonly<Record<string, unknown>>;
+}
+type CommandGuard = (context: CommandContext | AutocompleteContext) => Awaitable<boolean | void | CommandGuardFailure>;
+type CommandMiddleware = (context: CommandContext, next: () => Promise<void>) => Awaitable<void>;
+/** Hydrates resolved option payloads into structures; an interaction satisfies it. */
+interface ResolvedStructureSource {
+  resolvedUser(id: string): User | undefined;
+  resolvedChannel(id: string): Channel | undefined;
+  resolvedRole(id: string): Role | undefined;
+}
+/** Structure fields are present only when the invocation carried resolved payloads. */
+interface ResolvedUser {
+  readonly id: string;
+  readonly raw?: User$1;
+  readonly user?: User;
+}
+interface ResolvedChannel {
+  readonly id: string;
+  readonly raw?: Pick<Channel$1, "id" | "type" | "name" | "permissions">;
+  readonly channel?: Channel;
+}
+interface ResolvedRole {
+  readonly id: string;
+  readonly raw?: Role$1;
+  readonly role?: Role;
+}
+type ResolvedMentionable = {
+  readonly kind: "user";
+  readonly id: string;
+  readonly raw?: User$1;
+  readonly user?: User;
+} | {
+  readonly kind: "role";
+  readonly id: string;
+  readonly raw?: Role$1;
+  readonly role?: Role;
+};
+interface ResolvedAttachment {
+  readonly id: string;
+  readonly raw?: Attachment;
+}
+interface CommandRest {
+  put<T = unknown>(path: string, body?: unknown): Promise<T>;
+}
+interface CommandHost {
+  readonly applicationId: string;
+  readonly botId: string;
+  readonly ownerIds: readonly string[] | ReadonlySet<string>;
+  readonly rest: CommandRest;
+  reportCommandError(error: CommandError, context?: CommandContext | AutocompleteContext): Awaitable<void>;
+}
+interface FocusedOption {
+  readonly name: string;
+  readonly type: ApplicationCommandOptionType.String | ApplicationCommandOptionType.Integer | ApplicationCommandOptionType.Number;
+  readonly value: string | number;
+}
+/** Typed access to declared option fields: `ctx.get(this.sides)`. */
+interface OptionAccess {
+  get<V, R extends boolean>(field: OptionField<V, R>): R extends true ? V : V | undefined;
+  has(field: OptionField<unknown, boolean>): boolean;
+}
+interface CommandContextBase extends OptionAccess {
+  readonly command: Command;
+  readonly groups: readonly CommandGroup[];
+  readonly path: readonly string[];
+  readonly host: CommandHost;
+  readonly userId: string;
+  readonly channelId?: string;
+  readonly guildId?: string;
+  readonly userPermissions?: bigint;
+  readonly botPermissions?: bigint;
+  reply(input: Sendable): Promise<unknown>;
+}
+interface SlashCommandContext extends CommandContextBase {
+  readonly kind: "slash";
+  readonly interaction: Interaction<"command">;
+  defer(options?: {
+    readonly ephemeral?: boolean;
+  }): Promise<boolean>;
+}
+interface PrefixCommandContext extends CommandContextBase {
+  readonly kind: "prefix";
+  readonly message: Message;
+  readonly prefix: string;
+}
+type CommandContext = SlashCommandContext | PrefixCommandContext;
+interface AutocompleteContext extends OptionAccess {
+  readonly kind: "autocomplete";
+  readonly command: Command;
+  readonly groups: readonly CommandGroup[];
+  readonly path: readonly string[];
+  readonly host: CommandHost;
+  readonly interaction: Interaction<"autocomplete">;
+  readonly focused: FocusedOption;
+  readonly userId: string;
+  readonly channelId?: string;
+  readonly guildId?: string;
+  readonly userPermissions?: bigint;
+  readonly botPermissions?: bigint;
+}
+/** Context handed to command-scoped component and modal listeners. */
+interface ListenerContext<K extends "button" | "select" | "modal" = "button" | "select" | "modal"> {
+  readonly kind: K;
+  readonly command: Command;
+  readonly host: CommandHost;
+  readonly interaction: Interaction<K>;
+  readonly args: readonly string[];
+  readonly userId: string;
+  readonly channelId?: string;
+  readonly guildId?: string;
+  reply(input: Sendable): Promise<unknown>;
+  update(input: Sendable): Promise<void>;
+  defer(): Promise<boolean>;
+}
+type PrefixValue = string | readonly string[] | null | undefined;
+type PrefixResolver = string | readonly string[] | ((message: Message) => Awaitable<PrefixValue>);
+interface PrefixOptions {
+  readonly prefixes: PrefixResolver;
+  readonly allowMention?: boolean;
+  readonly caseSensitive?: boolean;
+  readonly ignoreBots?: boolean;
+}
+type CommandMessageFactory = string | ((rejection: CommandRejection) => string);
+interface CommandMessages {
+  readonly guildOnly?: CommandMessageFactory;
+  readonly ownerOnly?: CommandMessageFactory;
+  readonly userPermissions?: CommandMessageFactory;
+  readonly botPermissions?: CommandMessageFactory;
+  readonly permissionDataUnavailable?: CommandMessageFactory;
+  readonly cooldown?: CommandMessageFactory;
+  readonly guard?: CommandMessageFactory;
+  readonly invalidInput?: CommandMessageFactory;
+  readonly unavailable?: CommandMessageFactory;
+  readonly error?: string;
+}
+interface CommandManagerOptions {
+  readonly prefix?: PrefixResolver | PrefixOptions;
+  readonly middleware?: readonly CommandMiddleware[];
+  readonly guards?: readonly CommandGuard[];
+  readonly cooldownStore?: CooldownStore;
+  readonly autocompleteTimeoutMs?: number;
+  readonly messages?: CommandMessages;
+}
+interface CommandPermissionData {
+  readonly userPermissions?: PermissionInput;
+  readonly botPermissions?: PermissionInput;
+}
+interface CommandHandleOptions extends CommandPermissionData {
+  readonly resolvePermissions?: () => Awaitable<CommandPermissionData>;
+}
+type CommandHandleResult = {
+  readonly status: "ignored";
+} | {
+  readonly status: "completed";
+  readonly path: readonly string[];
+} | {
+  readonly status: "autocomplete";
+  readonly path: readonly string[];
+} | {
+  readonly status: "rejected";
+  readonly rejection: CommandRejection;
+} | {
+  readonly status: "failed";
+  readonly error: CommandError;
+};
+type CommandPublishTarget = {
+  readonly scope?: "global";
+} | {
+  readonly scope: "guild";
+  readonly guildId: string;
+};
+interface CommandPublishResult<T = unknown> {
+  readonly target: "global" | "guild";
+  readonly guildId?: string;
+  readonly commands: T;
+}
+//#endregion
+//#region packages/commands/src/command.d.ts
+type CommandKind = "slash" | "prefix" | "hybrid";
+declare abstract class Command {
+  abstract readonly name: string;
+  abstract readonly description: string;
+  abstract readonly kind: CommandKind;
+  readonly aliases: readonly string[];
+  readonly middleware: readonly CommandMiddleware[];
+  readonly guards: readonly CommandGuard[];
+  readonly guildOnly: boolean;
+  readonly ownerOnly: boolean;
+  readonly userPermissions?: PermissionInput;
+  readonly botPermissions?: PermissionInput;
+  readonly rateLimit?: CommandRateLimit;
+  readonly autoDefer?: boolean | AutoDeferOptions;
+  /** Free-form user space; the library never interprets it. */
+  readonly meta: Readonly<Record<string, unknown>>;
+  readonly nameLocalizations?: Localizations;
+  readonly descriptionLocalizations?: Localizations;
+  readonly defaultMemberPermissions?: PermissionInput | null;
+  readonly contexts?: readonly InteractionContextType[] | null;
+  readonly integrationTypes?: readonly ApplicationIntegrationType[];
+  readonly nsfw?: boolean;
+  abstract run(context: CommandContext): Awaitable<void>;
+  autocomplete(_context: AutocompleteContext): Awaitable<readonly CommandChoice[]>;
+}
+/**
+ * A group shares the field anatomy and lists child classes; shared policy
+ * (permissions, guildOnly, meta) applies to every child.
+ */
+declare abstract class CommandGroup {
+  abstract readonly name: string;
+  abstract readonly description: string;
+  abstract readonly children: readonly CommandNodeClass[];
+  readonly aliases: readonly string[];
+  readonly middleware: readonly CommandMiddleware[];
+  readonly guards: readonly CommandGuard[];
+  readonly guildOnly: boolean;
+  readonly ownerOnly: boolean;
+  readonly userPermissions?: PermissionInput;
+  readonly botPermissions?: PermissionInput;
+  readonly meta: Readonly<Record<string, unknown>>;
+  readonly nameLocalizations?: Localizations;
+  readonly descriptionLocalizations?: Localizations;
+  readonly defaultMemberPermissions?: PermissionInput | null;
+  readonly contexts?: readonly InteractionContextType[] | null;
+  readonly integrationTypes?: readonly ApplicationIntegrationType[];
+  readonly nsfw?: boolean;
+}
+type CommandNode = Command | CommandGroup;
+type CommandNodeClass = new () => CommandNode;
+//#endregion
+//#region packages/commands/src/listeners.d.ts
+type ListenerKind = "button" | "select" | "modal";
+interface ListenerButtonInput {
+  readonly style?: ButtonStyle.Primary | ButtonStyle.Secondary | ButtonStyle.Success | ButtonStyle.Danger;
+  readonly label?: string;
+  readonly emoji?: ComponentEmoji;
+  readonly disabled?: boolean;
+}
+type ListenerSelectInput = (Omit<StringSelectComponent, "type" | "custom_id"> & {
+  readonly type?: ComponentType.StringSelect;
+}) | Omit<AutoSelectComponent, "custom_id">;
+type ListenerModalInput = Omit<ModalInteractionResponseData, "custom_id">;
+type ListenerHandler<K extends ListenerKind> = (context: ListenerContext<K>, args: readonly string[]) => Awaitable<void>;
+declare abstract class ListenerFieldBase<K extends ListenerKind> {
+  readonly kind: K;
+  readonly handler: ListenerHandler<K>;
+  /** Route prefix (`<command>.<field>`); assigned at registration. */
+  route: string;
+  constructor(kind: K, handler: ListenerHandler<K>);
+  protected customId(args: readonly string[]): string;
+}
+declare class ButtonListenerField extends ListenerFieldBase<"button"> {
+  constructor(handler: ListenerHandler<"button">);
+  /** Produces plain button component data carrying the derived custom_id. */
+  button(input?: ListenerButtonInput, ...args: readonly string[]): ButtonComponent;
+}
+declare class SelectListenerField extends ListenerFieldBase<"select"> {
+  constructor(handler: ListenerHandler<"select">);
+  /** Produces plain select component data carrying the derived custom_id. */
+  select(input: ListenerSelectInput, ...args: readonly string[]): StringSelectComponent | AutoSelectComponent;
+}
+declare class ModalListenerField extends ListenerFieldBase<"modal"> {
+  constructor(handler: ListenerHandler<"modal">);
+  /** Produces modal callback data carrying the derived custom_id. */
+  modal(input: ListenerModalInput, ...args: readonly string[]): ModalInteractionResponseData;
+}
+type ListenerField = ButtonListenerField | SelectListenerField | ModalListenerField;
+declare function onButton(handler: ListenerHandler<"button">): ButtonListenerField;
+declare function onSelect(handler: ListenerHandler<"select">): SelectListenerField;
+declare function onModal(handler: ListenerHandler<"modal">): ModalListenerField;
+//#endregion
+//#region packages/commands/src/manager.d.ts
+declare class CommandManager {
+  private readonly roots;
+  private readonly slashRoots;
+  private readonly prefixRoots;
+  private readonly listenerRoutes;
+  private readonly host;
+  private readonly middleware;
+  private readonly guards;
+  private readonly cooldowns;
+  private readonly autocompleteTimeoutMs;
+  private readonly messages;
+  private readonly prefix?;
+  private frozen;
+  constructor(host: CommandHost, options?: CommandManagerOptions);
+  get isFrozen(): boolean;
+  get commands(): readonly CommandNode[];
+  register(...commands: readonly CommandNode[]): this;
+  handle(source: Interaction | Message, options?: CommandHandleOptions): Promise<CommandHandleResult>;
+  publish<T = unknown>(target?: CommandPublishTarget): Promise<CommandPublishResult<T>>;
+  private freeze;
+  private handleInteraction;
+  private handleListener;
+  private executeSlash;
+  private handleAutocomplete;
+  private handleMessage;
+  private executeContext;
+  private startAutoDefer;
+  private runChecks;
+  private consumeCooldown;
+  private respondWithResponder;
+  private respondWithoutContext;
+  private rejectionMessage;
+  private emptyAutocomplete;
+  private report;
+  private fail;
+}
+//#endregion
+//#region packages/commands/src/prefix.d.ts
+interface PrefixMatch {
+  readonly prefix: string;
+  readonly content: string;
+  readonly caseSensitive: boolean;
+}
+declare function tokenizePrefix(content: string): readonly string[];
+//#endregion
+//#region packages/gateway/src/identify-gate.d.ts
+/** Coordinates identify calls across concurrency buckets. */
+declare class IdentifyGate {
+  readonly maxConcurrency: number;
+  private readonly chains;
+  private readonly lastIdentifiedAt;
+  constructor(maxConcurrency: number);
+  acquire(shardId: number): Promise<void>;
+}
+//#endregion
+//#region packages/gateway/src/constants.d.ts
+/**
+ * Protocol constants for Discord's gateway (API v10). Every value here is
+ * defined by Discord, not by Eunia.
+ */
+/** The gateway version to speak. Sent as `?v=10` in the connection URL. */
+declare const GATEWAY_VERSION = 10;
+/**
+ * Opcodes. The `op` field of every gateway frame.
+ * "receive" = Discord to client, "send" = client to Discord.
+ */
+declare enum GatewayOpcode {
+  /** receive · An event (READY, MESSAGE_CREATE, …). */
+  Dispatch = 0,
+  /** send + receive · Keep-alive ping. */
+  Heartbeat = 1,
+  /** send · Log in and start a new session. */
+  Identify = 2,
+  /** send · Update the bot's status/activity. */
+  PresenceUpdate = 3,
+  /** send · Join, leave, or move voice channels. */
+  VoiceStateUpdate = 4,
+  /** send · Reattach to an existing session. */
+  Resume = 6,
+  /** receive · Discord asking the client to disconnect and resume. Routine. */
+  Reconnect = 7,
+  /** send · Request a guild's member list in chunks. */
+  RequestGuildMembers = 8,
+  /** receive · The session died. `d: true` = may resume, `d: false` = must re-identify. */
+  InvalidSession = 9,
+  /** receive · First frame after connecting; provides the heartbeat interval. */
+  Hello = 10,
+  /** receive · Acknowledges a heartbeat. */
+  HeartbeatAck = 11
+}
+/**
+ * Intents. Which event groups the bot receives, combined into a bitfield
+ * in IDENTIFY.
+ *
+ * Privileged intents (marked ⚠) must also be enabled in the developer
+ * portal, or the gateway closes the connection with code 4014 on identify.
+ * Note that message *events* and message *content* are separate intents.
+ */
+declare const Intents: {
+  readonly Guilds: number;
+  /** ⚠ privileged */
+  readonly GuildMembers: number;
+  readonly GuildModeration: number;
+  readonly GuildExpressions: number;
+  readonly GuildIntegrations: number;
+  readonly GuildWebhooks: number;
+  readonly GuildInvites: number;
+  readonly GuildVoiceStates: number;
+  /** ⚠ privileged */
+  readonly GuildPresences: number;
+  readonly GuildMessages: number;
+  readonly GuildMessageReactions: number;
+  readonly GuildMessageTyping: number;
+  readonly DirectMessages: number;
+  readonly DirectMessageReactions: number;
+  readonly DirectMessageTyping: number;
+  /** ⚠ privileged */
+  readonly MessageContent: number;
+  readonly GuildScheduledEvents: number;
+  readonly AutoModerationConfiguration: number;
+  readonly AutoModerationExecution: number;
+  readonly GuildMessagePolls: number;
+  readonly DirectMessagePolls: number;
+};
+/**
+ * Close codes Discord uses when it closes the WebSocket. Standard codes
+ * (1000 normal, 1006 abnormal) also appear.
+ */
+declare enum GatewayCloseCode {
+  UnknownError = 4000,
+  UnknownOpcode = 4001,
+  DecodeError = 4002,
+  NotAuthenticated = 4003,
+  AuthenticationFailed = 4004,
+  AlreadyAuthenticated = 4005,
+  InvalidSequence = 4007,
+  RateLimited = 4008,
+  SessionTimedOut = 4009,
+  InvalidShard = 4010,
+  ShardingRequired = 4011,
+  InvalidApiVersion = 4012,
+  InvalidIntents = 4013,
+  DisallowedIntents = 4014
+}
+/**
+ * Close codes where reconnecting can never help. The problem is the bot's
+ * configuration (bad token, disallowed intents, wrong shard setup). The
+ * shard refuses to retry these so a config mistake can't burn through the
+ * daily identify budget.
+ */
+declare const FATAL_CLOSE_CODES: ReadonlySet<number>;
+//#endregion
+//#region packages/gateway/src/types.d.ts
+declare enum ActivityType {
+  Playing = 0,
+  Streaming = 1,
+  Listening = 2,
+  Watching = 3,
+  Custom = 4,
+  Competing = 5
+}
+interface GatewayActivity {
+  name: string;
+  type: ActivityType;
+  url?: string | null;
+  state?: string | null;
+}
+interface GatewayPresence {
+  since: number | null;
+  activities: GatewayActivity[];
+  status: "online" | "dnd" | "idle" | "invisible" | "offline";
+  afk: boolean;
+}
+/**
+ * The envelope for every gateway frame, in both directions.
+ *
+ * `op` is the opcode, `d` the data (its shape depends on the opcode),
+ * `s` the sequence number, and `t` the event name. `s` and `t` are only
+ * non-null on Dispatch (op 0) frames.
+ */
+interface GatewayPayload<D = unknown> {
+  op: GatewayOpcode;
+  d: D;
+  s: number | null;
+  t: string | null;
+}
+/**
+ * Data of the HELLO frame, the first thing Discord sends after connecting.
+ * `heartbeat_interval` is in milliseconds.
+ */
+interface HelloData {
+  heartbeat_interval: number;
+}
+/**
+ * Data of the IDENTIFY frame, the login payload that starts a new session.
+ * The token is sent bare here; only REST prefixes it with "Bot ".
+ * `shard` is [shardId, shardCount] and may be omitted for a single connection.
+ */
+interface IdentifyData {
+  token: string;
+  intents: number;
+  properties: {
+    os: string;
+    browser: string;
+    device: string;
+  };
+  shard?: [shardId: number, shardCount: number];
+  presence?: GatewayPresence;
+  large_threshold?: number;
+}
+interface RequestGuildMembersData {
+  guild_id: string;
+  query?: string;
+  limit?: number;
+  presences?: boolean;
+  user_ids?: string | string[];
+  nonce?: string;
+}
+/**
+ * Data of the RESUME frame. Reattaches to an existing session after a
+ * disconnect. `seq` is the last sequence number that was processed.
+ */
+interface ResumeData {
+  token: string;
+  session_id: string;
+  seq: number;
+}
+/**
+ * Data of the READY event, the first dispatch of a new session.
+ *
+ * `session_id` and `resume_gateway_url` are what make resuming possible and
+ * must be kept: resumes go to that url specifically, not the general
+ * gateway url. Guilds arrive as stubs and fill in through GUILD_CREATE.
+ */
+interface ReadyData {
+  v: number;
+  user: {
+    id: string;
+    username: string;
+    discriminator: string;
+  };
+  session_id: string;
+  resume_gateway_url: string;
+  guilds: {
+    id: string;
+    unavailable?: boolean;
+  }[];
+  shard?: [number, number];
+  application?: {
+    id: string;
+    flags: number;
+  };
+}
+/**
+ * Response of GET /gateway/bot, fetched before connecting.
+ *
+ * `session_start_limit` is the identify budget: how many new sessions the
+ * bot may start before the window resets (`reset_after` is in ms).
+ */
+interface GatewayBotInfo {
+  url: string;
+  shards: number;
+  session_start_limit: {
+    total: number;
+    remaining: number;
+    reset_after: number;
+    max_concurrency: number;
+  };
+}
+//#endregion
+//#region packages/gateway/src/shard.d.ts
+/** The connection states a Shard moves through. See the diagram in this file's header. */
+declare enum ShardState {
+  Idle = "idle",
+  Connecting = "connecting",
+  WaitingForHello = "waiting-for-hello",
+  Identifying = "identifying",
+  Resuming = "resuming",
+  Ready = "ready",
+  Reconnecting = "reconnecting",
+  Disconnected = "disconnected"
+}
+/**
+ * Options for a Shard. `url` comes from GET /gateway/bot; `intents` is the
+ * combined bitfield; `shard` is [shardId, shardCount] and defaults to a
+ * single connection.
+ */
+interface ShardOptions {
+  url: string;
+  token: string;
+  intents: number;
+  shard?: [number, number];
+  presence?: GatewayPresence;
+  largeThreshold?: number;
+  identifyGate?: IdentifyGate;
+  logger?: Logger;
+}
+/** Details of a scheduled reconnect. `resume` tells whether the session will be resumed or re-identified. */
+interface ReconnectInfo {
+  attempt: number;
+  delayMs: number;
+  resume: boolean;
+  reason: string;
+}
+/** Why a shard (or client) ended for good. `fatal` means a close code retrying can't fix. */
+interface CloseInfo {
+  code: number;
+  reason: string;
+  fatal: boolean;
+}
+/**
+ * Events a Shard emits. "closed" fires only when the shard is done for
+ * good; ordinary drops surface as "reconnecting" followed by "resumed" or
+ * "ready". Every dispatch, including READY and RESUMED, also flows through
+ * the generic "dispatch" event.
+ */
+interface Shard {
+  on(event: "ready", listener: (data: ReadyData) => void): this;
+  on(event: "resumed", listener: () => void): this;
+  on(event: "dispatch", listener: (eventName: string, data: unknown) => void): this;
+  on(event: "reconnecting", listener: (info: ReconnectInfo) => void): this;
+  on(event: "closed", listener: (info: CloseInfo) => void): this;
+  emit(event: "ready", data: ReadyData): boolean;
+  emit(event: "resumed"): boolean;
+  emit(event: "dispatch", eventName: string, data: unknown): boolean;
+  emit(event: "reconnecting", info: ReconnectInfo): boolean;
+  emit(event: "closed", info: CloseInfo): boolean;
+}
+/**
+ * One gateway connection. Connects, identifies, heartbeats, and keeps
+ * itself alive: ordinary drops are recovered internally with a session
+ * resume (or a fresh identify when the session is gone), with exponential
+ * backoff. Only a fatal close code or `disconnect()` ends it permanently.
+ */
+declare class Shard extends EventEmitter {
+  private readonly options;
+  private readonly log;
+  private readonly token;
+  /**
+   * The live transport, replaced wholesale on every reconnect. Doubles as
+   * the staleness guard: async work captures the connection it belongs to
+   * and bails when `this.connection` no longer matches.
+   */
+  private connection;
+  private heartbeat;
+  private sendLimiter;
+  /** Which handshake the next HELLO should trigger. */
+  private handshake;
+  private currentState;
+  /** Session state. Survives reconnects and is required for resuming. */
+  private sequence;
+  private sessionId;
+  private resumeGatewayUrl;
+  private reconnectAttempts;
+  private reconnectTimer;
+  private helloTimer;
+  private forceCloseTimer;
+  private intentionalClose;
+  private lastIdentifyAt;
+  /** Non-heartbeat sends chain here so budget delays can't reorder them. */
+  private sendChain;
+  /** Settles the promise returned by connect() on first READY or fatal close. */
+  private pendingConnect;
+  constructor(options: ShardOptions);
+  /** The current connection state. */
+  get state(): ShardState;
+  /** Heartbeat round-trip time in ms, or null before the first ack. */
+  get latencyMs(): number | null;
+  /** Updates this shard's presence. */
+  updatePresence(presence: GatewayPresence): Promise<void>;
+  /** Requests members for one guild on this shard. */
+  requestGuildMembers(request: RequestGuildMembersData): Promise<void>;
+  /**
+   * Connects and logs in. Resolves once the shard is READY; rejects on a
+   * fatal close (bad token, disallowed intents). After it resolves, the
+   * shard handles drops and reconnects on its own.
+   */
+  connect(): Promise<void>;
+  /**
+   * Closes the connection permanently and disables auto-reconnect.
+   * The default close code 1000 tells Discord to discard the session.
+   */
+  disconnect(code?: number, reason?: string): void;
+  private startConnection;
+  private handlePayload;
+  /** Handles HELLO: starts the heartbeat loop, then identifies or resumes. */
+  private handleHello;
+  /** Sends IDENTIFY, starting a new session. */
+  private identify;
+  /**
+   * Sends RESUME.
+   *
+   * Discord replays every event after `seq` in order and then sends RESUMED,
+   * so no events are lost and no identify is spent.
+   */
+  private resume;
+  /**
+   * Handles a dispatch.
+   *
+   * READY and RESUMED are treated specially because they carry session state.
+   * Every dispatch is then emitted through the generic "dispatch" event.
+   */
+  private handleDispatch;
+  /**
+   * Sends one payload, respecting the outbound limit.
+   *
+   * Heartbeats use reserved slots and skip the queue, because a delayed
+   * heartbeat makes the connection look dead. Everything else goes through a
+   * FIFO chain so a budget delay cannot reorder payloads.
+   */
+  private enqueueSend;
+  /** Waits out the send budget if needed, then writes unless the connection was replaced. */
+  private writeWhenAllowed;
+  /**
+   * Kills the current connection so the reconnect machinery replaces it.
+   * For recoverable teardowns only; disconnect() is the permanent version.
+   */
+  private recycle;
+  /**
+   * Asks the connection to close, with a deadline: if the close handshake
+   * never completes, the close is declared locally after the grace period
+   * (1006 = closed abnormally).
+   */
+  private closeConnection;
+  /**
+   * The single teardown path for a live connection. Every ending funnels
+   * through here exactly once; the identity guard makes duplicate calls
+   * (the socket's close event racing the force timer) no-ops.
+   */
+  private finalizeClose;
+  /** Decides what a close means: stop for good, or schedule a comeback. */
+  private settleClose;
+  /** Plans resume-vs-identify and the backoff, then waits it out. */
+  private scheduleReconnect;
+  private setState;
+  private assertReady;
+}
+//#endregion
+//#region packages/gateway/src/manager.d.ts
+type ShardPlan = "auto" | number | {
+  total: number;
+  ids?: readonly number[];
+};
+interface ShardManagerOptions {
+  gateway: GatewayBotInfo;
+  token: string;
+  intents: number;
+  shards?: ShardPlan;
+  presence?: GatewayPresence;
+  largeThreshold?: number;
+  logger?: Logger;
+}
+interface ShardManager {
+  on(event: "ready", listener: (sessions: readonly ReadyData[]) => void): this;
+  on(event: "dispatch", listener: (shardId: number, eventName: string, data: unknown) => void): this;
+  on(event: "resumed", listener: (shardId: number) => void): this;
+  on(event: "reconnecting", listener: (shardId: number, info: ReconnectInfo) => void): this;
+  on(event: "closed", listener: (shardId: number, info: CloseInfo) => void): this;
+  emit(event: "ready", sessions: readonly ReadyData[]): boolean;
+  emit(event: "dispatch", shardId: number, eventName: string, data: unknown): boolean;
+  emit(event: "resumed", shardId: number): boolean;
+  emit(event: "reconnecting", shardId: number, info: ReconnectInfo): boolean;
+  emit(event: "closed", shardId: number, info: CloseInfo): boolean;
+}
+/** Owns a bot's shard set and identify concurrency. */
+declare class ShardManager extends EventEmitter {
+  private readonly options;
+  private readonly shardsById;
+  private readonly readyById;
+  private started;
+  readonly totalShards: number;
+  readonly shardIds: readonly number[];
+  constructor(options: ShardManagerOptions);
+  /** Connects every assigned shard and resolves when all are ready. */
+  connect(): Promise<void>;
+  /** Permanently closes every shard. */
+  destroy(reason?: string): void;
+  /** Sends one member request to the shard that owns its guild. */
+  requestGuildMembers(request: RequestGuildMembersData): Promise<void>;
+  /** Applies a presence to every assigned shard. */
+  updatePresence(presence: GatewayPresence): Promise<void>;
+  /** Returns the current heartbeat latency for each shard. */
+  get latencies(): ReadonlyMap<number, number | null>;
+  get averageLatencyMs(): number | null;
+  private shardForGuild;
+}
+/** Calculates the shard that owns a guild. */
+declare function shardIdForGuild(guildId: string, shardCount: number): number;
+//#endregion
+//#region packages/client/src/domains/cached.d.ts
+/**
+ * Shared get/peek/pull triad for domains keyed by a single id.
+ * get = cache first, network on miss; peek = sync cache only;
+ * pull = network always, cache refreshed.
+ */
+declare abstract class CachedDomain<Raw, Value> {
+  protected readonly ctx: StructureContext;
+  protected readonly store: CacheStore<Raw>;
+  protected constructor(ctx: StructureContext, store: CacheStore<Raw>);
+  protected abstract route(id: string): RoutePath;
+  protected abstract hydrate(raw: Raw): Value;
+  get(id: string): Promise<Value>;
+  peek(id: string): Value | undefined;
+  pull(id: string): Promise<Value>;
+}
+//#endregion
+//#region packages/client/src/domains/channels.d.ts
+/** Channel cache accessors and REST operations. */
+declare class ChannelsDomain extends CachedDomain<Channel$1, Channel> {
+  constructor(ctx: StructureContext);
+  protected route(id: string): RoutePath;
+  protected hydrate(raw: Channel$1): Channel;
+  edit(channelId: string, input: ChannelEditInput, audit?: AuditLogOptions): Promise<Channel>;
+  delete(channelId: string, audit?: AuditLogOptions): Promise<Channel>;
+  typing(channelId: string): Promise<void>;
+}
+//#endregion
+//#region packages/client/src/domains/guilds.d.ts
+/** Guild cache accessors. */
+declare class GuildsDomain extends CachedDomain<Guild$1, Guild> {
+  constructor(ctx: StructureContext);
+  protected route(id: string): RoutePath;
+  protected hydrate(raw: Guild$1): Guild;
+}
+//#endregion
+//#region packages/client/src/domains/members.d.ts
+/** Guild member cache accessors and REST operations. */
+declare class MembersDomain {
+  private readonly ctx;
+  constructor(ctx: StructureContext);
+  get(guildId: string, userId: string): Promise<GuildMember>;
+  peek(guildId: string, userId: string): GuildMember | undefined;
+  pull(guildId: string, userId: string): Promise<GuildMember>;
+  edit(guildId: string, userId: string, input: MemberEditInput): Promise<GuildMember>;
+  kick(guildId: string, userId: string, audit?: AuditLogOptions): Promise<void>;
+  ban(guildId: string, userId: string, input?: BanInput): Promise<void>;
+  unban(guildId: string, userId: string, audit?: AuditLogOptions): Promise<void>;
+  addRole(guildId: string, userId: string, roleId: string, audit?: AuditLogOptions): Promise<void>;
+  removeRole(guildId: string, userId: string, roleId: string, audit?: AuditLogOptions): Promise<void>;
+  private hydrated;
+}
+//#endregion
+//#region packages/client/src/domains/messages.d.ts
+/** Message cache accessors and REST operations. */
+declare class MessagesDomain {
+  private readonly ctx;
+  constructor(ctx: StructureContext);
+  get(channelId: string, messageId: string): Promise<Message>;
+  peek(channelId: string, messageId: string): Message | undefined;
+  pull(channelId: string, messageId: string): Promise<Message>;
+  send(channelId: string, input: Sendable): Promise<Message>;
+  edit(channelId: string, messageId: string, input: Sendable): Promise<Message>;
+  delete(channelId: string, messageId: string): Promise<void>;
+  private cacheMessage;
+}
+//#endregion
+//#region packages/client/src/domains/pins.d.ts
+/** Pin REST operations. */
+declare class PinsDomain {
+  private readonly ctx;
+  constructor(ctx: StructureContext);
+  add(channelId: string, messageId: string): Promise<void>;
+  remove(channelId: string, messageId: string): Promise<void>;
+  private setPinned;
+}
+//#endregion
+//#region packages/client/src/domains/reactions.d.ts
+/** Reaction REST operations. */
+declare class ReactionsDomain {
+  private readonly ctx;
+  constructor(ctx: StructureContext);
+  /** Adds the bot's reaction. */
+  add(channelId: string, messageId: string, emoji: string): Promise<void>;
+  /** Removes one user's reaction; the bot's own when no user id is given. */
+  remove(channelId: string, messageId: string, emoji: string, userId?: string): Promise<void>;
+  /** Removes every reaction, or every reaction for one emoji. */
+  clear(channelId: string, messageId: string, emoji?: string): Promise<void>;
+}
+//#endregion
+//#region packages/client/src/domains/roles.d.ts
+/** Role cache accessors and REST operations. */
+declare class RolesDomain {
+  private readonly ctx;
+  constructor(ctx: StructureContext);
+  get(guildId: string, roleId: string): Promise<Role>;
+  peek(guildId: string, roleId: string): Role | undefined;
+  pull(guildId: string, roleId: string): Promise<Role>;
+  list(guildId: string): Promise<ReadonlyMap<string, Role>>;
+  create(guildId: string, input?: RoleEditInput, audit?: AuditLogOptions): Promise<Role>;
+  edit(guildId: string, roleId: string, input: RoleEditInput, audit?: AuditLogOptions): Promise<Role>;
+  delete(guildId: string, roleId: string, audit?: AuditLogOptions): Promise<void>;
+}
+//#endregion
+//#region packages/client/src/domains/users.d.ts
+/** User cache accessors. */
+declare class UsersDomain extends CachedDomain<User$1, User> {
+  constructor(ctx: StructureContext);
+  protected route(id: string): RoutePath;
+  protected hydrate(raw: User$1): User;
+}
+//#endregion
+//#region packages/client/src/modules.d.ts
+interface EuniaModule {
+  readonly name: string;
+  readonly dependsOn?: readonly string[];
+  setup?(client: Client): Awaitable$1<void>;
+  start?(client: Client): Awaitable$1<void>;
+  stop?(client: Client): Awaitable$1<void>;
+}
+/** Orders modules so every dependency starts first. */
+declare function orderModules(modules: readonly EuniaModule[]): readonly EuniaModule[];
+//#endregion
+//#region packages/client/src/options.d.ts
+type IntentInput = number | readonly number[];
+interface ClientGatewayOptions {
+  readonly shards?: ShardPlan;
+  readonly presence?: GatewayPresence;
+  readonly largeThreshold?: number;
+}
+interface ClientCommandOptions extends CommandManagerOptions {
+  readonly commands?: readonly CommandNode[];
+  readonly publishOnStart?: false | CommandPublishTarget;
+}
+interface ClientOptions {
+  readonly token: string;
+  readonly intents: IntentInput;
+  readonly applicationId?: string;
+  readonly botId?: string;
+  readonly ownerIds?: readonly string[];
+  readonly rest?: Omit<RestOptions, "token">;
+  readonly gateway?: ClientGatewayOptions;
+  readonly cache?: CacheOptions | StructureCache;
+  readonly commands?: ClientCommandOptions;
+  readonly modules?: readonly EuniaModule[];
+  readonly logger?: Logger;
+}
+declare function resolveIntents(intents: IntentInput): number;
+//#endregion
+//#region packages/client/src/services.d.ts
+type ServiceKey = string | symbol;
+/** Stores services shared by Eunia modules. */
+declare class ServiceRegistry {
+  private readonly services;
+  provide<T>(key: ServiceKey, service: T): this;
+  get<T>(key: ServiceKey): T;
+  resolve<T>(key: ServiceKey): T | undefined;
+  has(key: ServiceKey): boolean;
+  delete(key: ServiceKey): boolean;
+  clear(): void;
+}
+//#endregion
+//#region packages/client/src/client.d.ts
+type ClientState = "idle" | "starting" | "ready" | "stopping" | "stopped" | "failed";
+interface GuildDeleteInfo {
+  readonly id: string;
+  readonly unavailable: boolean;
+  readonly guild?: Guild;
+}
+interface GuildMemberRemoveInfo {
+  readonly guildId: string;
+  readonly userId: string;
+  readonly member?: GuildMember;
+}
+interface RoleDeleteInfo {
+  readonly guildId: string;
+  readonly roleId: string;
+  readonly role?: Role;
+}
+interface MessageDeleteInfo extends MessageDeleteEvent {
+  readonly message?: Message;
+}
+interface MessageDeleteBulkInfo extends MessageDeleteBulkEvent {
+  readonly messages: readonly Message[];
+}
+interface Client {
+  embeds: EmbedRegistry;
+  components: ComponentRegistry;
+  modals: ModalRegistry;
+  on(event: "ready", listener: (user: User) => void): this;
+  on(event: "stopped", listener: () => void): this;
+  on(event: "stateChange", listener: (state: ClientState, previous: ClientState) => void): this;
+  on(event: "userUpdate", listener: (user: User, previous?: User) => void): this;
+  on(event: "guildCreate", listener: (guild: Guild) => void): this;
+  on(event: "guildUpdate", listener: (guild: Guild, previous?: Guild) => void): this;
+  on(event: "guildDelete", listener: (info: GuildDeleteInfo) => void): this;
+  on(event: "channelCreate", listener: (channel: Channel) => void): this;
+  on(event: "channelUpdate", listener: (channel: Channel, previous?: Channel) => void): this;
+  on(event: "channelDelete", listener: (channel: Channel) => void): this;
+  on(event: "messageCreate", listener: (message: Message) => void): this;
+  on(event: "messageUpdate", listener: (message: Message | undefined, previous: Message | undefined, raw: MessageUpdateEvent) => void): this;
+  on(event: "messageDelete", listener: (info: MessageDeleteInfo) => void): this;
+  on(event: "messageDeleteBulk", listener: (info: MessageDeleteBulkInfo) => void): this;
+  on(event: "guildMemberAdd", listener: (member: GuildMember) => void): this;
+  on(event: "guildMemberUpdate", listener: (member: GuildMember, previous?: GuildMember) => void): this;
+  on(event: "guildMemberRemove", listener: (info: GuildMemberRemoveInfo) => void): this;
+  on(event: "roleCreate", listener: (role: Role) => void): this;
+  on(event: "roleUpdate", listener: (role: Role, previous?: Role) => void): this;
+  on(event: "roleDelete", listener: (info: RoleDeleteInfo) => void): this;
+  on(event: "interactionCreate", listener: (interaction: Interaction) => void): this;
+  on(event: "dispatch", listener: (eventName: string, data: unknown, shardId: number) => void): this;
+  on(event: "shardReconnecting", listener: (shardId: number, info: ReconnectInfo) => void): this;
+  on(event: "shardResumed", listener: (shardId: number) => void): this;
+  on(event: "shardClosed", listener: (shardId: number, info: CloseInfo) => void): this;
+  on(event: "commandResult", listener: (result: CommandHandleResult, source: Interaction | Message) => void): this;
+  on(event: "commandError", listener: (error: CommandError, context?: CommandContext | AutocompleteContext) => void): this;
+  on(event: "clientError", listener: (error: unknown, source: string) => void): this;
+  emit(event: "ready", user: User): boolean;
+  emit(event: "stopped"): boolean;
+  emit(event: "stateChange", state: ClientState, previous: ClientState): boolean;
+  emit(event: "userUpdate", user: User, previous?: User): boolean;
+  emit(event: "guildCreate", guild: Guild): boolean;
+  emit(event: "guildUpdate", guild: Guild, previous?: Guild): boolean;
+  emit(event: "guildDelete", info: GuildDeleteInfo): boolean;
+  emit(event: "channelCreate", channel: Channel): boolean;
+  emit(event: "channelUpdate", channel: Channel, previous?: Channel): boolean;
+  emit(event: "channelDelete", channel: Channel): boolean;
+  emit(event: "messageCreate", message: Message): boolean;
+  emit(event: "messageUpdate", message: Message | undefined, previous: Message | undefined, raw: MessageUpdateEvent): boolean;
+  emit(event: "messageDelete", info: MessageDeleteInfo): boolean;
+  emit(event: "messageDeleteBulk", info: MessageDeleteBulkInfo): boolean;
+  emit(event: "guildMemberAdd", member: GuildMember): boolean;
+  emit(event: "guildMemberUpdate", member: GuildMember, previous?: GuildMember): boolean;
+  emit(event: "guildMemberRemove", info: GuildMemberRemoveInfo): boolean;
+  emit(event: "roleCreate", role: Role): boolean;
+  emit(event: "roleUpdate", role: Role, previous?: Role): boolean;
+  emit(event: "roleDelete", info: RoleDeleteInfo): boolean;
+  emit(event: "interactionCreate", interaction: Interaction): boolean;
+  emit(event: "dispatch", eventName: string, data: unknown, shardId: number): boolean;
+  emit(event: "shardReconnecting", shardId: number, info: ReconnectInfo): boolean;
+  emit(event: "shardResumed", shardId: number): boolean;
+  emit(event: "shardClosed", shardId: number, info: CloseInfo): boolean;
+  emit(event: "commandResult", result: CommandHandleResult, source: Interaction | Message): boolean;
+  emit(event: "commandError", error: CommandError, context?: CommandContext | AutocompleteContext): boolean;
+  emit(event: "clientError", error: unknown, source: string): boolean;
+}
+/** Connects Eunia's transport, cache, structures, commands, and modules. */
+declare class Client extends EventEmitter {
+  readonly rest: EuniaRest;
+  readonly cache: StructureCache;
+  readonly context: StructureContext;
+  readonly commands: CommandManager;
+  readonly services: ServiceRegistry;
+  readonly users: UsersDomain;
+  readonly guilds: GuildsDomain;
+  readonly channels: ChannelsDomain;
+  readonly messages: MessagesDomain;
+  readonly members: MembersDomain;
+  readonly roles: RolesDomain;
+  readonly reactions: ReactionsDomain;
+  readonly pins: PinsDomain;
+  private readonly log;
+  private readonly token;
+  private readonly intents;
+  private readonly gatewayOptions;
+  private readonly publishOnStart;
+  private readonly configuredModules;
+  private readonly activeModules;
+  private readonly readyByShard;
+  private gatewayManager?;
+  private currentState;
+  private startPromise?;
+  private stopPromise?;
+  private stopRequested;
+  private startupError;
+  private applicationIdValue;
+  private botIdValue;
+  constructor(options: ClientOptions);
+  get state(): ClientState;
+  get isReady(): boolean;
+  get applicationId(): string | undefined;
+  get botId(): string | undefined;
+  get self(): User | undefined;
+  get latencyMs(): number | null;
+  get latencies(): ReadonlyMap<number, number | null>;
+  get shardIds(): readonly number[];
+  get totalShards(): number;
+  get readySessions(): ReadonlyMap<number, Readonly<ReadyEvent>>;
+  use(module: EuniaModule): this;
+  start(): Promise<this>;
+  stop(): Promise<void>;
+  destroy(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  updatePresence(presence: GatewayPresence): Promise<void>;
+  requestGuildMembers(request: RequestGuildMembersData): Promise<void>;
+  /** @internal Updates identity from one shard's READY event. */
+  recordReady(ready: ReadyEvent, shardId: number): void;
+  /** @internal Sends a structure through the command framework. */
+  handleCommand(source: Interaction | Message): Promise<CommandHandleResult>;
+  private startInternal;
+  private stopInternal;
+  private stopModules;
+  private wireGateway;
+  private commandPermissions;
+  private loadPermissionResource;
+  private requireGateway;
+  private throwIfStopRequested;
+  private setState;
+  private emitSafely;
+  private reportClientError;
+}
+//#endregion
+export { API_VERSION, ActivityType, type AttachmentOptionConfig, type AuditLogOptions, type AutoDeferOptions, type AutocompleteContext, AutocompleteError, type Awaitable, type BanInput, type BooleanOptionConfig, type BuiltInCacheAdapterConfig, type BuiltInCacheDomain, ButtonListenerField, type CDNImageOptions, CDN_BASE_URL, Cache, Cache as EuniaCache, type CacheAdapter, type CacheAdapterOperation, CacheBackpressureError, type CacheBackpressureOperation, type CacheErrorContext, type CacheErrorHandler, type CacheOptions, type CachePolicy, type CacheShape, CacheStore, type CacheStoreOptions, Channel, type ChannelEditInput, type ChannelOptionConfig, Client, type ClientCommandOptions, type ClientGatewayOptions, type ClientOptions, type ClientState, type CloseInfo, Command, type CommandChoice, type CommandContext, CommandError, type CommandErrorCode, CommandExecutionError, CommandGroup, type CommandGuard, type CommandGuardFailure, type CommandHandleOptions, type CommandHandleResult, type CommandHost, type CommandKind, CommandManager, type CommandManagerOptions, type CommandMessageFactory, type CommandMessages, type CommandMiddleware, type CommandNode, type CommandNodeClass, CommandOptionError, type CommandPermissionData, type CommandPublishResult, type CommandPublishTarget, type CommandRateLimit, CommandRejection, type CommandRejectionCode, type CommandRest, CommandValidationError, ComponentRegistry, ComponentTemplates, ConsoleLogger, type CooldownRequest, type CooldownResult, type CooldownScope, type CooldownStore, CooldownStoreError, DEFAULT_CACHE_MAX_PENDING_OPERATIONS, DEFAULT_CACHE_POLICIES, DEFAULT_CACHE_READ_THROUGH_TTL, DISCORD_EPOCH, type DeferOptions, DiscordError, DuplicateCommandError, EmbedRegistry, EmbedTemplates, type EuniaModule, EuniaRest, FATAL_CLOSE_CODES, type FocusedOption, GATEWAY_VERSION, type GatewayActivity, type GatewayBotInfo, GatewayCloseCode, GatewayOpcode, type GatewayPayload, type GatewayPresence, Guild, type GuildBanInput, type GuildDeleteInfo, GuildMember, type GuildMemberRemoveInfo, type HelloData, type HttpMethod, type IdentifyData, type ImageExtension, type IntentInput, Intents, type Interaction, InteractionAlreadyAcknowledgedError, type InteractionKind, InteractionNotAcknowledgedError, type InteractionState, type ListenerButtonInput, type ListenerContext, type ListenerField, type ListenerHandler, type ListenerKind, type ListenerModalInput, type ListenerSelectInput, type LogLevel, type Logger, type LoggerOptions, type MemberEditInput, type MemoryAdapterConfig, MemoryCooldownStore, type MemoryCooldownStoreOptions, MemoryStore, type MemoryStoreOptions, type MentionableOptionConfig, Message, type MessageDeleteBulkInfo, type MessageDeleteInfo, type MessageRequestParts, MiddlewareError, type ModalFieldValue, ModalListenerField, ModalRegistry, ModalTemplatePayload, ModalTemplates, type NumericOptionConfig, type OptionAccess, OptionField, type OriginalMessage, PermissionFlags, type PrefixCommandContext, type PrefixMatch, type PrefixOptions, type PrefixResolver, type PrefixValue, type QueryValue, RateLimitExhaustedError, type ReadyData, type ReconnectInfo, type RedisAdapterConfig, RedisCacheAdapter, type RedisCacheAdapterOptions, type RedisClientLike, RegistrationFrozenError, type RequestGuildMembersData, type RequestPath, type ResolvedAttachment, type ResolvedCachePolicy, type ResolvedChannel, type ResolvedMentionable, type ResolvedRole, type ResolvedStructureSource, type ResolvedUser, type RestDiagnostics, type RestFile, type RestOptions, type RestRequestOptions, type ResumeData, Role, type RoleCreateInput, type RoleDeleteInfo, type RoleEditInput, type RoleOptionConfig, type RoutePath, SelectListenerField, type Sendable, type ServiceKey, ServiceRegistry, Shard, ShardManager, type ShardManagerOptions, type ShardOptions, type ShardPlan, ShardState, SilentLogger, type SlashCommandContext, type StringOptionConfig, type StructureCache, type StructureCacheShape, type StructureContext, type TemplateMap, type TemplateRegistry, User, type UserOptionConfig, ValkeyCacheAdapter, can, canAny, cdnAssetUrl, componentTemplates, createInteraction, createLogger, defineComponents, defineEmbeds, defineModals, embedTemplates, formatLogPrefix, isInteraction, memberCacheKey, missing, modalTemplates, normalizeSendable, onButton, onModal, onSelect, option, orderModules, removeCachedGuildChannel, removeCachedGuildMember, resolveIntents, routePath, shardIdForGuild, snowflakeTimestamp, splitMessageFiles, toFlagNames, toPermissionBits, tokenizePrefix, index_d_exports as types, upsertCachedGuildChannel, upsertCachedGuildMember, upsertCachedGuildMembers, withQuery };