first commit

1 files changed, 6520 insertions, 0 deletions

diff --git a/node_modules/discord.js/typings/index.d.ts b/node_modules/discord.js/typings/index.d.ts
new file mode 100644
index 0000000..fda9b4c
--- /dev/null
+++ b/node_modules/discord.js/typings/index.d.ts
@@ -0,0 +1,6520 @@
+// DOM types required for undici
+/// <reference lib="dom" />
+
+import {
+  ActionRowBuilder as BuilderActionRow,
+  MessageActionRowComponentBuilder,
+  blockQuote,
+  bold,
+  ButtonBuilder as BuilderButtonComponent,
+  channelMention,
+  codeBlock,
+  EmbedBuilder as BuildersEmbed,
+  formatEmoji,
+  hideLinkEmbed,
+  hyperlink,
+  inlineCode,
+  italic,
+  quote,
+  roleMention,
+  ChannelSelectMenuBuilder as BuilderChannelSelectMenuComponent,
+  MentionableSelectMenuBuilder as BuilderMentionableSelectMenuComponent,
+  RoleSelectMenuBuilder as BuilderRoleSelectMenuComponent,
+  StringSelectMenuBuilder as BuilderStringSelectMenuComponent,
+  UserSelectMenuBuilder as BuilderUserSelectMenuComponent,
+  TextInputBuilder as BuilderTextInputComponent,
+  SelectMenuOptionBuilder as BuildersSelectMenuOption,
+  spoiler,
+  strikethrough,
+  time,
+  TimestampStyles,
+  underscore,
+  userMention,
+  ModalActionRowComponentBuilder,
+  ModalBuilder as BuildersModal,
+  AnyComponentBuilder,
+  ComponentBuilder,
+  type RestOrArray,
+  ApplicationCommandOptionAllowedChannelTypes,
+} from '@discordjs/builders';
+import { Awaitable, JSONEncodable } from '@discordjs/util';
+import { Collection } from '@discordjs/collection';
+import { BaseImageURLOptions, ImageURLOptions, RawFile, REST, RESTOptions } from '@discordjs/rest';
+import {
+  WebSocketManager as WSWebSocketManager,
+  IShardingStrategy,
+  IIdentifyThrottler,
+  SessionInfo,
+} from '@discordjs/ws';
+import {
+  APIActionRowComponent,
+  APIApplicationCommandInteractionData,
+  APIApplicationCommandOption,
+  APIAuditLogChange,
+  APIButtonComponent,
+  APIEmbed,
+  APIEmoji,
+  APIInteractionDataResolvedChannel,
+  APIInteractionDataResolvedGuildMember,
+  APIInteractionGuildMember,
+  APIMessage,
+  APIMessageComponent,
+  APIOverwrite,
+  APIPartialChannel,
+  APIPartialEmoji,
+  APIPartialGuild,
+  APIRole,
+  APISelectMenuComponent,
+  APITemplateSerializedSourceGuild,
+  APIUser,
+  ButtonStyle,
+  ChannelType,
+  ComponentType,
+  GatewayDispatchEvents,
+  GatewayVoiceServerUpdateDispatchData,
+  GatewayVoiceStateUpdateDispatchData,
+  GuildFeature,
+  GuildMFALevel,
+  GuildNSFWLevel,
+  GuildPremiumTier,
+  GuildVerificationLevel,
+  Locale,
+  InteractionType,
+  InviteTargetType,
+  MessageType,
+  OAuth2Scopes,
+  RESTPostAPIApplicationCommandsJSONBody,
+  Snowflake,
+  StageInstancePrivacyLevel,
+  StickerFormatType,
+  StickerType,
+  TeamMemberMembershipState,
+  WebhookType,
+  OverwriteType,
+  GuildExplicitContentFilter,
+  GuildDefaultMessageNotifications,
+  ApplicationCommandPermissionType,
+  ApplicationCommandOptionType,
+  ApplicationCommandType,
+  ActivityType,
+  GuildScheduledEventEntityType,
+  GuildScheduledEventPrivacyLevel,
+  GuildScheduledEventStatus,
+  IntegrationExpireBehavior,
+  ApplicationFlags,
+  PermissionFlagsBits,
+  ThreadMemberFlags,
+  UserFlags,
+  MessageFlags,
+  GuildSystemChannelFlags,
+  GatewayIntentBits,
+  ActivityFlags,
+  AuditLogEvent,
+  APIMessageComponentEmoji,
+  EmbedType,
+  APIActionRowComponentTypes,
+  APIModalInteractionResponseCallbackData,
+  APIModalSubmitInteraction,
+  APIMessageActionRowComponent,
+  TextInputStyle,
+  APITextInputComponent,
+  APIModalActionRowComponent,
+  APIModalComponent,
+  APISelectMenuOption,
+  APIEmbedField,
+  APIEmbedAuthor,
+  APIEmbedFooter,
+  APIEmbedImage,
+  VideoQualityMode,
+  LocalizationMap,
+  LocaleString,
+  MessageActivityType,
+  APIAttachment,
+  APIChannel,
+  ThreadAutoArchiveDuration,
+  FormattingPatterns,
+  APIEmbedProvider,
+  AuditLogOptionsType,
+  TextChannelType,
+  ChannelFlags,
+  SortOrderType,
+  APIMessageStringSelectInteractionData,
+  APIMessageUserSelectInteractionData,
+  APIStringSelectComponent,
+  APIUserSelectComponent,
+  APIRoleSelectComponent,
+  APIMentionableSelectComponent,
+  APIChannelSelectComponent,
+  APIGuildMember,
+  APIMessageRoleSelectInteractionData,
+  APIMessageMentionableSelectInteractionData,
+  APIMessageChannelSelectInteractionData,
+  AutoModerationRuleKeywordPresetType,
+  AutoModerationActionType,
+  AutoModerationRuleEventType,
+  AutoModerationRuleTriggerType,
+  AuditLogRuleTriggerType,
+  GatewayAutoModerationActionExecutionDispatchData,
+  APIAutoModerationRule,
+  ForumLayoutType,
+  ApplicationRoleConnectionMetadataType,
+  APIApplicationRoleConnectionMetadata,
+  ImageFormat,
+  GuildMemberFlags,
+  RESTGetAPIGuildThreadsResult,
+  RESTGetAPIGuildOnboardingResult,
+  APIGuildOnboardingPrompt,
+  APIGuildOnboardingPromptOption,
+  GuildOnboardingPromptType,
+  AttachmentFlags,
+  RoleFlags,
+} from 'discord-api-types/v10';
+import { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { Stream } from 'node:stream';
+import { MessagePort, Worker } from 'node:worker_threads';
+import * as WebSocket from 'ws';
+import {
+  RawActivityData,
+  RawAnonymousGuildData,
+  RawApplicationCommandData,
+  RawApplicationData,
+  RawBaseGuildData,
+  RawChannelData,
+  RawClientApplicationData,
+  RawDMChannelData,
+  RawEmojiData,
+  RawGuildAuditLogData,
+  RawGuildAuditLogEntryData,
+  RawGuildBanData,
+  RawGuildChannelData,
+  RawGuildData,
+  RawGuildEmojiData,
+  RawGuildMemberData,
+  RawGuildPreviewData,
+  RawGuildScheduledEventData,
+  RawGuildTemplateData,
+  RawIntegrationApplicationData,
+  RawIntegrationData,
+  RawInteractionData,
+  RawInviteData,
+  RawInviteGuildData,
+  RawInviteStageInstance,
+  RawMessageButtonInteractionData,
+  RawMessageComponentInteractionData,
+  RawMessageData,
+  RawMessagePayloadData,
+  RawMessageReactionData,
+  RawOAuth2GuildData,
+  RawPartialGroupDMChannelData,
+  RawPartialMessageData,
+  RawPermissionOverwriteData,
+  RawPresenceData,
+  RawReactionEmojiData,
+  RawRichPresenceAssets,
+  RawRoleData,
+  RawStageInstanceData,
+  RawStickerData,
+  RawStickerPackData,
+  RawTeamData,
+  RawTeamMemberData,
+  RawThreadChannelData,
+  RawThreadMemberData,
+  RawTypingData,
+  RawUserData,
+  RawVoiceRegionData,
+  RawVoiceStateData,
+  RawWebhookData,
+  RawWelcomeChannelData,
+  RawWelcomeScreenData,
+  RawWidgetData,
+  RawWidgetMemberData,
+} from './rawDataTypes';
+
+declare module 'node:events' {
+  class EventEmitter {
+    // Add type overloads for client events.
+    public static once<E extends EventEmitter, K extends keyof ClientEvents>(
+      eventEmitter: E,
+      eventName: E extends Client ? K : string,
+    ): Promise<E extends Client ? ClientEvents[K] : any[]>;
+    public static on<E extends EventEmitter, K extends keyof ClientEvents>(
+      eventEmitter: E,
+      eventName: E extends Client ? K : string,
+    ): AsyncIterableIterator<E extends Client ? ClientEvents[K] : any>;
+  }
+}
+
+//#region Classes
+
+export class Activity {
+  private constructor(presence: Presence, data?: RawActivityData);
+  public readonly presence: Presence;
+  public applicationId: Snowflake | null;
+  public assets: RichPresenceAssets | null;
+  public buttons: string[];
+  public get createdAt(): Date;
+  public createdTimestamp: number;
+  public details: string | null;
+  public emoji: Emoji | null;
+  public flags: Readonly<ActivityFlagsBitField>;
+  public name: string;
+  public party: {
+    id: string | null;
+    size: [number, number];
+  } | null;
+  public state: string | null;
+  public timestamps: {
+    start: Date | null;
+    end: Date | null;
+  } | null;
+  public type: ActivityType;
+  public url: string | null;
+  public equals(activity: Activity): boolean;
+  public toString(): string;
+}
+
+export type ActivityFlagsString = keyof typeof ActivityFlags;
+
+export interface BaseComponentData {
+  type: ComponentType;
+}
+
+export type MessageActionRowComponentData =
+  | JSONEncodable<APIMessageActionRowComponent>
+  | ButtonComponentData
+  | StringSelectMenuComponentData
+  | UserSelectMenuComponentData
+  | RoleSelectMenuComponentData
+  | MentionableSelectMenuComponentData
+  | ChannelSelectMenuComponentData;
+
+export type ModalActionRowComponentData = JSONEncodable<APIModalActionRowComponent> | TextInputComponentData;
+
+export type ActionRowComponentData = MessageActionRowComponentData | ModalActionRowComponentData;
+
+export type ActionRowComponent = MessageActionRowComponent | ModalActionRowComponent;
+
+export interface ActionRowData<T extends JSONEncodable<APIActionRowComponentTypes> | ActionRowComponentData>
+  extends BaseComponentData {
+  components: T[];
+}
+
+export class ActionRowBuilder<T extends AnyComponentBuilder = AnyComponentBuilder> extends BuilderActionRow<T> {
+  constructor(
+    data?: Partial<
+      | ActionRowData<ActionRowComponentData | JSONEncodable<APIActionRowComponentTypes>>
+      | APIActionRowComponent<APIMessageActionRowComponent | APIModalActionRowComponent>
+    >,
+  );
+  public static from<T extends AnyComponentBuilder = AnyComponentBuilder>(
+    other:
+      | JSONEncodable<APIActionRowComponent<ReturnType<T['toJSON']>>>
+      | APIActionRowComponent<ReturnType<T['toJSON']>>,
+  ): ActionRowBuilder<T>;
+}
+
+export type MessageActionRowComponent =
+  | ButtonComponent
+  | StringSelectMenuComponent
+  | UserSelectMenuComponent
+  | RoleSelectMenuComponent
+  | MentionableSelectMenuComponent
+  | ChannelSelectMenuComponent;
+export type ModalActionRowComponent = TextInputComponent;
+
+export class ActionRow<T extends MessageActionRowComponent | ModalActionRowComponent> extends Component<
+  APIActionRowComponent<APIMessageActionRowComponent | APIModalActionRowComponent>
+> {
+  private constructor(data: APIActionRowComponent<APIMessageActionRowComponent | APIModalActionRowComponent>);
+  public readonly components: T[];
+  public toJSON(): APIActionRowComponent<ReturnType<T['toJSON']>>;
+}
+
+export class ActivityFlagsBitField extends BitField<ActivityFlagsString> {
+  public static Flags: typeof ActivityFlags;
+  public static resolve(bit?: BitFieldResolvable<ActivityFlagsString, number>): number;
+}
+
+export abstract class AnonymousGuild extends BaseGuild {
+  protected constructor(client: Client<true>, data: RawAnonymousGuildData, immediatePatch?: boolean);
+  public banner: string | null;
+  public description: string | null;
+  public nsfwLevel: GuildNSFWLevel;
+  public premiumSubscriptionCount: number | null;
+  public splash: string | null;
+  public vanityURLCode: string | null;
+  public verificationLevel: GuildVerificationLevel;
+  public bannerURL(options?: ImageURLOptions): string | null;
+  public splashURL(options?: ImageURLOptions): string | null;
+}
+
+export class AutoModerationActionExecution {
+  private constructor(data: GatewayAutoModerationActionExecutionDispatchData, guild: Guild);
+  public guild: Guild;
+  public action: AutoModerationAction;
+  public ruleId: Snowflake;
+  public ruleTriggerType: AutoModerationRuleTriggerType;
+  public get user(): User | null;
+  public userId: Snowflake;
+  public get channel(): GuildTextBasedChannel | ForumChannel | null;
+  public channelId: Snowflake | null;
+  public get member(): GuildMember | null;
+  public messageId: Snowflake | null;
+  public alertSystemMessageId: Snowflake | null;
+  public content: string;
+  public matchedKeyword: string | null;
+  public matchedContent: string | null;
+  public get autoModerationRule(): AutoModerationRule | null;
+}
+
+export class AutoModerationRule extends Base {
+  private constructor(client: Client<true>, data: APIAutoModerationRule, guild: Guild);
+  public id: Snowflake;
+  public guild: Guild;
+  public name: string;
+  public creatorId: Snowflake;
+  public eventType: AutoModerationRuleEventType;
+  public triggerType: AutoModerationRuleTriggerType;
+  public triggerMetadata: AutoModerationTriggerMetadata;
+  public actions: AutoModerationAction[];
+  public enabled: boolean;
+  public exemptRoles: Collection<Snowflake, Role>;
+  public exemptChannels: Collection<Snowflake, GuildBasedChannel>;
+  public edit(options: AutoModerationRuleEditOptions): Promise<AutoModerationRule>;
+  public delete(reason?: string): Promise<void>;
+  public setName(name: string, reason?: string): Promise<AutoModerationRule>;
+  public setEventType(eventType: AutoModerationRuleEventType, reason?: string): Promise<AutoModerationRule>;
+  public setKeywordFilter(keywordFilter: string[], reason?: string): Promise<AutoModerationRule>;
+  public setRegexPatterns(regexPatterns: string[], reason?: string): Promise<AutoModerationRule>;
+  public setPresets(presets: AutoModerationRuleKeywordPresetType[], reason?: string): Promise<AutoModerationRule>;
+  public setAllowList(allowList: string[], reason?: string): Promise<AutoModerationRule>;
+  public setMentionTotalLimit(mentionTotalLimit: number, reason?: string): Promise<AutoModerationRule>;
+  public setMentionRaidProtectionEnabled(
+    mentionRaidProtectionEnabled: boolean,
+    reason?: string,
+  ): Promise<AutoModerationRule>;
+  public setActions(actions: AutoModerationActionOptions[], reason?: string): Promise<AutoModerationRule>;
+  public setEnabled(enabled?: boolean, reason?: string): Promise<AutoModerationRule>;
+  public setExemptRoles(
+    roles: Collection<Snowflake, Role> | RoleResolvable[],
+    reason?: string,
+  ): Promise<AutoModerationRule>;
+  public setExemptChannels(
+    channels: Collection<Snowflake, GuildBasedChannel> | GuildChannelResolvable[],
+    reason?: string,
+  ): Promise<AutoModerationRule>;
+}
+
+export abstract class Application extends Base {
+  protected constructor(client: Client<true>, data: RawApplicationData);
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public description: string | null;
+  public icon: string | null;
+  public id: Snowflake;
+  public name: string | null;
+  public coverURL(options?: ImageURLOptions): string | null;
+  public iconURL(options?: ImageURLOptions): string | null;
+  public toJSON(): unknown;
+  public toString(): string | null;
+}
+
+export class ApplicationCommand<PermissionsFetchType = {}> extends Base {
+  private constructor(client: Client<true>, data: RawApplicationCommandData, guild?: Guild, guildId?: Snowflake);
+  public applicationId: Snowflake;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public defaultMemberPermissions: Readonly<PermissionsBitField> | null;
+  public description: string;
+  public descriptionLocalizations: LocalizationMap | null;
+  public descriptionLocalized: string | null;
+  public dmPermission: boolean | null;
+  public guild: Guild | null;
+  public guildId: Snowflake | null;
+  public get manager(): ApplicationCommandManager;
+  public id: Snowflake;
+  public name: string;
+  public nameLocalizations: LocalizationMap | null;
+  public nameLocalized: string | null;
+  public options: (ApplicationCommandOption & { nameLocalized?: string; descriptionLocalized?: string })[];
+  public permissions: ApplicationCommandPermissionsManager<
+    PermissionsFetchType,
+    PermissionsFetchType,
+    Guild | null,
+    Snowflake
+  >;
+  public type: ApplicationCommandType;
+  public version: Snowflake;
+  public nsfw: boolean;
+  public delete(): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public edit(data: Partial<ApplicationCommandData>): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setName(name: string): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setNameLocalizations(nameLocalizations: LocalizationMap): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setDescription(description: string): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setDescriptionLocalizations(
+    descriptionLocalizations: LocalizationMap,
+  ): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setDefaultMemberPermissions(
+    defaultMemberPermissions: PermissionResolvable | null,
+  ): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setDMPermission(dmPermission?: boolean): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public setOptions(options: ApplicationCommandOptionData[]): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public equals(
+    command: ApplicationCommand | ApplicationCommandData | RawApplicationCommandData,
+    enforceOptionOrder?: boolean,
+  ): boolean;
+  public static optionsEqual(
+    existing: ApplicationCommandOption[],
+    options: ApplicationCommandOption[] | ApplicationCommandOptionData[] | APIApplicationCommandOption[],
+    enforceOptionOrder?: boolean,
+  ): boolean;
+  private static _optionEquals(
+    existing: ApplicationCommandOption,
+    options: ApplicationCommandOption | ApplicationCommandOptionData | APIApplicationCommandOption,
+    enforceOptionOrder?: boolean,
+  ): boolean;
+  private static transformOption(option: ApplicationCommandOptionData, received?: boolean): unknown;
+  private static transformCommand(command: ApplicationCommandData): RESTPostAPIApplicationCommandsJSONBody;
+  private static isAPICommandData(command: object): command is RESTPostAPIApplicationCommandsJSONBody;
+}
+
+export class ApplicationRoleConnectionMetadata {
+  private constructor(data: APIApplicationRoleConnectionMetadata);
+  public name: string;
+  public nameLocalizations: LocalizationMap | null;
+  public description: string;
+  public descriptionLocalizations: LocalizationMap | null;
+  public key: string;
+  public type: ApplicationRoleConnectionMetadataType;
+}
+
+export type ApplicationResolvable = Application | Activity | Snowflake;
+
+export class ApplicationFlagsBitField extends BitField<ApplicationFlagsString> {
+  public static Flags: typeof ApplicationFlags;
+  public static resolve(bit?: BitFieldResolvable<ApplicationFlagsString, number>): number;
+}
+
+export type AutoModerationRuleResolvable = AutoModerationRule | Snowflake;
+
+export abstract class Base {
+  public constructor(client: Client<true>);
+  public readonly client: Client<true>;
+  public toJSON(...props: Record<string, boolean | string>[]): unknown;
+  public valueOf(): string;
+}
+
+export class BaseClient extends EventEmitter {
+  public constructor(options?: ClientOptions | WebhookClientOptions);
+  private decrementMaxListeners(): void;
+  private incrementMaxListeners(): void;
+
+  public options: ClientOptions | WebhookClientOptions;
+  public rest: REST;
+  public destroy(): void;
+  public toJSON(...props: Record<string, boolean | string>[]): unknown;
+}
+
+export type GuildCacheMessage<Cached extends CacheType> = CacheTypeReducer<
+  Cached,
+  Message<true>,
+  APIMessage,
+  Message | APIMessage,
+  Message | APIMessage
+>;
+
+export type BooleanCache<T extends CacheType> = T extends 'cached' ? true : false;
+
+export abstract class CommandInteraction<Cached extends CacheType = CacheType> extends BaseInteraction<Cached> {
+  public type: InteractionType.ApplicationCommand;
+  public get command(): ApplicationCommand | ApplicationCommand<{ guild: GuildResolvable }> | null;
+  public options: Omit<
+    CommandInteractionOptionResolver<Cached>,
+    | 'getMessage'
+    | 'getFocused'
+    | 'getMentionable'
+    | 'getRole'
+    | 'getAttachment'
+    | 'getNumber'
+    | 'getInteger'
+    | 'getString'
+    | 'getChannel'
+    | 'getBoolean'
+    | 'getSubcommandGroup'
+    | 'getSubcommand'
+  >;
+  public channelId: Snowflake;
+  public commandId: Snowflake;
+  public commandName: string;
+  public commandType: ApplicationCommandType;
+  public commandGuildId: Snowflake | null;
+  public deferred: boolean;
+  public ephemeral: boolean | null;
+  public replied: boolean;
+  public webhook: InteractionWebhook;
+  public inGuild(): this is CommandInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is CommandInteraction<'cached'>;
+  public inRawGuild(): this is CommandInteraction<'raw'>;
+  public deferReply(
+    options: InteractionDeferReplyOptions & { fetchReply: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
+  public editReply(
+    options: string | MessagePayload | InteractionEditReplyOptions,
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
+  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(
+    options: string | MessagePayload | InteractionReplyOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public showModal(
+    modal:
+      | JSONEncodable<APIModalInteractionResponseCallbackData>
+      | ModalComponentData
+      | APIModalInteractionResponseCallbackData,
+  ): Promise<void>;
+  public awaitModalSubmit(
+    options: AwaitModalSubmitOptions<ModalSubmitInteraction>,
+  ): Promise<ModalSubmitInteraction<Cached>>;
+  private transformOption(
+    option: APIApplicationCommandOption,
+    resolved: APIApplicationCommandInteractionData['resolved'],
+  ): CommandInteractionOption<Cached>;
+  private transformResolved(
+    resolved: APIApplicationCommandInteractionData['resolved'],
+  ): CommandInteractionResolvedData<Cached>;
+}
+
+export class InteractionResponse<Cached extends boolean = boolean> {
+  private constructor(interaction: Interaction, id?: Snowflake);
+  public interaction: Interaction<WrapBooleanCache<Cached>>;
+  public client: Client;
+  public id: Snowflake;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public awaitMessageComponent<T extends MessageComponentType>(
+    options?: AwaitMessageCollectorOptionsParams<T, Cached>,
+  ): Promise<MappedInteractionTypes<Cached>[T]>;
+  public createMessageComponentCollector<T extends MessageComponentType>(
+    options?: MessageCollectorOptionsParams<T, Cached>,
+  ): InteractionCollector<MappedInteractionTypes<Cached>[T]>;
+  public delete(): Promise<void>;
+  public edit(options: string | MessagePayload | WebhookMessageEditOptions): Promise<Message>;
+  public fetch(): Promise<Message>;
+}
+
+export abstract class BaseGuild extends Base {
+  protected constructor(client: Client<true>, data: RawBaseGuildData);
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public features: `${GuildFeature}`[];
+  public icon: string | null;
+  public id: Snowflake;
+  public name: string;
+  public get nameAcronym(): string;
+  public get partnered(): boolean;
+  public get verified(): boolean;
+  public fetch(): Promise<Guild>;
+  public iconURL(options?: ImageURLOptions): string | null;
+  public toString(): string;
+}
+
+export class BaseGuildEmoji extends Emoji {
+  protected constructor(client: Client<true>, data: RawGuildEmojiData, guild: Guild | GuildPreview);
+  public available: boolean | null;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public guild: Guild | GuildPreview;
+  public id: Snowflake;
+  public managed: boolean | null;
+  public requiresColons: boolean | null;
+}
+
+export class BaseGuildTextChannel extends TextBasedChannelMixin(GuildChannel, true) {
+  protected constructor(guild: Guild, data?: RawGuildChannelData, client?: Client<true>, immediatePatch?: boolean);
+  public defaultAutoArchiveDuration?: ThreadAutoArchiveDuration;
+  public rateLimitPerUser: number | null;
+  public nsfw: boolean;
+  public threads: GuildTextThreadManager<AllowedThreadTypeForTextChannel | AllowedThreadTypeForNewsChannel>;
+  public topic: string | null;
+  public createInvite(options?: InviteCreateOptions): Promise<Invite>;
+  public fetchInvites(cache?: boolean): Promise<Collection<string, Invite>>;
+  public setDefaultAutoArchiveDuration(
+    defaultAutoArchiveDuration: ThreadAutoArchiveDuration,
+    reason?: string,
+  ): Promise<this>;
+  public setTopic(topic: string | null, reason?: string): Promise<this>;
+  public setType(type: ChannelType.GuildText, reason?: string): Promise<TextChannel>;
+  public setType(type: ChannelType.GuildAnnouncement, reason?: string): Promise<NewsChannel>;
+}
+
+export class BaseGuildVoiceChannel extends TextBasedChannelMixin(GuildChannel, true, [
+  'lastPinTimestamp',
+  'lastPinAt',
+]) {
+  public constructor(guild: Guild, data?: RawGuildChannelData);
+  public bitrate: number;
+  public get full(): boolean;
+  public get joinable(): boolean;
+  public get members(): Collection<Snowflake, GuildMember>;
+  public nsfw: boolean;
+  public rateLimitPerUser: number | null;
+  public rtcRegion: string | null;
+  public userLimit: number;
+  public videoQualityMode: VideoQualityMode | null;
+  public createInvite(options?: InviteCreateOptions): Promise<Invite>;
+  public fetchInvites(cache?: boolean): Promise<Collection<string, Invite>>;
+  public setBitrate(bitrate: number, reason?: string): Promise<this>;
+  public setRTCRegion(rtcRegion: string | null, reason?: string): Promise<this>;
+  public setUserLimit(userLimit: number, reason?: string): Promise<this>;
+  public setVideoQualityMode(videoQualityMode: VideoQualityMode, reason?: string): Promise<this>;
+}
+
+export type EnumLike<E, V> = Record<keyof E, V>;
+
+export class BitField<S extends string, N extends number | bigint = number> {
+  public constructor(bits?: BitFieldResolvable<S, N>);
+  public bitfield: N;
+  public add(...bits: BitFieldResolvable<S, N>[]): BitField<S, N>;
+  public any(bit: BitFieldResolvable<S, N>): boolean;
+  public equals(bit: BitFieldResolvable<S, N>): boolean;
+  public freeze(): Readonly<BitField<S, N>>;
+  public has(bit: BitFieldResolvable<S, N>): boolean;
+  public missing(bits: BitFieldResolvable<S, N>, ...hasParams: readonly unknown[]): S[];
+  public remove(...bits: BitFieldResolvable<S, N>[]): BitField<S, N>;
+  public serialize(...hasParams: readonly unknown[]): Record<S, boolean>;
+  public toArray(...hasParams: readonly unknown[]): S[];
+  public toJSON(): N extends number ? number : string;
+  public valueOf(): N;
+  public [Symbol.iterator](): IterableIterator<S>;
+  public static Flags: EnumLike<unknown, number | bigint>;
+  public static resolve(bit?: BitFieldResolvable<string, number | bigint>): number | bigint;
+}
+
+export class ButtonInteraction<Cached extends CacheType = CacheType> extends MessageComponentInteraction<Cached> {
+  private constructor(client: Client<true>, data: RawMessageButtonInteractionData);
+  public componentType: ComponentType.Button;
+  public get component(): CacheTypeReducer<
+    Cached,
+    ButtonComponent,
+    APIButtonComponent,
+    ButtonComponent | APIButtonComponent,
+    ButtonComponent | APIButtonComponent
+  >;
+  public inGuild(): this is ButtonInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is ButtonInteraction<'cached'>;
+  public inRawGuild(): this is ButtonInteraction<'raw'>;
+}
+
+export type AnyComponent =
+  | APIMessageComponent
+  | APIModalComponent
+  | APIActionRowComponent<APIMessageActionRowComponent | APIModalActionRowComponent>;
+
+export class Component<T extends AnyComponent = AnyComponent> {
+  public readonly data: Readonly<T>;
+  public get type(): T['type'];
+  public toJSON(): T;
+  public equals(other: this | T): boolean;
+}
+
+export class ButtonComponent extends Component<APIButtonComponent> {
+  private constructor(data: APIButtonComponent);
+  public get style(): ButtonStyle;
+  public get label(): string | null;
+  public get emoji(): APIMessageComponentEmoji | null;
+  public get disabled(): boolean;
+  public get customId(): string | null;
+  public get url(): string | null;
+}
+
+export type ComponentEmojiResolvable = APIMessageComponentEmoji | string;
+
+export class ButtonBuilder extends BuilderButtonComponent {
+  public constructor(data?: Partial<ButtonComponentData> | Partial<APIButtonComponent>);
+  public static from(other: JSONEncodable<APIButtonComponent> | APIButtonComponent): ButtonBuilder;
+  public override setEmoji(emoji: ComponentEmojiResolvable): this;
+}
+
+export class StringSelectMenuBuilder extends BuilderStringSelectMenuComponent {
+  public constructor(data?: Partial<StringSelectMenuComponentData | APIStringSelectComponent>);
+  private static normalizeEmoji(
+    selectMenuOption: JSONEncodable<APISelectMenuOption> | SelectMenuComponentOptionData,
+  ): (APISelectMenuOption | StringSelectMenuOptionBuilder)[];
+  public override addOptions(
+    ...options: RestOrArray<BuildersSelectMenuOption | SelectMenuComponentOptionData | APISelectMenuOption>
+  ): this;
+  public override setOptions(
+    ...options: RestOrArray<BuildersSelectMenuOption | SelectMenuComponentOptionData | APISelectMenuOption>
+  ): this;
+  public static from(other: JSONEncodable<APISelectMenuComponent> | APISelectMenuComponent): StringSelectMenuBuilder;
+}
+
+export {
+  /** @deprecated Use {@link StringSelectMenuBuilder} instead */
+  StringSelectMenuBuilder as SelectMenuBuilder,
+  /** @deprecated Use {@link StringSelectMenuOptionBuilder} instead */
+  StringSelectMenuOptionBuilder as SelectMenuOptionBuilder,
+};
+
+export class UserSelectMenuBuilder extends BuilderUserSelectMenuComponent {
+  public constructor(data?: Partial<UserSelectMenuComponentData | APIUserSelectComponent>);
+  public static from(other: JSONEncodable<APISelectMenuComponent> | APISelectMenuComponent): UserSelectMenuBuilder;
+}
+
+export class RoleSelectMenuBuilder extends BuilderRoleSelectMenuComponent {
+  public constructor(data?: Partial<RoleSelectMenuComponentData | APIRoleSelectComponent>);
+  public static from(other: JSONEncodable<APISelectMenuComponent> | APISelectMenuComponent): RoleSelectMenuBuilder;
+}
+
+export class MentionableSelectMenuBuilder extends BuilderMentionableSelectMenuComponent {
+  public constructor(data?: Partial<MentionableSelectMenuComponentData | APIMentionableSelectComponent>);
+  public static from(
+    other: JSONEncodable<APISelectMenuComponent> | APISelectMenuComponent,
+  ): MentionableSelectMenuBuilder;
+}
+
+export class ChannelSelectMenuBuilder extends BuilderChannelSelectMenuComponent {
+  public constructor(data?: Partial<ChannelSelectMenuComponentData | APIChannelSelectComponent>);
+  public static from(other: JSONEncodable<APISelectMenuComponent> | APISelectMenuComponent): ChannelSelectMenuBuilder;
+}
+
+export class StringSelectMenuOptionBuilder extends BuildersSelectMenuOption {
+  public constructor(data?: SelectMenuComponentOptionData | APISelectMenuOption);
+  public override setEmoji(emoji: ComponentEmojiResolvable): this;
+  public static from(other: JSONEncodable<APISelectMenuOption> | APISelectMenuOption): StringSelectMenuOptionBuilder;
+}
+
+export class ModalBuilder extends BuildersModal {
+  public constructor(data?: Partial<ModalComponentData> | Partial<APIModalInteractionResponseCallbackData>);
+  public static from(other: JSONEncodable<APIModalComponent> | APIModalComponent): ModalBuilder;
+}
+
+export class TextInputBuilder extends BuilderTextInputComponent {
+  public constructor(data?: Partial<TextInputComponentData | APITextInputComponent>);
+  public static from(other: JSONEncodable<APITextInputComponent> | APITextInputComponent): TextInputBuilder;
+}
+
+export class TextInputComponent extends Component<APITextInputComponent> {
+  public get customId(): string;
+  public get value(): string;
+}
+
+export class BaseSelectMenuComponent<Data extends APISelectMenuComponent> extends Component<Data> {
+  protected constructor(data: Data);
+  public get placeholder(): string | null;
+  public get maxValues(): number | null;
+  public get minValues(): number | null;
+  public get customId(): string;
+  public get disabled(): boolean;
+}
+
+export class StringSelectMenuComponent extends BaseSelectMenuComponent<APIStringSelectComponent> {
+  public get options(): APISelectMenuOption[];
+}
+
+export {
+  /** @deprecated Use {@link StringSelectMenuComponent} instead */
+  StringSelectMenuComponent as SelectMenuComponent,
+};
+
+export class UserSelectMenuComponent extends BaseSelectMenuComponent<APIUserSelectComponent> {}
+
+export class RoleSelectMenuComponent extends BaseSelectMenuComponent<APIRoleSelectComponent> {}
+
+export class MentionableSelectMenuComponent extends BaseSelectMenuComponent<APIMentionableSelectComponent> {}
+
+export class ChannelSelectMenuComponent extends BaseSelectMenuComponent<APIChannelSelectComponent> {
+  public getChannelTypes(): ChannelType[] | null;
+}
+
+export interface EmbedData {
+  title?: string;
+  type?: EmbedType;
+  description?: string;
+  url?: string;
+  timestamp?: string | number | Date;
+  color?: number;
+  footer?: EmbedFooterData;
+  image?: EmbedAssetData;
+  thumbnail?: EmbedAssetData;
+  provider?: APIEmbedProvider;
+  author?: EmbedAuthorData;
+  fields?: APIEmbedField[];
+  video?: EmbedAssetData;
+}
+
+export interface IconData {
+  iconURL?: string;
+  proxyIconURL?: string;
+}
+
+export type EmbedAuthorData = Omit<APIEmbedAuthor, 'icon_url' | 'proxy_icon_url'> & IconData;
+
+export type EmbedFooterData = Omit<APIEmbedFooter, 'icon_url' | 'proxy_icon_url'> & IconData;
+
+export interface EmbedAssetData extends Omit<APIEmbedImage, 'proxy_url'> {
+  proxyURL?: string;
+}
+
+export class EmbedBuilder extends BuildersEmbed {
+  public constructor(data?: EmbedData | APIEmbed);
+  public override setColor(color: ColorResolvable | null): this;
+  public static from(other: JSONEncodable<APIEmbed> | APIEmbed): EmbedBuilder;
+  public get length(): number;
+}
+
+export class Embed {
+  private constructor(data: APIEmbed);
+  public readonly data: Readonly<APIEmbed>;
+  public get fields(): APIEmbedField[];
+  public get footer(): EmbedFooterData | null;
+  public get title(): string | null;
+  public get description(): string | null;
+  public get url(): string | null;
+  public get color(): number | null;
+  public get hexColor(): string | null;
+  public get timestamp(): string | null;
+  public get thumbnail(): EmbedAssetData | null;
+  public get image(): EmbedAssetData | null;
+  public get author(): EmbedAuthorData | null;
+  public get provider(): APIEmbedProvider | null;
+  public get video(): EmbedAssetData | null;
+  public get length(): number;
+  public equals(other: Embed | APIEmbed): boolean;
+  public toJSON(): APIEmbed;
+}
+
+export interface MappedChannelCategoryTypes {
+  [ChannelType.GuildAnnouncement]: NewsChannel;
+  [ChannelType.GuildVoice]: VoiceChannel;
+  [ChannelType.GuildText]: TextChannel;
+  [ChannelType.GuildStageVoice]: StageChannel;
+  [ChannelType.GuildForum]: ForumChannel;
+}
+
+export type CategoryChannelType = Exclude<
+  ChannelType,
+  | ChannelType.DM
+  | ChannelType.GroupDM
+  | ChannelType.PublicThread
+  | ChannelType.AnnouncementThread
+  | ChannelType.PrivateThread
+  | ChannelType.GuildCategory
+  | ChannelType.GuildDirectory
+>;
+
+export class CategoryChannel extends GuildChannel {
+  public get children(): CategoryChannelChildManager;
+  public type: ChannelType.GuildCategory;
+  public get parent(): null;
+  public parentId: null;
+}
+
+export type CategoryChannelResolvable = Snowflake | CategoryChannel;
+
+export type ChannelFlagsString = keyof typeof ChannelFlags;
+
+export type ChannelFlagsResolvable = BitFieldResolvable<ChannelFlagsString, number>;
+
+export class ChannelFlagsBitField extends BitField<ChannelFlagsString> {
+  public static Flags: typeof ChannelFlags;
+  public static resolve(bit?: BitFieldResolvable<ChannelFlagsString, ChannelFlags>): number;
+}
+
+export abstract class BaseChannel extends Base {
+  public constructor(client: Client<true>, data?: RawChannelData, immediatePatch?: boolean);
+  public get createdAt(): Date | null;
+  public get createdTimestamp(): number | null;
+  public id: Snowflake;
+  public flags: Readonly<ChannelFlagsBitField> | null;
+  public get partial(): false;
+  public type: ChannelType;
+  public get url(): string;
+  public delete(): Promise<this>;
+  public fetch(force?: boolean): Promise<this>;
+  public isThread(): this is AnyThreadChannel;
+  public isTextBased(): this is TextBasedChannel;
+  public isDMBased(): this is PartialGroupDMChannel | DMChannel | PartialDMChannel;
+  public isVoiceBased(): this is VoiceBasedChannel;
+  public toString(): ChannelMention | UserMention;
+}
+
+export type If<T extends boolean, A, B = null> = T extends true ? A : T extends false ? B : A | B;
+
+export class Client<Ready extends boolean = boolean> extends BaseClient {
+  public constructor(options: ClientOptions);
+  private actions: unknown;
+  private presence: ClientPresence;
+  private _eval(script: string): unknown;
+  private _validateOptions(options: ClientOptions): void;
+  private get _censoredToken(): string | null;
+
+  public application: If<Ready, ClientApplication>;
+  public channels: ChannelManager;
+  public get emojis(): BaseGuildEmojiManager;
+  public guilds: GuildManager;
+  public options: Omit<ClientOptions, 'intents'> & { intents: IntentsBitField };
+  public get readyAt(): If<Ready, Date>;
+  public readyTimestamp: If<Ready, number>;
+  public sweepers: Sweepers;
+  public shard: ShardClientUtil | null;
+  public token: If<Ready, string, string | null>;
+  public get uptime(): If<Ready, number>;
+  public user: If<Ready, ClientUser>;
+  public users: UserManager;
+  public voice: ClientVoiceManager;
+  public ws: WebSocketManager;
+  public destroy(): Promise<void>;
+  public deleteWebhook(id: Snowflake, options?: WebhookDeleteOptions): Promise<void>;
+  public fetchGuildPreview(guild: GuildResolvable): Promise<GuildPreview>;
+  public fetchInvite(invite: InviteResolvable, options?: ClientFetchInviteOptions): Promise<Invite>;
+  public fetchGuildTemplate(template: GuildTemplateResolvable): Promise<GuildTemplate>;
+  public fetchVoiceRegions(): Promise<Collection<string, VoiceRegion>>;
+  public fetchSticker(id: Snowflake): Promise<Sticker>;
+  public fetchPremiumStickerPacks(): Promise<Collection<Snowflake, StickerPack>>;
+  public fetchWebhook(id: Snowflake, token?: string): Promise<Webhook>;
+  public fetchGuildWidget(guild: GuildResolvable): Promise<Widget>;
+  public generateInvite(options?: InviteGenerationOptions): string;
+  public login(token?: string): Promise<string>;
+  public isReady(): this is Client<true>;
+  public toJSON(): unknown;
+
+  public on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => Awaitable<void>): this;
+  public on<S extends string | symbol>(
+    event: Exclude<S, keyof ClientEvents>,
+    listener: (...args: any[]) => Awaitable<void>,
+  ): this;
+
+  public once<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => Awaitable<void>): this;
+  public once<S extends string | symbol>(
+    event: Exclude<S, keyof ClientEvents>,
+    listener: (...args: any[]) => Awaitable<void>,
+  ): this;
+
+  public emit<K extends keyof ClientEvents>(event: K, ...args: ClientEvents[K]): boolean;
+  public emit<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, ...args: unknown[]): boolean;
+
+  public off<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => Awaitable<void>): this;
+  public off<S extends string | symbol>(
+    event: Exclude<S, keyof ClientEvents>,
+    listener: (...args: any[]) => Awaitable<void>,
+  ): this;
+
+  public removeAllListeners<K extends keyof ClientEvents>(event?: K): this;
+  public removeAllListeners<S extends string | symbol>(event?: Exclude<S, keyof ClientEvents>): this;
+}
+
+export class ClientApplication extends Application {
+  private constructor(client: Client<true>, data: RawClientApplicationData);
+  public botPublic: boolean | null;
+  public botRequireCodeGrant: boolean | null;
+  public commands: ApplicationCommandManager;
+  public guildId: Snowflake | null;
+  public get guild(): Guild | null;
+  public cover: string | null;
+  public flags: Readonly<ApplicationFlagsBitField>;
+  public approximateGuildCount: number | null;
+  public tags: string[];
+  public installParams: ClientApplicationInstallParams | null;
+  public customInstallURL: string | null;
+  public owner: User | Team | null;
+  public get partial(): boolean;
+  public roleConnectionsVerificationURL: string | null;
+  public rpcOrigins: string[];
+  public fetch(): Promise<ClientApplication>;
+  public fetchRoleConnectionMetadataRecords(): Promise<ApplicationRoleConnectionMetadata[]>;
+  public editRoleConnectionMetadataRecords(
+    records: ApplicationRoleConnectionMetadataEditOptions[],
+  ): Promise<ApplicationRoleConnectionMetadata[]>;
+}
+
+export class ClientPresence extends Presence {
+  private constructor(client: Client<true>, data: RawPresenceData);
+  private _parse(data: PresenceData): RawPresenceData;
+
+  public set(presence: PresenceData): ClientPresence;
+}
+
+export class ClientUser extends User {
+  public mfaEnabled: boolean;
+  public get presence(): ClientPresence;
+  public verified: boolean;
+  public edit(options: ClientUserEditOptions): Promise<this>;
+  public setActivity(options?: ActivityOptions): ClientPresence;
+  public setActivity(name: string, options?: Omit<ActivityOptions, 'name'>): ClientPresence;
+  public setAFK(afk?: boolean, shardId?: number | number[]): ClientPresence;
+  public setAvatar(avatar: BufferResolvable | Base64Resolvable | null): Promise<this>;
+  public setPresence(data: PresenceData): ClientPresence;
+  public setStatus(status: PresenceStatusData, shardId?: number | number[]): ClientPresence;
+  public setUsername(username: string): Promise<this>;
+}
+
+export class Options extends null {
+  private constructor();
+  private static userAgentAppendix: string;
+  public static get DefaultMakeCacheSettings(): CacheWithLimitsOptions;
+  public static get DefaultSweeperSettings(): SweeperOptions;
+  public static createDefault(): ClientOptions;
+  public static cacheWithLimits(settings?: CacheWithLimitsOptions): CacheFactory;
+  public static cacheEverything(): CacheFactory;
+}
+
+export class ClientVoiceManager {
+  private constructor(client: Client);
+  public readonly client: Client;
+  public adapters: Map<Snowflake, InternalDiscordGatewayAdapterLibraryMethods>;
+}
+
+export { Collection } from '@discordjs/collection';
+
+export interface CollectorEventTypes<K, V, F extends unknown[] = []> {
+  collect: [V, ...F];
+  ignore: [V, ...F];
+  dispose: [V, ...F];
+  end: [collected: Collection<K, V>, reason: string];
+}
+
+export abstract class Collector<K, V, F extends unknown[] = []> extends EventEmitter {
+  protected constructor(client: Client<true>, options?: CollectorOptions<[V, ...F]>);
+  private _timeout: NodeJS.Timeout | null;
+  private _idletimeout: NodeJS.Timeout | null;
+  private _endReason: string | null;
+
+  public readonly client: Client;
+  public collected: Collection<K, V>;
+  public lastCollectedTimestamp: number | null;
+  public get lastCollectedAt(): Date | null;
+  public ended: boolean;
+  public get endReason(): string | null;
+  public filter: CollectorFilter<[V, ...F]>;
+  public get next(): Promise<V>;
+  public options: CollectorOptions<[V, ...F]>;
+  public checkEnd(): boolean;
+  public handleCollect(...args: unknown[]): Promise<void>;
+  public handleDispose(...args: unknown[]): Promise<void>;
+  public stop(reason?: string): void;
+  public resetTimer(options?: CollectorResetTimerOptions): void;
+  public [Symbol.asyncIterator](): AsyncIterableIterator<[V, ...F]>;
+  public toJSON(): unknown;
+
+  protected listener: (...args: any[]) => void;
+  public abstract collect(...args: unknown[]): K | null | Promise<K | null>;
+  public abstract dispose(...args: unknown[]): K | null;
+
+  public on<EventKey extends keyof CollectorEventTypes<K, V, F>>(
+    event: EventKey,
+    listener: (...args: CollectorEventTypes<K, V, F>[EventKey]) => Awaitable<void>,
+  ): this;
+
+  public once<EventKey extends keyof CollectorEventTypes<K, V, F>>(
+    event: EventKey,
+    listener: (...args: CollectorEventTypes<K, V, F>[EventKey]) => Awaitable<void>,
+  ): this;
+}
+
+export class ChatInputCommandInteraction<Cached extends CacheType = CacheType> extends CommandInteraction<Cached> {
+  public commandType: ApplicationCommandType.ChatInput;
+  public options: Omit<CommandInteractionOptionResolver<Cached>, 'getMessage' | 'getFocused'>;
+  public inGuild(): this is ChatInputCommandInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is ChatInputCommandInteraction<'cached'>;
+  public inRawGuild(): this is ChatInputCommandInteraction<'raw'>;
+  public toString(): string;
+}
+
+export class AutocompleteInteraction<Cached extends CacheType = CacheType> extends BaseInteraction<Cached> {
+  public type: InteractionType.ApplicationCommandAutocomplete;
+  public get command(): ApplicationCommand | ApplicationCommand<{ guild: GuildResolvable }> | null;
+  public channelId: Snowflake;
+  public commandId: Snowflake;
+  public commandName: string;
+  public commandType: ApplicationCommandType.ChatInput;
+  public commandGuildId: Snowflake | null;
+  public responded: boolean;
+  public options: Omit<
+    CommandInteractionOptionResolver<Cached>,
+    'getMessage' | 'getUser' | 'getAttachment' | 'getChannel' | 'getMember' | 'getMentionable' | 'getRole'
+  >;
+  public inGuild(): this is AutocompleteInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is AutocompleteInteraction<'cached'>;
+  public inRawGuild(): this is AutocompleteInteraction<'raw'>;
+  public respond(options: ApplicationCommandOptionChoiceData[]): Promise<void>;
+}
+
+export class CommandInteractionOptionResolver<Cached extends CacheType = CacheType> {
+  private constructor(
+    client: Client<true>,
+    options: CommandInteractionOption[],
+    resolved: CommandInteractionResolvedData,
+  );
+  public readonly client: Client;
+  public readonly data: readonly CommandInteractionOption<Cached>[];
+  public readonly resolved: Readonly<CommandInteractionResolvedData<Cached>> | null;
+  private _group: string | null;
+  private _hoistedOptions: CommandInteractionOption<Cached>[];
+  private _subcommand: string | null;
+  private _getTypedOption(
+    name: string,
+    allowedTypes: ApplicationCommandOptionType[],
+    properties: (keyof ApplicationCommandOption)[],
+    required: true,
+  ): CommandInteractionOption<Cached>;
+  private _getTypedOption(
+    name: string,
+    allowedTypes: ApplicationCommandOptionType[],
+    properties: (keyof ApplicationCommandOption)[],
+    required: boolean,
+  ): CommandInteractionOption<Cached> | null;
+
+  public get(name: string, required: true): CommandInteractionOption<Cached>;
+  public get(name: string, required?: boolean): CommandInteractionOption<Cached> | null;
+
+  public getSubcommand(required?: true): string;
+  public getSubcommand(required: boolean): string | null;
+  public getSubcommandGroup(required: true): string;
+  public getSubcommandGroup(required?: boolean): string | null;
+  public getBoolean(name: string, required: true): boolean;
+  public getBoolean(name: string, required?: boolean): boolean | null;
+  public getChannel<const T extends ChannelType = ChannelType>(
+    name: string,
+    required: true,
+    channelTypes?: readonly T[],
+  ): Extract<
+    NonNullable<CommandInteractionOption<Cached>['channel']>,
+    {
+      // The `type` property of the PublicThreadChannel class is typed as `ChannelType.PublicThread | ChannelType.AnnouncementThread`
+      // If the user only passed one of those channel types, the Extract<> would have resolved to `never`
+      // Hence the need for this ternary
+      type: T extends ChannelType.PublicThread | ChannelType.AnnouncementThread
+        ? ChannelType.PublicThread | ChannelType.AnnouncementThread
+        : T;
+    }
+  >;
+  public getChannel<const T extends ChannelType = ChannelType>(
+    name: string,
+    required?: boolean,
+    channelTypes?: readonly T[],
+  ): Extract<
+    NonNullable<CommandInteractionOption<Cached>['channel']>,
+    {
+      // The `type` property of the PublicThreadChannel class is typed as `ChannelType.PublicThread | ChannelType.AnnouncementThread`
+      // If the user only passed one of those channel types, the Extract<> would have resolved to `never`
+      // Hence the need for this ternary
+      type: T extends ChannelType.PublicThread | ChannelType.AnnouncementThread
+        ? ChannelType.PublicThread | ChannelType.AnnouncementThread
+        : T;
+    }
+  > | null;
+  public getString(name: string, required: true): string;
+  public getString(name: string, required?: boolean): string | null;
+  public getInteger(name: string, required: true): number;
+  public getInteger(name: string, required?: boolean): number | null;
+  public getNumber(name: string, required: true): number;
+  public getNumber(name: string, required?: boolean): number | null;
+  public getUser(name: string, required: true): NonNullable<CommandInteractionOption<Cached>['user']>;
+  public getUser(name: string, required?: boolean): NonNullable<CommandInteractionOption<Cached>['user']> | null;
+  public getMember(name: string): NonNullable<CommandInteractionOption<Cached>['member']> | null;
+  public getRole(name: string, required: true): NonNullable<CommandInteractionOption<Cached>['role']>;
+  public getRole(name: string, required?: boolean): NonNullable<CommandInteractionOption<Cached>['role']> | null;
+  public getAttachment(name: string, required: true): NonNullable<CommandInteractionOption<Cached>['attachment']>;
+  public getAttachment(
+    name: string,
+    required?: boolean,
+  ): NonNullable<CommandInteractionOption<Cached>['attachment']> | null;
+  public getMentionable(
+    name: string,
+    required: true,
+  ): NonNullable<CommandInteractionOption<Cached>['member' | 'role' | 'user']>;
+  public getMentionable(
+    name: string,
+    required?: boolean,
+  ): NonNullable<CommandInteractionOption<Cached>['member' | 'role' | 'user']> | null;
+  public getMessage(name: string, required: true): NonNullable<CommandInteractionOption<Cached>['message']>;
+  public getMessage(name: string, required?: boolean): NonNullable<CommandInteractionOption<Cached>['message']> | null;
+  public getFocused(getFull: true): AutocompleteFocusedOption;
+  public getFocused(getFull?: boolean): string;
+}
+
+export class ContextMenuCommandInteraction<Cached extends CacheType = CacheType> extends CommandInteraction<Cached> {
+  public commandType: ApplicationCommandType.Message | ApplicationCommandType.User;
+  public options: Omit<
+    CommandInteractionOptionResolver<Cached>,
+    | 'getFocused'
+    | 'getMentionable'
+    | 'getRole'
+    | 'getNumber'
+    | 'getInteger'
+    | 'getString'
+    | 'getChannel'
+    | 'getBoolean'
+    | 'getSubcommandGroup'
+    | 'getSubcommand'
+  >;
+  public targetId: Snowflake;
+  public inGuild(): this is ContextMenuCommandInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is ContextMenuCommandInteraction<'cached'>;
+  public inRawGuild(): this is ContextMenuCommandInteraction<'raw'>;
+  private resolveContextMenuOptions(data: APIApplicationCommandInteractionData): CommandInteractionOption<Cached>[];
+}
+
+export interface ResolvedFile {
+  data: Buffer;
+  contentType?: string;
+}
+
+export class DataResolver extends null {
+  private constructor();
+  public static resolveBase64(data: Base64Resolvable): string;
+  public static resolveCode(data: string, regex: RegExp): string;
+  public static resolveFile(resource: BufferResolvable | Stream): Promise<ResolvedFile>;
+  public static resolveImage(resource: BufferResolvable | Base64Resolvable): Promise<string | null>;
+  public static resolveInviteCode(data: InviteResolvable): string;
+  public static resolveGuildTemplateCode(data: GuildTemplateResolvable): string;
+}
+
+export class DMChannel extends TextBasedChannelMixin(BaseChannel, false, [
+  'bulkDelete',
+  'fetchWebhooks',
+  'createWebhook',
+  'setRateLimitPerUser',
+  'setNSFW',
+]) {
+  private constructor(client: Client<true>, data?: RawDMChannelData);
+  public flags: Readonly<ChannelFlagsBitField>;
+  public recipientId: Snowflake;
+  public get recipient(): User | null;
+  public type: ChannelType.DM;
+  public fetch(force?: boolean): Promise<this>;
+  public toString(): UserMention;
+}
+
+export class Emoji extends Base {
+  protected constructor(client: Client<true>, emoji: RawEmojiData);
+  public animated: boolean | null;
+  public get createdAt(): Date | null;
+  public get createdTimestamp(): number | null;
+  public id: Snowflake | null;
+  public name: string | null;
+  public get identifier(): string;
+  public get url(): string | null;
+  public toJSON(): unknown;
+  public toString(): string;
+}
+
+export class Guild extends AnonymousGuild {
+  private constructor(client: Client<true>, data: RawGuildData);
+  private _sortedRoles(): Collection<Snowflake, Role>;
+  private _sortedChannels(channel: NonThreadGuildBasedChannel): Collection<Snowflake, NonThreadGuildBasedChannel>;
+
+  public get afkChannel(): VoiceChannel | null;
+  public afkChannelId: Snowflake | null;
+  public afkTimeout: number;
+  public applicationId: Snowflake | null;
+  public maxVideoChannelUsers: number | null;
+  public approximateMemberCount: number | null;
+  public approximatePresenceCount: number | null;
+  public autoModerationRules: AutoModerationRuleManager;
+  public available: boolean;
+  public bans: GuildBanManager;
+  public channels: GuildChannelManager;
+  public commands: GuildApplicationCommandManager;
+  public defaultMessageNotifications: GuildDefaultMessageNotifications;
+  public discoverySplash: string | null;
+  public emojis: GuildEmojiManager;
+  public explicitContentFilter: GuildExplicitContentFilter;
+  public invites: GuildInviteManager;
+  public get joinedAt(): Date;
+  public joinedTimestamp: number;
+  public large: boolean;
+  public maximumMembers: number | null;
+  public maximumPresences: number | null;
+  public maxStageVideoChannelUsers: number | null;
+  public memberCount: number;
+  public members: GuildMemberManager;
+  public mfaLevel: GuildMFALevel;
+  public ownerId: Snowflake;
+  public preferredLocale: Locale;
+  public premiumProgressBarEnabled: boolean;
+  public premiumTier: GuildPremiumTier;
+  public presences: PresenceManager;
+  public get publicUpdatesChannel(): TextChannel | null;
+  public publicUpdatesChannelId: Snowflake | null;
+  public roles: RoleManager;
+  public get rulesChannel(): TextChannel | null;
+  public rulesChannelId: Snowflake | null;
+  public get safetyAlertsChannel(): TextChannel | null;
+  public safetyAlertsChannelId: Snowflake | null;
+  public scheduledEvents: GuildScheduledEventManager;
+  public get shard(): WebSocketShard;
+  public shardId: number;
+  public stageInstances: StageInstanceManager;
+  public stickers: GuildStickerManager;
+  public get systemChannel(): TextChannel | null;
+  public systemChannelFlags: Readonly<SystemChannelFlagsBitField>;
+  public systemChannelId: Snowflake | null;
+  public vanityURLUses: number | null;
+  public get voiceAdapterCreator(): InternalDiscordGatewayAdapterCreator;
+  public voiceStates: VoiceStateManager;
+  public get widgetChannel(): TextChannel | NewsChannel | VoiceBasedChannel | ForumChannel | null;
+  public widgetChannelId: Snowflake | null;
+  public widgetEnabled: boolean | null;
+  public get maximumBitrate(): number;
+  public createTemplate(name: string, description?: string): Promise<GuildTemplate>;
+  public delete(): Promise<Guild>;
+  public discoverySplashURL(options?: ImageURLOptions): string | null;
+  public edit(options: GuildEditOptions): Promise<Guild>;
+  public editWelcomeScreen(options: WelcomeScreenEditOptions): Promise<WelcomeScreen>;
+  public equals(guild: Guild): boolean;
+  public fetchAuditLogs<T extends GuildAuditLogsResolvable = null>(
+    options?: GuildAuditLogsFetchOptions<T>,
+  ): Promise<GuildAuditLogs<T>>;
+  public fetchIntegrations(): Promise<Collection<Snowflake | string, Integration>>;
+  public fetchOnboarding(): Promise<GuildOnboarding>;
+  public fetchOwner(options?: BaseFetchOptions): Promise<GuildMember>;
+  public fetchPreview(): Promise<GuildPreview>;
+  public fetchTemplates(): Promise<Collection<GuildTemplate['code'], GuildTemplate>>;
+  public fetchVanityData(): Promise<Vanity>;
+  public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
+  public fetchWelcomeScreen(): Promise<WelcomeScreen>;
+  public fetchWidget(): Promise<Widget>;
+  public fetchWidgetSettings(): Promise<GuildWidgetSettings>;
+  public leave(): Promise<Guild>;
+  public disableInvites(disabled?: boolean): Promise<Guild>;
+  public setAFKChannel(afkChannel: VoiceChannelResolvable | null, reason?: string): Promise<Guild>;
+  public setAFKTimeout(afkTimeout: number, reason?: string): Promise<Guild>;
+  public setBanner(banner: BufferResolvable | Base64Resolvable | null, reason?: string): Promise<Guild>;
+  public setDefaultMessageNotifications(
+    defaultMessageNotifications: GuildDefaultMessageNotifications | null,
+    reason?: string,
+  ): Promise<Guild>;
+  public setDiscoverySplash(
+    discoverySplash: BufferResolvable | Base64Resolvable | null,
+    reason?: string,
+  ): Promise<Guild>;
+  public setExplicitContentFilter(
+    explicitContentFilter: GuildExplicitContentFilter | null,
+    reason?: string,
+  ): Promise<Guild>;
+  public setIcon(icon: BufferResolvable | Base64Resolvable | null, reason?: string): Promise<Guild>;
+  public setName(name: string, reason?: string): Promise<Guild>;
+  public setOwner(owner: GuildMemberResolvable, reason?: string): Promise<Guild>;
+  public setPreferredLocale(preferredLocale: Locale | null, reason?: string): Promise<Guild>;
+  public setPublicUpdatesChannel(publicUpdatesChannel: TextChannelResolvable | null, reason?: string): Promise<Guild>;
+  public setRulesChannel(rulesChannel: TextChannelResolvable | null, reason?: string): Promise<Guild>;
+  public setSafetyAlertsChannel(safetyAlertsChannel: TextChannelResolvable | null, reason?: string): Promise<Guild>;
+  public setSplash(splash: BufferResolvable | Base64Resolvable | null, reason?: string): Promise<Guild>;
+  public setSystemChannel(systemChannel: TextChannelResolvable | null, reason?: string): Promise<Guild>;
+  public setSystemChannelFlags(systemChannelFlags: SystemChannelFlagsResolvable, reason?: string): Promise<Guild>;
+  public setVerificationLevel(verificationLevel: GuildVerificationLevel | null, reason?: string): Promise<Guild>;
+  public setPremiumProgressBarEnabled(enabled?: boolean, reason?: string): Promise<Guild>;
+  public setWidgetSettings(settings: GuildWidgetSettingsData, reason?: string): Promise<Guild>;
+  public setMFALevel(level: GuildMFALevel, reason?: string): Promise<Guild>;
+  public toJSON(): unknown;
+}
+
+export class GuildAuditLogs<T extends GuildAuditLogsResolvable = AuditLogEvent> {
+  private constructor(guild: Guild, data: RawGuildAuditLogData);
+  private applicationCommands: Collection<Snowflake, ApplicationCommand>;
+  private webhooks: Collection<Snowflake, Webhook>;
+  private integrations: Collection<Snowflake | string, Integration>;
+  private guildScheduledEvents: Collection<Snowflake, GuildScheduledEvent>;
+  private autoModerationRules: Collection<Snowflake, AutoModerationRule>;
+  public entries: Collection<Snowflake, GuildAuditLogsEntry<T>>;
+  public toJSON(): unknown;
+}
+
+export class GuildAuditLogsEntry<
+  TAction extends GuildAuditLogsResolvable = AuditLogEvent,
+  TActionType extends GuildAuditLogsActionType = TAction extends keyof GuildAuditLogsTypes
+    ? GuildAuditLogsTypes[TAction][1]
+    : GuildAuditLogsActionType,
+  TTargetType extends GuildAuditLogsTargetType = TAction extends keyof GuildAuditLogsTypes
+    ? GuildAuditLogsTypes[TAction][0]
+    : GuildAuditLogsTargetType,
+  TResolvedType = TAction extends null ? AuditLogEvent : TAction,
+> {
+  private constructor(guild: Guild, data: RawGuildAuditLogEntryData, logs?: GuildAuditLogs);
+  public static Targets: GuildAuditLogsTargets;
+  public action: TResolvedType;
+  public actionType: TActionType;
+  public changes: AuditLogChange[];
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public executorId: Snowflake | null;
+  public executor: User | null;
+  public extra: TResolvedType extends keyof GuildAuditLogsEntryExtraField
+    ? GuildAuditLogsEntryExtraField[TResolvedType]
+    : null;
+  public id: Snowflake;
+  public reason: string | null;
+  public targetId: Snowflake | null;
+  public target: TTargetType extends keyof GuildAuditLogsEntryTargetField<TActionType>
+    ? GuildAuditLogsEntryTargetField<TActionType>[TTargetType]
+    : Role | GuildEmoji | { id: Snowflake } | null;
+  public targetType: TTargetType;
+  public static actionType(action: AuditLogEvent): GuildAuditLogsActionType;
+  public static targetType(target: AuditLogEvent): GuildAuditLogsTargetType;
+  public toJSON(): unknown;
+}
+
+export class GuildBan extends Base {
+  private constructor(client: Client<true>, data: RawGuildBanData, guild: Guild);
+  public guild: Guild;
+  public user: User;
+  public get partial(): boolean;
+  public reason?: string | null;
+  public fetch(force?: boolean): Promise<GuildBan>;
+}
+
+export abstract class GuildChannel extends BaseChannel {
+  public constructor(guild: Guild, data?: RawGuildChannelData, client?: Client<true>, immediatePatch?: boolean);
+  private memberPermissions(member: GuildMember, checkAdmin: boolean): Readonly<PermissionsBitField>;
+  private rolePermissions(role: Role, checkAdmin: boolean): Readonly<PermissionsBitField>;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public get deletable(): boolean;
+  public flags: Readonly<ChannelFlagsBitField>;
+  public guild: Guild;
+  public guildId: Snowflake;
+  public get manageable(): boolean;
+  public get members(): Collection<Snowflake, GuildMember>;
+  public name: string;
+  public get parent(): CategoryChannel | null;
+  public parentId: Snowflake | null;
+  public permissionOverwrites: PermissionOverwriteManager;
+  public get permissionsLocked(): boolean | null;
+  public get position(): number;
+  public rawPosition: number;
+  public type: Exclude<ChannelType, ChannelType.DM | ChannelType.GroupDM>;
+  public get viewable(): boolean;
+  public clone(options?: GuildChannelCloneOptions): Promise<this>;
+  public delete(reason?: string): Promise<this>;
+  public edit(options: GuildChannelEditOptions): Promise<this>;
+  public equals(channel: GuildChannel): boolean;
+  public lockPermissions(): Promise<this>;
+  public permissionsFor(memberOrRole: GuildMember | Role, checkAdmin?: boolean): Readonly<PermissionsBitField>;
+  public permissionsFor(
+    memberOrRole: GuildMemberResolvable | RoleResolvable,
+    checkAdmin?: boolean,
+  ): Readonly<PermissionsBitField> | null;
+  public setName(name: string, reason?: string): Promise<this>;
+  public setParent(channel: CategoryChannelResolvable | null, options?: SetParentOptions): Promise<this>;
+  public setPosition(position: number, options?: SetChannelPositionOptions): Promise<this>;
+  public isTextBased(): this is GuildBasedChannel & TextBasedChannel;
+  public toString(): ChannelMention;
+}
+
+export class GuildEmoji extends BaseGuildEmoji {
+  private constructor(client: Client<true>, data: RawGuildEmojiData, guild: Guild);
+  private _roles: Snowflake[];
+
+  public get deletable(): boolean;
+  public guild: Guild;
+  public author: User | null;
+  public get roles(): GuildEmojiRoleManager;
+  public get url(): string;
+  public delete(reason?: string): Promise<GuildEmoji>;
+  public edit(options: GuildEmojiEditOptions): Promise<GuildEmoji>;
+  public equals(other: GuildEmoji | unknown): boolean;
+  public fetchAuthor(): Promise<User>;
+  public setName(name: string, reason?: string): Promise<GuildEmoji>;
+}
+
+export type GuildMemberFlagsString = keyof typeof GuildMemberFlags;
+
+export type GuildMemberFlagsResolvable = BitFieldResolvable<GuildMemberFlagsString, number>;
+
+export class GuildMemberFlagsBitField extends BitField<GuildMemberFlagsString> {
+  public static Flags: GuildMemberFlags;
+  public static resolve(bit?: BitFieldResolvable<GuildMemberFlagsString, GuildMemberFlags>): number;
+}
+
+export class GuildMember extends PartialTextBasedChannel(Base) {
+  private constructor(client: Client<true>, data: RawGuildMemberData, guild: Guild);
+  private _roles: Snowflake[];
+  public avatar: string | null;
+  public get bannable(): boolean;
+  public get dmChannel(): DMChannel | null;
+  public get displayColor(): number;
+  public get displayHexColor(): HexColorString;
+  public get displayName(): string;
+  public guild: Guild;
+  public get id(): Snowflake;
+  public pending: boolean;
+  public get communicationDisabledUntil(): Date | null;
+  public communicationDisabledUntilTimestamp: number | null;
+  public flags: Readonly<GuildMemberFlagsBitField>;
+  public get joinedAt(): Date | null;
+  public joinedTimestamp: number | null;
+  public get kickable(): boolean;
+  public get manageable(): boolean;
+  public get moderatable(): boolean;
+  public nickname: string | null;
+  public get partial(): false;
+  public get permissions(): Readonly<PermissionsBitField>;
+  public get premiumSince(): Date | null;
+  public premiumSinceTimestamp: number | null;
+  public get presence(): Presence | null;
+  public get roles(): GuildMemberRoleManager;
+  public user: User;
+  public get voice(): VoiceState;
+  public avatarURL(options?: ImageURLOptions): string | null;
+  public ban(options?: BanOptions): Promise<GuildMember>;
+  public disableCommunicationUntil(timeout: DateResolvable | null, reason?: string): Promise<GuildMember>;
+  public timeout(timeout: number | null, reason?: string): Promise<GuildMember>;
+  public fetch(force?: boolean): Promise<GuildMember>;
+  public createDM(force?: boolean): Promise<DMChannel>;
+  public deleteDM(): Promise<DMChannel>;
+  public displayAvatarURL(options?: ImageURLOptions): string;
+  public edit(options: GuildMemberEditOptions): Promise<GuildMember>;
+  public isCommunicationDisabled(): this is GuildMember & {
+    communicationDisabledUntilTimestamp: number;
+    readonly communicationDisabledUntil: Date;
+  };
+  public kick(reason?: string): Promise<GuildMember>;
+  public permissionsIn(channel: GuildChannelResolvable): Readonly<PermissionsBitField>;
+  public setFlags(flags: GuildMemberFlagsResolvable, reason?: string): Promise<GuildMember>;
+  public setNickname(nickname: string | null, reason?: string): Promise<GuildMember>;
+  public toJSON(): unknown;
+  public toString(): UserMention;
+  public valueOf(): string;
+}
+
+export class GuildOnboarding extends Base {
+  private constructor(client: Client, data: RESTGetAPIGuildOnboardingResult);
+  public get guild(): Guild;
+  public guildId: Snowflake;
+  public prompts: Collection<Snowflake, GuildOnboardingPrompt>;
+  public defaultChannels: Collection<Snowflake, GuildChannel>;
+  public enabled: boolean;
+}
+
+export class GuildOnboardingPrompt extends Base {
+  private constructor(client: Client, data: APIGuildOnboardingPrompt, guildId: Snowflake);
+  public id: Snowflake;
+  public get guild(): Guild;
+  public guildId: Snowflake;
+  public options: Collection<Snowflake, GuildOnboardingPromptOption>;
+  public title: string;
+  public singleSelect: boolean;
+  public required: boolean;
+  public inOnboarding: boolean;
+  public type: GuildOnboardingPromptType;
+}
+
+export class GuildOnboardingPromptOption extends Base {
+  private constructor(client: Client, data: APIGuildOnboardingPromptOption, guildId: Snowflake);
+  public id: Snowflake;
+  public get guild(): Guild;
+  public guildId: Snowflake;
+  public channels: Collection<Snowflake, GuildChannel>;
+  public roles: Collection<Snowflake, Role>;
+  public emoji: GuildOnboardingPromptOptionEmoji | null;
+  public title: string;
+  public description: string | null;
+}
+
+export class GuildPreview extends Base {
+  private constructor(client: Client<true>, data: RawGuildPreviewData);
+  public approximateMemberCount: number;
+  public approximatePresenceCount: number;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public description: string | null;
+  public discoverySplash: string | null;
+  public emojis: Collection<Snowflake, GuildPreviewEmoji>;
+  public stickers: Collection<Snowflake, Sticker>;
+  public features: `${GuildFeature}`[];
+  public icon: string | null;
+  public id: Snowflake;
+  public name: string;
+  public splash: string | null;
+  public discoverySplashURL(options?: ImageURLOptions): string | null;
+  public iconURL(options?: ImageURLOptions): string | null;
+  public splashURL(options?: ImageURLOptions): string | null;
+  public fetch(): Promise<GuildPreview>;
+  public toJSON(): unknown;
+  public toString(): string;
+}
+
+export class GuildScheduledEvent<S extends GuildScheduledEventStatus = GuildScheduledEventStatus> extends Base {
+  private constructor(client: Client<true>, data: RawGuildScheduledEventData);
+  public id: Snowflake;
+  public guildId: Snowflake;
+  public channelId: Snowflake | null;
+  public creatorId: Snowflake | null;
+  public name: string;
+  public description: string | null;
+  public scheduledStartTimestamp: number | null;
+  public scheduledEndTimestamp: number | null;
+  public privacyLevel: GuildScheduledEventPrivacyLevel;
+  public status: S;
+  public entityType: GuildScheduledEventEntityType;
+  public entityId: Snowflake | null;
+  public entityMetadata: GuildScheduledEventEntityMetadata | null;
+  public userCount: number | null;
+  public creator: User | null;
+  public get createdTimestamp(): number;
+  public get createdAt(): Date;
+  public get scheduledStartAt(): Date | null;
+  public get scheduledEndAt(): Date | null;
+  public get channel(): VoiceChannel | StageChannel | null;
+  public get guild(): Guild | null;
+  public get url(): string;
+  public image: string | null;
+  public coverImageURL(options?: Readonly<BaseImageURLOptions>): string | null;
+  public createInviteURL(options?: GuildScheduledEventInviteURLCreateOptions): Promise<string>;
+  public edit<T extends GuildScheduledEventSetStatusArg<S>>(
+    options: GuildScheduledEventEditOptions<S, T>,
+  ): Promise<GuildScheduledEvent<T>>;
+  public delete(): Promise<GuildScheduledEvent<S>>;
+  public setName(name: string, reason?: string): Promise<GuildScheduledEvent<S>>;
+  public setScheduledStartTime(scheduledStartTime: DateResolvable, reason?: string): Promise<GuildScheduledEvent<S>>;
+  public setScheduledEndTime(scheduledEndTime: DateResolvable, reason?: string): Promise<GuildScheduledEvent<S>>;
+  public setDescription(description: string, reason?: string): Promise<GuildScheduledEvent<S>>;
+  public setStatus<T extends GuildScheduledEventSetStatusArg<S>>(
+    status: T,
+    reason?: string,
+  ): Promise<GuildScheduledEvent<T>>;
+  public setLocation(location: string, reason?: string): Promise<GuildScheduledEvent<S>>;
+  public fetchSubscribers<T extends FetchGuildScheduledEventSubscribersOptions>(
+    options?: T,
+  ): Promise<GuildScheduledEventManagerFetchSubscribersResult<T>>;
+  public toString(): string;
+  public isActive(): this is GuildScheduledEvent<GuildScheduledEventStatus.Active>;
+  public isCanceled(): this is GuildScheduledEvent<GuildScheduledEventStatus.Canceled>;
+  public isCompleted(): this is GuildScheduledEvent<GuildScheduledEventStatus.Completed>;
+  public isScheduled(): this is GuildScheduledEvent<GuildScheduledEventStatus.Scheduled>;
+}
+
+export class GuildTemplate extends Base {
+  private constructor(client: Client<true>, data: RawGuildTemplateData);
+  public createdTimestamp: number;
+  public updatedTimestamp: number;
+  public get url(): string;
+  public code: string;
+  public name: string;
+  public description: string | null;
+  public usageCount: number;
+  public creator: User;
+  public creatorId: Snowflake;
+  public get createdAt(): Date;
+  public get updatedAt(): Date;
+  public get guild(): Guild | null;
+  public guildId: Snowflake;
+  public serializedGuild: APITemplateSerializedSourceGuild;
+  public unSynced: boolean | null;
+  public createGuild(name: string, icon?: BufferResolvable | Base64Resolvable): Promise<Guild>;
+  public delete(): Promise<GuildTemplate>;
+  public edit(options?: GuildTemplateEditOptions): Promise<GuildTemplate>;
+  public sync(): Promise<GuildTemplate>;
+  public static GuildTemplatesPattern: RegExp;
+}
+
+export class GuildPreviewEmoji extends BaseGuildEmoji {
+  private constructor(client: Client<true>, data: RawGuildEmojiData, guild: GuildPreview);
+  public guild: GuildPreview;
+  public roles: Snowflake[];
+}
+
+export class Integration extends Base {
+  private constructor(client: Client<true>, data: RawIntegrationData, guild: Guild);
+  public account: IntegrationAccount;
+  public application: IntegrationApplication | null;
+  public enabled: boolean | null;
+  public expireBehavior: IntegrationExpireBehavior | null;
+  public expireGracePeriod: number | null;
+  public guild: Guild;
+  public id: Snowflake | string;
+  public name: string;
+  public role: Role | null;
+  public enableEmoticons: boolean | null;
+  public get roles(): Collection<Snowflake, Role>;
+  public scopes: OAuth2Scopes[];
+  public get syncedAt(): Date | null;
+  public syncedTimestamp: number | null;
+  public syncing: boolean | null;
+  public type: IntegrationType;
+  public user: User | null;
+  public subscriberCount: number | null;
+  public revoked: boolean | null;
+  public delete(reason?: string): Promise<Integration>;
+}
+
+export class IntegrationApplication extends Application {
+  private constructor(client: Client<true>, data: RawIntegrationApplicationData);
+  public bot: User | null;
+  public termsOfServiceURL: string | null;
+  public privacyPolicyURL: string | null;
+  public rpcOrigins: string[];
+  public hook: boolean | null;
+  public cover: string | null;
+  public verifyKey: string | null;
+}
+
+export type GatewayIntentsString = keyof typeof GatewayIntentBits;
+
+export class IntentsBitField extends BitField<GatewayIntentsString> {
+  public static Flags: typeof GatewayIntentBits;
+  public static resolve(bit?: BitFieldResolvable<GatewayIntentsString, number>): number;
+}
+
+export type CacheType = 'cached' | 'raw' | undefined;
+
+export type CacheTypeReducer<
+  State extends CacheType,
+  CachedType,
+  RawType = CachedType,
+  PresentType = CachedType | RawType,
+  Fallback = PresentType | null,
+> = [State] extends ['cached']
+  ? CachedType
+  : [State] extends ['raw']
+  ? RawType
+  : [State] extends ['raw' | 'cached']
+  ? PresentType
+  : Fallback;
+
+export type Interaction<Cached extends CacheType = CacheType> =
+  | ChatInputCommandInteraction<Cached>
+  | MessageContextMenuCommandInteraction<Cached>
+  | UserContextMenuCommandInteraction<Cached>
+  | AnySelectMenuInteraction<Cached>
+  | ButtonInteraction<Cached>
+  | AutocompleteInteraction<Cached>
+  | ModalSubmitInteraction<Cached>;
+
+export type RepliableInteraction<Cached extends CacheType = CacheType> = Exclude<
+  Interaction<Cached>,
+  AutocompleteInteraction<Cached>
+>;
+
+export class BaseInteraction<Cached extends CacheType = CacheType> extends Base {
+  // This a technique used to brand different cached types. Or else we'll get `never` errors on typeguard checks.
+  private readonly _cacheType: Cached;
+  protected constructor(client: Client<true>, data: RawInteractionData);
+  public applicationId: Snowflake;
+  public get channel(): CacheTypeReducer<
+    Cached,
+    GuildTextBasedChannel | null,
+    GuildTextBasedChannel | null,
+    GuildTextBasedChannel | null,
+    TextBasedChannel | null
+  >;
+  public channelId: Snowflake | null;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public get guild(): CacheTypeReducer<Cached, Guild, null>;
+  public guildId: CacheTypeReducer<Cached, Snowflake>;
+  public id: Snowflake;
+  public member: CacheTypeReducer<Cached, GuildMember, APIInteractionGuildMember>;
+  public readonly token: string;
+  public type: InteractionType;
+  public user: User;
+  public version: number;
+  public appPermissions: CacheTypeReducer<Cached, Readonly<PermissionsBitField>>;
+  public memberPermissions: CacheTypeReducer<Cached, Readonly<PermissionsBitField>>;
+  public locale: Locale;
+  public guildLocale: CacheTypeReducer<Cached, Locale>;
+  public inGuild(): this is BaseInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is BaseInteraction<'cached'>;
+  public inRawGuild(): this is BaseInteraction<'raw'>;
+  public isButton(): this is ButtonInteraction<Cached>;
+  public isAutocomplete(): this is AutocompleteInteraction<Cached>;
+  public isChatInputCommand(): this is ChatInputCommandInteraction<Cached>;
+  public isCommand(): this is CommandInteraction<Cached>;
+  public isContextMenuCommand(): this is ContextMenuCommandInteraction<Cached>;
+  public isMessageComponent(): this is MessageComponentInteraction<Cached>;
+  public isMessageContextMenuCommand(): this is MessageContextMenuCommandInteraction<Cached>;
+  public isModalSubmit(): this is ModalSubmitInteraction<Cached>;
+  public isUserContextMenuCommand(): this is UserContextMenuCommandInteraction<Cached>;
+  /** @deprecated Use {@link isStringSelectMenu} instead. */
+  public isSelectMenu(): this is StringSelectMenuInteraction<Cached>;
+  public isAnySelectMenu(): this is AnySelectMenuInteraction<Cached>;
+  public isStringSelectMenu(): this is StringSelectMenuInteraction<Cached>;
+  public isUserSelectMenu(): this is UserSelectMenuInteraction<Cached>;
+  public isRoleSelectMenu(): this is RoleSelectMenuInteraction<Cached>;
+  public isMentionableSelectMenu(): this is MentionableSelectMenuInteraction<Cached>;
+  public isChannelSelectMenu(): this is ChannelSelectMenuInteraction<Cached>;
+  public isRepliable(): this is RepliableInteraction<Cached>;
+}
+
+export class InteractionCollector<T extends CollectedInteraction> extends Collector<
+  Snowflake,
+  T,
+  [Collection<Snowflake, T>]
+> {
+  public constructor(client: Client<true>, options?: InteractionCollectorOptions<T>);
+  private _handleMessageDeletion(message: Message): void;
+  private _handleChannelDeletion(channel: NonThreadGuildBasedChannel): void;
+  private _handleGuildDeletion(guild: Guild): void;
+
+  public channelId: Snowflake | null;
+  public messageInteractionId: Snowflake | null;
+  public componentType: ComponentType | null;
+  public guildId: Snowflake | null;
+  public interactionType: InteractionType | null;
+  public messageId: Snowflake | null;
+  public options: InteractionCollectorOptions<T>;
+  public total: number;
+  public users: Collection<Snowflake, User>;
+
+  public collect(interaction: Interaction): Snowflake;
+  public empty(): void;
+  public dispose(interaction: Interaction): Snowflake;
+  public on(event: 'collect' | 'dispose' | 'ignore', listener: (interaction: T) => Awaitable<void>): this;
+  public on(event: 'end', listener: (collected: Collection<Snowflake, T>, reason: string) => Awaitable<void>): this;
+  public on(event: string, listener: (...args: any[]) => Awaitable<void>): this;
+
+  public once(event: 'collect' | 'dispose' | 'ignore', listener: (interaction: T) => Awaitable<void>): this;
+  public once(event: 'end', listener: (collected: Collection<Snowflake, T>, reason: string) => Awaitable<void>): this;
+  public once(event: string, listener: (...args: any[]) => Awaitable<void>): this;
+}
+
+export class InteractionWebhook extends PartialWebhookMixin() {
+  public constructor(client: Client<true>, id: Snowflake, token: string);
+  public token: string;
+  public send(options: string | MessagePayload | InteractionReplyOptions): Promise<Message>;
+  public editMessage(
+    message: MessageResolvable | '@original',
+    options: string | MessagePayload | WebhookMessageEditOptions,
+  ): Promise<Message>;
+  public fetchMessage(message: Snowflake | '@original'): Promise<Message>;
+}
+
+export class Invite extends Base {
+  private constructor(client: Client<true>, data: RawInviteData);
+  public channel: NonThreadGuildBasedChannel | PartialGroupDMChannel | null;
+  public channelId: Snowflake | null;
+  public code: string;
+  public get deletable(): boolean;
+  public get createdAt(): Date | null;
+  public createdTimestamp: number | null;
+  public get expiresAt(): Date | null;
+  public get expiresTimestamp(): number | null;
+  public guild: InviteGuild | Guild | null;
+  public get inviter(): User | null;
+  public inviterId: Snowflake | null;
+  public maxAge: number | null;
+  public maxUses: number | null;
+  public memberCount: number;
+  public presenceCount: number;
+  public targetApplication: IntegrationApplication | null;
+  public targetUser: User | null;
+  public targetType: InviteTargetType | null;
+  public temporary: boolean | null;
+  public get url(): string;
+  public uses: number | null;
+  public delete(reason?: string): Promise<Invite>;
+  public toJSON(): unknown;
+  public toString(): string;
+  public static InvitesPattern: RegExp;
+  /** @deprecated */
+  public stageInstance: InviteStageInstance | null;
+  public guildScheduledEvent: GuildScheduledEvent | null;
+}
+
+/** @deprecated */
+export class InviteStageInstance extends Base {
+  private constructor(client: Client<true>, data: RawInviteStageInstance, channelId: Snowflake, guildId: Snowflake);
+  public channelId: Snowflake;
+  public guildId: Snowflake;
+  public members: Collection<Snowflake, GuildMember>;
+  public topic: string;
+  public participantCount: number;
+  public speakerCount: number;
+  public get channel(): StageChannel | null;
+  public get guild(): Guild | null;
+}
+
+export class InviteGuild extends AnonymousGuild {
+  private constructor(client: Client<true>, data: RawInviteGuildData);
+  public welcomeScreen: WelcomeScreen | null;
+}
+
+export class LimitedCollection<K, V> extends Collection<K, V> {
+  public constructor(options?: LimitedCollectionOptions<K, V>, iterable?: Iterable<readonly [K, V]>);
+  public maxSize: number;
+  public keepOverLimit: ((value: V, key: K, collection: this) => boolean) | null;
+}
+
+export type MessageComponentType = Exclude<ComponentType, ComponentType.TextInput | ComponentType.ActionRow>;
+
+export type MessageCollectorOptionsParams<T extends MessageComponentType, Cached extends boolean = boolean> =
+  | {
+      componentType?: T;
+    } & MessageComponentCollectorOptions<MappedInteractionTypes<Cached>[T]>;
+
+export type MessageChannelCollectorOptionsParams<T extends MessageComponentType, Cached extends boolean = boolean> =
+  | {
+      componentType?: T;
+    } & MessageChannelComponentCollectorOptions<MappedInteractionTypes<Cached>[T]>;
+
+export type AwaitMessageCollectorOptionsParams<T extends MessageComponentType, Cached extends boolean = boolean> =
+  | { componentType?: T } & Pick<
+      InteractionCollectorOptions<MappedInteractionTypes<Cached>[T]>,
+      keyof AwaitMessageComponentOptions<any>
+    >;
+
+export interface StringMappedInteractionTypes<Cached extends CacheType = CacheType> {
+  Button: ButtonInteraction<Cached>;
+  StringSelectMenu: StringSelectMenuInteraction<Cached>;
+  UserSelectMenu: UserSelectMenuInteraction<Cached>;
+  RoleSelectMenu: RoleSelectMenuInteraction<Cached>;
+  MentionableSelectMenu: MentionableSelectMenuInteraction<Cached>;
+  ChannelSelectMenu: ChannelSelectMenuInteraction<Cached>;
+  ActionRow: MessageComponentInteraction<Cached>;
+}
+
+export type WrapBooleanCache<T extends boolean> = If<T, 'cached', CacheType>;
+
+export interface MappedInteractionTypes<Cached extends boolean = boolean> {
+  [ComponentType.Button]: ButtonInteraction<WrapBooleanCache<Cached>>;
+  [ComponentType.StringSelect]: StringSelectMenuInteraction<WrapBooleanCache<Cached>>;
+  [ComponentType.UserSelect]: UserSelectMenuInteraction<WrapBooleanCache<Cached>>;
+  [ComponentType.RoleSelect]: RoleSelectMenuInteraction<WrapBooleanCache<Cached>>;
+  [ComponentType.MentionableSelect]: MentionableSelectMenuInteraction<WrapBooleanCache<Cached>>;
+  [ComponentType.ChannelSelect]: ChannelSelectMenuInteraction<WrapBooleanCache<Cached>>;
+}
+
+export class Message<InGuild extends boolean = boolean> extends Base {
+  private readonly _cacheType: InGuild;
+  private constructor(client: Client<true>, data: RawMessageData);
+  private _patch(data: RawPartialMessageData | RawMessageData): void;
+
+  public activity: MessageActivity | null;
+  public applicationId: Snowflake | null;
+  public attachments: Collection<Snowflake, Attachment>;
+  public author: User;
+  public get bulkDeletable(): boolean;
+  public get channel(): If<InGuild, GuildTextBasedChannel, TextBasedChannel>;
+  public channelId: Snowflake;
+  public get cleanContent(): string;
+  public components: ActionRow<MessageActionRowComponent>[];
+  public content: string;
+  public get createdAt(): Date;
+  public createdTimestamp: number;
+  public get crosspostable(): boolean;
+  public get deletable(): boolean;
+  public get editable(): boolean;
+  public get editedAt(): Date | null;
+  public editedTimestamp: number | null;
+  public embeds: Embed[];
+  public groupActivityApplication: ClientApplication | null;
+  public guildId: If<InGuild, Snowflake>;
+  public get guild(): If<InGuild, Guild>;
+  public get hasThread(): boolean;
+  public id: Snowflake;
+  public interaction: MessageInteraction | null;
+  public get member(): GuildMember | null;
+  public mentions: MessageMentions<InGuild>;
+  public nonce: string | number | null;
+  public get partial(): false;
+  public get pinnable(): boolean;
+  public pinned: boolean;
+  public reactions: ReactionManager;
+  public stickers: Collection<Snowflake, Sticker>;
+  public position: number | null;
+  public roleSubscriptionData: RoleSubscriptionData | null;
+  public system: boolean;
+  public get thread(): AnyThreadChannel | null;
+  public tts: boolean;
+  public type: MessageType;
+  public get url(): string;
+  public webhookId: Snowflake | null;
+  public flags: Readonly<MessageFlagsBitField>;
+  public reference: MessageReference | null;
+  public awaitMessageComponent<T extends MessageComponentType>(
+    options?: AwaitMessageCollectorOptionsParams<T, InGuild>,
+  ): Promise<MappedInteractionTypes<InGuild>[T]>;
+  public awaitReactions(options?: AwaitReactionsOptions): Promise<Collection<Snowflake | string, MessageReaction>>;
+  public createReactionCollector(options?: ReactionCollectorOptions): ReactionCollector;
+  public createMessageComponentCollector<T extends MessageComponentType>(
+    options?: MessageCollectorOptionsParams<T, InGuild>,
+  ): InteractionCollector<MappedInteractionTypes<InGuild>[T]>;
+  public delete(): Promise<Message<InGuild>>;
+  public edit(content: string | MessageEditOptions | MessagePayload): Promise<Message<InGuild>>;
+  public equals(message: Message, rawData: unknown): boolean;
+  public fetchReference(): Promise<Message<InGuild>>;
+  public fetchWebhook(): Promise<Webhook>;
+  public crosspost(): Promise<Message<InGuild>>;
+  public fetch(force?: boolean): Promise<Message<InGuild>>;
+  public pin(reason?: string): Promise<Message<InGuild>>;
+  public react(emoji: EmojiIdentifierResolvable): Promise<MessageReaction>;
+  public removeAttachments(): Promise<Message<InGuild>>;
+  public reply(options: string | MessagePayload | MessageReplyOptions): Promise<Message<InGuild>>;
+  public resolveComponent(customId: string): MessageActionRowComponent | null;
+  public startThread(options: StartThreadOptions): Promise<AnyThreadChannel>;
+  public suppressEmbeds(suppress?: boolean): Promise<Message<InGuild>>;
+  public toJSON(): unknown;
+  public toString(): string;
+  public unpin(reason?: string): Promise<Message<InGuild>>;
+  public inGuild(): this is Message<true>;
+}
+
+export class AttachmentBuilder {
+  public constructor(attachment: BufferResolvable | Stream, data?: AttachmentData);
+  public attachment: BufferResolvable | Stream;
+  public description: string | null;
+  public name: string | null;
+  public get spoiler(): boolean;
+  public setDescription(description: string): this;
+  public setFile(attachment: BufferResolvable | Stream, name?: string): this;
+  public setName(name: string): this;
+  public setSpoiler(spoiler?: boolean): this;
+  public toJSON(): unknown;
+  public static from(other: JSONEncodable<AttachmentPayload>): AttachmentBuilder;
+}
+
+export class Attachment {
+  private constructor(data: APIAttachment);
+  private attachment: BufferResolvable | Stream;
+  public contentType: string | null;
+  public description: string | null;
+  public duration: number | null;
+  public ephemeral: boolean;
+  public flags: AttachmentFlagsBitField;
+  public height: number | null;
+  public id: Snowflake;
+  public name: string;
+  public proxyURL: string;
+  public size: number;
+  public get spoiler(): boolean;
+  public url: string;
+  public waveform: string | null;
+  public width: number | null;
+  public toJSON(): unknown;
+}
+
+export type AttachmentFlagsString = keyof typeof AttachmentFlags;
+
+export class AttachmentFlagsBitField extends BitField<AttachmentFlagsString> {
+  public static Flags: Record<AttachmentFlagsString, number>;
+  public static resolve(bit?: BitFieldResolvable<AttachmentFlagsString, number>): number;
+}
+
+export class MessageCollector extends Collector<Snowflake, Message, [Collection<Snowflake, Message>]> {
+  public constructor(channel: TextBasedChannel, options?: MessageCollectorOptions);
+  private _handleChannelDeletion(channel: NonThreadGuildBasedChannel): void;
+  private _handleGuildDeletion(guild: Guild): void;
+
+  public channel: TextBasedChannel;
+  public options: MessageCollectorOptions;
+  public received: number;
+
+  public collect(message: Message): Snowflake | null;
+  public dispose(message: Message): Snowflake | null;
+}
+
+export class MessageComponentInteraction<Cached extends CacheType = CacheType> extends BaseInteraction<Cached> {
+  protected constructor(client: Client<true>, data: RawMessageComponentInteractionData);
+  public type: InteractionType.MessageComponent;
+  public get component(): CacheTypeReducer<
+    Cached,
+    MessageActionRowComponent,
+    Exclude<APIMessageComponent, APIActionRowComponent<APIMessageActionRowComponent>>,
+    MessageActionRowComponent | Exclude<APIMessageComponent, APIActionRowComponent<APIMessageActionRowComponent>>,
+    MessageActionRowComponent | Exclude<APIMessageComponent, APIActionRowComponent<APIMessageActionRowComponent>>
+  >;
+  public componentType: Exclude<ComponentType, ComponentType.ActionRow | ComponentType.TextInput>;
+  public customId: string;
+  public channelId: Snowflake;
+  public deferred: boolean;
+  public ephemeral: boolean | null;
+  public message: Message<BooleanCache<Cached>>;
+  public replied: boolean;
+  public webhook: InteractionWebhook;
+  public inGuild(): this is MessageComponentInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is MessageComponentInteraction<'cached'>;
+  public inRawGuild(): this is MessageComponentInteraction<'raw'>;
+  public deferReply(
+    options: InteractionDeferReplyOptions & { fetchReply: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deferUpdate(
+    options: InteractionDeferUpdateOptions & { fetchReply: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferUpdate(options?: InteractionDeferUpdateOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
+  public editReply(
+    options: string | MessagePayload | InteractionEditReplyOptions,
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
+  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(
+    options: string | MessagePayload | InteractionReplyOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public update(options: InteractionUpdateOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public update(
+    options: string | MessagePayload | InteractionUpdateOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public showModal(
+    modal:
+      | JSONEncodable<APIModalInteractionResponseCallbackData>
+      | ModalComponentData
+      | APIModalInteractionResponseCallbackData,
+  ): Promise<void>;
+  public awaitModalSubmit(
+    options: AwaitModalSubmitOptions<ModalSubmitInteraction>,
+  ): Promise<ModalSubmitInteraction<Cached>>;
+}
+
+export class MessageContextMenuCommandInteraction<
+  Cached extends CacheType = CacheType,
+> extends ContextMenuCommandInteraction<Cached> {
+  public commandType: ApplicationCommandType.Message;
+  public get targetMessage(): NonNullable<CommandInteractionOption<Cached>['message']>;
+  public inGuild(): this is MessageContextMenuCommandInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is MessageContextMenuCommandInteraction<'cached'>;
+  public inRawGuild(): this is MessageContextMenuCommandInteraction<'raw'>;
+}
+
+export type MessageFlagsString = keyof typeof MessageFlags;
+
+export class MessageFlagsBitField extends BitField<MessageFlagsString> {
+  public static Flags: typeof MessageFlags;
+  public static resolve(bit?: BitFieldResolvable<MessageFlagsString, number>): number;
+}
+
+export class MessageMentions<InGuild extends boolean = boolean> {
+  private constructor(
+    message: Message,
+    users: APIUser[] | Collection<Snowflake, User>,
+    roles: Snowflake[] | Collection<Snowflake, Role>,
+    everyone: boolean,
+    repliedUser?: APIUser | User,
+  );
+  private _channels: Collection<Snowflake, Channel> | null;
+  private readonly _content: string;
+  private _members: Collection<Snowflake, GuildMember> | null;
+  private _parsedUsers: Collection<Snowflake, User> | null;
+
+  public get channels(): Collection<Snowflake, Channel>;
+  public readonly client: Client;
+  public everyone: boolean;
+  public readonly guild: If<InGuild, Guild>;
+  public has(data: UserResolvable | RoleResolvable | ChannelResolvable, options?: MessageMentionsHasOptions): boolean;
+  public get members(): If<InGuild, Collection<Snowflake, GuildMember>>;
+  public get parsedUsers(): Collection<Snowflake, User>;
+  public repliedUser: User | null;
+  public roles: Collection<Snowflake, Role>;
+  public users: Collection<Snowflake, User>;
+  public crosspostedChannels: Collection<Snowflake, CrosspostedChannel>;
+  public toJSON(): unknown;
+
+  private static GlobalChannelsPattern: RegExp;
+  private static GlobalUsersPattern: RegExp;
+  public static ChannelsPattern: typeof FormattingPatterns.Channel;
+  public static EveryonePattern: RegExp;
+  public static RolesPattern: typeof FormattingPatterns.Role;
+  public static UsersPattern: typeof FormattingPatterns.User;
+}
+
+export type MessagePayloadOption =
+  | MessageCreateOptions
+  | MessageEditOptions
+  | WebhookMessageCreateOptions
+  | WebhookMessageEditOptions
+  | InteractionReplyOptions
+  | InteractionUpdateOptions;
+
+export class MessagePayload {
+  public constructor(target: MessageTarget, options: MessagePayloadOption);
+  public body: RawMessagePayloadData | null;
+  public get isUser(): boolean;
+  public get isWebhook(): boolean;
+  public get isMessage(): boolean;
+  public get isMessageManager(): boolean;
+  public get isInteraction(): boolean;
+  public files: RawFile[] | null;
+  public options: MessagePayloadOption;
+  public target: MessageTarget;
+
+  public static create(
+    target: MessageTarget,
+    options: string | MessagePayloadOption,
+    extra?: MessagePayloadOption,
+  ): MessagePayload;
+  public static resolveFile(
+    fileLike: BufferResolvable | Stream | AttachmentPayload | JSONEncodable<AttachmentPayload>,
+  ): Promise<RawFile>;
+
+  public makeContent(): string | undefined;
+  public resolveBody(): this;
+  public resolveFiles(): Promise<this>;
+}
+
+export class MessageReaction {
+  private constructor(client: Client<true>, data: RawMessageReactionData, message: Message);
+  private _emoji: GuildEmoji | ReactionEmoji;
+
+  public readonly client: Client<true>;
+  public count: number;
+  public get emoji(): GuildEmoji | ReactionEmoji;
+  public me: boolean;
+  public message: Message | PartialMessage;
+  public get partial(): false;
+  public users: ReactionUserManager;
+  public react(): Promise<MessageReaction>;
+  public remove(): Promise<MessageReaction>;
+  public fetch(): Promise<MessageReaction>;
+  public toJSON(): unknown;
+  public valueOf(): Snowflake | string;
+}
+
+export interface ModalComponentData {
+  customId: string;
+  title: string;
+  components: (
+    | JSONEncodable<APIActionRowComponent<APIModalActionRowComponent>>
+    | ActionRowData<ModalActionRowComponentData>
+  )[];
+}
+
+export interface BaseModalData {
+  customId: string;
+  type: ComponentType;
+}
+
+export interface TextInputModalData extends BaseModalData {
+  type: ComponentType.TextInput;
+  value: string;
+}
+
+export interface ActionRowModalData {
+  type: ComponentType.ActionRow;
+  components: TextInputModalData[];
+}
+
+export class ModalSubmitFields {
+  constructor(components: ModalActionRowComponent[][]);
+  public components: ActionRowModalData[];
+  public fields: Collection<string, ModalActionRowComponent>;
+  public getField<T extends ComponentType>(customId: string, type: T): { type: T } & TextInputModalData;
+  public getField(customId: string, type?: ComponentType): TextInputModalData;
+  public getTextInputValue(customId: string): string;
+}
+
+export interface ModalMessageModalSubmitInteraction<Cached extends CacheType = CacheType>
+  extends ModalSubmitInteraction<Cached> {
+  message: Message<BooleanCache<Cached>>;
+  channelId: Snowflake;
+  update(options: InteractionUpdateOptions & { fetchReply: true }): Promise<Message>;
+  update(
+    options: string | MessagePayload | InteractionUpdateOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  inGuild(): this is ModalMessageModalSubmitInteraction<'raw' | 'cached'>;
+  inCachedGuild(): this is ModalMessageModalSubmitInteraction<'cached'>;
+  inRawGuild(): this is ModalMessageModalSubmitInteraction<'raw'>;
+}
+
+export class ModalSubmitInteraction<Cached extends CacheType = CacheType> extends BaseInteraction<Cached> {
+  private constructor(client: Client<true>, data: APIModalSubmitInteraction);
+  public type: InteractionType.ModalSubmit;
+  public readonly customId: string;
+  public readonly components: ActionRowModalData[];
+  public readonly fields: ModalSubmitFields;
+  public deferred: boolean;
+  public ephemeral: boolean | null;
+  public message: Message<BooleanCache<Cached>> | null;
+  public replied: boolean;
+  public readonly webhook: InteractionWebhook;
+  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(
+    options: string | MessagePayload | InteractionReplyOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
+  public editReply(
+    options: string | MessagePayload | InteractionEditReplyOptions,
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferReply(
+    options: InteractionDeferReplyOptions & { fetchReply: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
+  public deferUpdate(
+    options: InteractionDeferUpdateOptions & { fetchReply: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public deferUpdate(options?: InteractionDeferUpdateOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public inGuild(): this is ModalSubmitInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is ModalSubmitInteraction<'cached'>;
+  public inRawGuild(): this is ModalSubmitInteraction<'raw'>;
+  public isFromMessage(): this is ModalMessageModalSubmitInteraction<Cached>;
+}
+
+export class NewsChannel extends BaseGuildTextChannel {
+  public threads: GuildTextThreadManager<AllowedThreadTypeForNewsChannel>;
+  public type: ChannelType.GuildAnnouncement;
+  public addFollower(channel: TextChannelResolvable, reason?: string): Promise<NewsChannel>;
+}
+
+export class OAuth2Guild extends BaseGuild {
+  private constructor(client: Client<true>, data: RawOAuth2GuildData);
+  public owner: boolean;
+  public permissions: Readonly<PermissionsBitField>;
+}
+
+export class PartialGroupDMChannel extends BaseChannel {
+  private constructor(client: Client<true>, data: RawPartialGroupDMChannelData);
+  public type: ChannelType.GroupDM;
+  public flags: null;
+  public name: string | null;
+  public icon: string | null;
+  public recipients: PartialRecipient[];
+  public iconURL(options?: ImageURLOptions): string | null;
+  public toString(): ChannelMention;
+}
+
+export interface GuildForumTagEmoji {
+  id: Snowflake | null;
+  name: string | null;
+}
+
+export interface GuildForumTag {
+  id: Snowflake;
+  name: string;
+  moderated: boolean;
+  emoji: GuildForumTagEmoji | null;
+}
+
+export type GuildForumTagData = Partial<GuildForumTag> & { name: string };
+
+export interface DefaultReactionEmoji {
+  id: Snowflake | null;
+  name: string | null;
+}
+
+export class ForumChannel extends TextBasedChannelMixin(GuildChannel, true, [
+  'send',
+  'lastMessage',
+  'lastPinAt',
+  'bulkDelete',
+  'sendTyping',
+  'createMessageCollector',
+  'awaitMessages',
+  'createMessageComponentCollector',
+  'awaitMessageComponent',
+]) {
+  public type: ChannelType.GuildForum;
+  public threads: GuildForumThreadManager;
+  public availableTags: GuildForumTag[];
+  public defaultReactionEmoji: DefaultReactionEmoji | null;
+  public defaultThreadRateLimitPerUser: number | null;
+  public rateLimitPerUser: number | null;
+  public defaultAutoArchiveDuration: ThreadAutoArchiveDuration | null;
+  public nsfw: boolean;
+  public topic: string | null;
+  public defaultSortOrder: SortOrderType | null;
+  public defaultForumLayout: ForumLayoutType;
+
+  public setAvailableTags(tags: GuildForumTagData[], reason?: string): Promise<this>;
+  public setDefaultReactionEmoji(emojiId: DefaultReactionEmoji | null, reason?: string): Promise<this>;
+  public setDefaultThreadRateLimitPerUser(rateLimit: number, reason?: string): Promise<this>;
+  public createInvite(options?: InviteCreateOptions): Promise<Invite>;
+  public fetchInvites(cache?: boolean): Promise<Collection<string, Invite>>;
+  public setDefaultAutoArchiveDuration(
+    defaultAutoArchiveDuration: ThreadAutoArchiveDuration,
+    reason?: string,
+  ): Promise<this>;
+  public setTopic(topic: string | null, reason?: string): Promise<this>;
+  public setDefaultSortOrder(defaultSortOrder: SortOrderType | null, reason?: string): Promise<this>;
+  public setDefaultForumLayout(defaultForumLayout: ForumLayoutType, reason?: string): Promise<this>;
+}
+
+export class PermissionOverwrites extends Base {
+  private constructor(client: Client<true>, data: RawPermissionOverwriteData, channel: NonThreadGuildBasedChannel);
+  public allow: Readonly<PermissionsBitField>;
+  public readonly channel: NonThreadGuildBasedChannel;
+  public deny: Readonly<PermissionsBitField>;
+  public id: Snowflake;
+  public type: OverwriteType;
+  public edit(options: PermissionOverwriteOptions, reason?: string): Promise<PermissionOverwrites>;
+  public delete(reason?: string): Promise<PermissionOverwrites>;
+  public toJSON(): unknown;
+  public static resolveOverwriteOptions(
+    options: PermissionOverwriteOptions,
+    initialPermissions: { allow?: PermissionResolvable; deny?: PermissionResolvable },
+  ): ResolvedOverwriteOptions;
+  public static resolve(overwrite: OverwriteResolvable, guild: Guild): APIOverwrite;
+}
+
+export type PermissionsString = keyof typeof PermissionFlagsBits;
+
+export class PermissionsBitField extends BitField<PermissionsString, bigint> {
+  public any(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+  public has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+  public missing(bits: BitFieldResolvable<PermissionsString, bigint>, checkAdmin?: boolean): PermissionsString[];
+  public serialize(checkAdmin?: boolean): Record<PermissionsString, boolean>;
+  public toArray(): PermissionsString[];
+
+  public static All: bigint;
+  public static Default: bigint;
+  public static StageModerator: bigint;
+  public static Flags: typeof PermissionFlagsBits;
+  public static resolve(permission?: PermissionResolvable): bigint;
+}
+
+export class Presence extends Base {
+  protected constructor(client: Client<true>, data?: RawPresenceData);
+  public activities: Activity[];
+  public clientStatus: ClientPresenceStatusData | null;
+  public guild: Guild | null;
+  public get member(): GuildMember | null;
+  public status: PresenceStatus;
+  public get user(): User | null;
+  public userId: Snowflake;
+  public equals(presence: Presence): boolean;
+}
+
+export class ReactionCollector extends Collector<Snowflake | string, MessageReaction, [User]> {
+  public constructor(message: Message, options?: ReactionCollectorOptions);
+  private _handleChannelDeletion(channel: NonThreadGuildBasedChannel): void;
+  private _handleGuildDeletion(guild: Guild): void;
+  private _handleMessageDeletion(message: Message): void;
+
+  public message: Message;
+  public options: ReactionCollectorOptions;
+  public total: number;
+  public users: Collection<Snowflake, User>;
+
+  public static key(reaction: MessageReaction): Snowflake | string;
+
+  public collect(reaction: MessageReaction, user: User): Snowflake | string | null;
+  public dispose(reaction: MessageReaction, user: User): Snowflake | string | null;
+  public empty(): void;
+
+  public on(
+    event: 'collect' | 'dispose' | 'remove' | 'ignore',
+    listener: (reaction: MessageReaction, user: User) => void,
+  ): this;
+  public on(event: 'end', listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void): this;
+  public on(event: string, listener: (...args: any[]) => void): this;
+
+  public once(
+    event: 'collect' | 'dispose' | 'remove' | 'ignore',
+    listener: (reaction: MessageReaction, user: User) => void,
+  ): this;
+  public once(
+    event: 'end',
+    listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void,
+  ): this;
+  public once(event: string, listener: (...args: any[]) => void): this;
+}
+
+export class ReactionEmoji extends Emoji {
+  private constructor(reaction: MessageReaction, emoji: RawReactionEmojiData);
+  public reaction: MessageReaction;
+  public toJSON(): unknown;
+}
+
+export class RichPresenceAssets {
+  private constructor(activity: Activity, assets: RawRichPresenceAssets);
+  public readonly activity: Activity;
+  public largeImage: Snowflake | null;
+  public largeText: string | null;
+  public smallImage: Snowflake | null;
+  public smallText: string | null;
+  public largeImageURL(options?: ImageURLOptions): string | null;
+  public smallImageURL(options?: ImageURLOptions): string | null;
+}
+
+export class Role extends Base {
+  private constructor(client: Client<true>, data: RawRoleData, guild: Guild);
+  public color: number;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public get editable(): boolean;
+  public flags: RoleFlagsBitField;
+  public guild: Guild;
+  public get hexColor(): HexColorString;
+  public hoist: boolean;
+  public id: Snowflake;
+  public managed: boolean;
+  public get members(): Collection<Snowflake, GuildMember>;
+  public mentionable: boolean;
+  public name: string;
+  public permissions: Readonly<PermissionsBitField>;
+  public get position(): number;
+  public rawPosition: number;
+  public tags: RoleTagData | null;
+  public comparePositionTo(role: RoleResolvable): number;
+  public icon: string | null;
+  public unicodeEmoji: string | null;
+  public delete(reason?: string): Promise<Role>;
+  public edit(options: RoleEditOptions): Promise<Role>;
+  public equals(role: Role): boolean;
+  public iconURL(options?: ImageURLOptions): string | null;
+  public permissionsIn(
+    channel: NonThreadGuildBasedChannel | Snowflake,
+    checkAdmin?: boolean,
+  ): Readonly<PermissionsBitField>;
+  public setColor(color: ColorResolvable, reason?: string): Promise<Role>;
+  public setHoist(hoist?: boolean, reason?: string): Promise<Role>;
+  public setMentionable(mentionable?: boolean, reason?: string): Promise<Role>;
+  public setName(name: string, reason?: string): Promise<Role>;
+  public setPermissions(permissions: PermissionResolvable, reason?: string): Promise<Role>;
+  public setIcon(icon: BufferResolvable | Base64Resolvable | EmojiResolvable | null, reason?: string): Promise<Role>;
+  public setPosition(position: number, options?: SetRolePositionOptions): Promise<Role>;
+  public setUnicodeEmoji(unicodeEmoji: string | null, reason?: string): Promise<Role>;
+  public toJSON(): unknown;
+  public toString(): RoleMention;
+}
+
+export type RoleFlagsString = keyof typeof RoleFlags;
+
+export class RoleFlagsBitField extends BitField<RoleFlagsString> {
+  public static Flags: typeof RoleFlags;
+  public static resolve(bit?: BitFieldResolvable<RoleFlagsString, number>): number;
+}
+
+export class StringSelectMenuInteraction<
+  Cached extends CacheType = CacheType,
+> extends MessageComponentInteraction<Cached> {
+  public constructor(client: Client<true>, data: APIMessageStringSelectInteractionData);
+  public get component(): CacheTypeReducer<
+    Cached,
+    StringSelectMenuComponent,
+    APIStringSelectComponent,
+    StringSelectMenuComponent | APIStringSelectComponent,
+    StringSelectMenuComponent | APIStringSelectComponent
+  >;
+  public componentType: ComponentType.StringSelect;
+  public values: string[];
+  public inGuild(): this is StringSelectMenuInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is StringSelectMenuInteraction<'cached'>;
+  public inRawGuild(): this is StringSelectMenuInteraction<'raw'>;
+}
+
+export {
+  /** @deprecated Use {@link StringSelectMenuInteraction} instead */
+  StringSelectMenuInteraction as SelectMenuInteraction,
+};
+
+export class UserSelectMenuInteraction<
+  Cached extends CacheType = CacheType,
+> extends MessageComponentInteraction<Cached> {
+  public constructor(client: Client<true>, data: APIMessageUserSelectInteractionData);
+  public get component(): CacheTypeReducer<
+    Cached,
+    UserSelectMenuComponent,
+    APIUserSelectComponent,
+    UserSelectMenuComponent | APIUserSelectComponent,
+    UserSelectMenuComponent | APIUserSelectComponent
+  >;
+  public componentType: ComponentType.UserSelect;
+  public values: Snowflake[];
+  public users: Collection<Snowflake, User>;
+  public members: Collection<
+    Snowflake,
+    CacheTypeReducer<Cached, GuildMember, APIGuildMember, GuildMember | APIGuildMember, GuildMember | APIGuildMember>
+  >;
+  public inGuild(): this is UserSelectMenuInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is UserSelectMenuInteraction<'cached'>;
+  public inRawGuild(): this is UserSelectMenuInteraction<'raw'>;
+}
+
+export class RoleSelectMenuInteraction<
+  Cached extends CacheType = CacheType,
+> extends MessageComponentInteraction<Cached> {
+  public constructor(client: Client<true>, data: APIMessageRoleSelectInteractionData);
+  public get component(): CacheTypeReducer<
+    Cached,
+    RoleSelectMenuComponent,
+    APIRoleSelectComponent,
+    RoleSelectMenuComponent | APIRoleSelectComponent,
+    RoleSelectMenuComponent | APIRoleSelectComponent
+  >;
+  public componentType: ComponentType.RoleSelect;
+  public values: Snowflake[];
+  public roles: Collection<Snowflake, CacheTypeReducer<Cached, Role, APIRole, Role | APIRole, Role | APIRole>>;
+  public inGuild(): this is RoleSelectMenuInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is RoleSelectMenuInteraction<'cached'>;
+  public inRawGuild(): this is RoleSelectMenuInteraction<'raw'>;
+}
+
+export class MentionableSelectMenuInteraction<
+  Cached extends CacheType = CacheType,
+> extends MessageComponentInteraction<Cached> {
+  public constructor(client: Client<true>, data: APIMessageMentionableSelectInteractionData);
+  public get component(): CacheTypeReducer<
+    Cached,
+    MentionableSelectMenuComponent,
+    APIMentionableSelectComponent,
+    MentionableSelectMenuComponent | APIMentionableSelectComponent,
+    MentionableSelectMenuComponent | APIMentionableSelectComponent
+  >;
+  public componentType: ComponentType.MentionableSelect;
+  public values: Snowflake[];
+  public users: Collection<Snowflake, User>;
+  public members: Collection<
+    Snowflake,
+    CacheTypeReducer<Cached, GuildMember, APIGuildMember, GuildMember | APIGuildMember, GuildMember | APIGuildMember>
+  >;
+  public roles: Collection<Snowflake, CacheTypeReducer<Cached, Role, APIRole, Role | APIRole, Role | APIRole>>;
+  public inGuild(): this is MentionableSelectMenuInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is MentionableSelectMenuInteraction<'cached'>;
+  public inRawGuild(): this is MentionableSelectMenuInteraction<'raw'>;
+}
+
+export class ChannelSelectMenuInteraction<
+  Cached extends CacheType = CacheType,
+> extends MessageComponentInteraction<Cached> {
+  public constructor(client: Client<true>, data: APIMessageChannelSelectInteractionData);
+  public get component(): CacheTypeReducer<
+    Cached,
+    ChannelSelectMenuComponent,
+    APIChannelSelectComponent,
+    ChannelSelectMenuComponent | APIChannelSelectComponent,
+    ChannelSelectMenuComponent | APIChannelSelectComponent
+  >;
+  public componentType: ComponentType.ChannelSelect;
+  public values: Snowflake[];
+  public channels: Collection<
+    Snowflake,
+    CacheTypeReducer<Cached, Channel, APIChannel, Channel | APIChannel, Channel | APIChannel>
+  >;
+  public inGuild(): this is ChannelSelectMenuInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is ChannelSelectMenuInteraction<'cached'>;
+  public inRawGuild(): this is ChannelSelectMenuInteraction<'raw'>;
+}
+
+// Ideally this should be named SelectMenuInteraction, but that's the name of the "old" StringSelectMenuInteraction, meaning
+// the type name is reserved as a re-export to prevent a breaking change from being made, as such:
+// TODO: Rename this to SelectMenuInteraction in the next major
+export type AnySelectMenuInteraction<Cached extends CacheType = CacheType> =
+  | StringSelectMenuInteraction<Cached>
+  | UserSelectMenuInteraction<Cached>
+  | RoleSelectMenuInteraction<Cached>
+  | MentionableSelectMenuInteraction<Cached>
+  | ChannelSelectMenuInteraction<Cached>;
+
+export type SelectMenuType = APISelectMenuComponent['type'];
+
+export interface ShardEventTypes {
+  death: [process: ChildProcess | Worker];
+  disconnect: [];
+  error: [error: Error];
+  message: [message: any];
+  ready: [];
+  reconnecting: [];
+  resume: [];
+  spawn: [process: ChildProcess | Worker];
+}
+
+export class Shard extends EventEmitter {
+  private constructor(manager: ShardingManager, id: number);
+  private _evals: Map<string, Promise<unknown>>;
+  private _exitListener: (...args: any[]) => void;
+  private _fetches: Map<string, Promise<unknown>>;
+  private _handleExit(respawn?: boolean, timeout?: number): void;
+  private _handleMessage(message: unknown): void;
+  private incrementMaxListeners(emitter: EventEmitter | ChildProcess): void;
+  private decrementMaxListeners(emitter: EventEmitter | ChildProcess): void;
+
+  public args: string[];
+  public execArgv: string[];
+  public env: unknown;
+  public id: number;
+  public manager: ShardingManager;
+  public process: ChildProcess | null;
+  public ready: boolean;
+  public silent: boolean;
+  public worker: Worker | null;
+  public eval(script: string): Promise<unknown>;
+  public eval<T>(fn: (client: Client) => T): Promise<T>;
+  public eval<T, P>(fn: (client: Client<true>, context: Serialized<P>) => T, context: P): Promise<T>;
+  public fetchClientValue(prop: string): Promise<unknown>;
+  public kill(): void;
+  public respawn(options?: { delay?: number; timeout?: number }): Promise<ChildProcess>;
+  public send(message: unknown): Promise<Shard>;
+  public spawn(timeout?: number): Promise<ChildProcess>;
+
+  public on<K extends keyof ShardEventTypes>(
+    event: K,
+    listener: (...args: ShardEventTypes[K]) => Awaitable<void>,
+  ): this;
+
+  public once<K extends keyof ShardEventTypes>(
+    event: K,
+    listener: (...args: ShardEventTypes[K]) => Awaitable<void>,
+  ): this;
+}
+
+export class ShardClientUtil {
+  private constructor(client: Client<true>, mode: ShardingManagerMode);
+  private _handleMessage(message: unknown): void;
+  private _respond(type: string, message: unknown): void;
+  private incrementMaxListeners(emitter: EventEmitter | ChildProcess): void;
+  private decrementMaxListeners(emitter: EventEmitter | ChildProcess): void;
+
+  public client: Client;
+  public get count(): number;
+  public get ids(): number[];
+  public mode: ShardingManagerMode;
+  public parentPort: MessagePort | null;
+  public broadcastEval<T>(fn: (client: Client) => Awaitable<T>): Promise<Serialized<T>[]>;
+  public broadcastEval<T>(fn: (client: Client) => Awaitable<T>, options: { shard: number }): Promise<Serialized<T>>;
+  public broadcastEval<T, P>(
+    fn: (client: Client<true>, context: Serialized<P>) => Awaitable<T>,
+    options: { context: P },
+  ): Promise<Serialized<T>[]>;
+  public broadcastEval<T, P>(
+    fn: (client: Client<true>, context: Serialized<P>) => Awaitable<T>,
+    options: { context: P; shard: number },
+  ): Promise<Serialized<T>>;
+  public fetchClientValues(prop: string): Promise<unknown[]>;
+  public fetchClientValues(prop: string, shard: number): Promise<unknown>;
+  public respawnAll(options?: MultipleShardRespawnOptions): Promise<void>;
+  public send(message: unknown): Promise<void>;
+
+  public static singleton(client: Client<true>, mode: ShardingManagerMode): ShardClientUtil;
+  public static shardIdForGuildId(guildId: Snowflake, shardCount: number): number;
+}
+
+export class ShardingManager extends EventEmitter {
+  public constructor(file: string, options?: ShardingManagerOptions);
+  private _performOnShards(method: string, args: unknown[]): Promise<unknown[]>;
+  private _performOnShards(method: string, args: unknown[], shard: number): Promise<unknown>;
+
+  public file: string;
+  public respawn: boolean;
+  public silent: boolean;
+  public shardArgs: string[];
+  public shards: Collection<number, Shard>;
+  public token: string | null;
+  public totalShards: number | 'auto';
+  public shardList: number[] | 'auto';
+  public broadcast(message: unknown): Promise<Shard[]>;
+  public broadcastEval<T>(fn: (client: Client) => Awaitable<T>): Promise<Serialized<T>[]>;
+  public broadcastEval<T>(fn: (client: Client) => Awaitable<T>, options: { shard: number }): Promise<Serialized<T>>;
+  public broadcastEval<T, P>(
+    fn: (client: Client<true>, context: Serialized<P>) => Awaitable<T>,
+    options: { context: P },
+  ): Promise<Serialized<T>[]>;
+  public broadcastEval<T, P>(
+    fn: (client: Client<true>, context: Serialized<P>) => Awaitable<T>,
+    options: { context: P; shard: number },
+  ): Promise<Serialized<T>>;
+  public createShard(id: number): Shard;
+  public fetchClientValues(prop: string): Promise<unknown[]>;
+  public fetchClientValues(prop: string, shard: number): Promise<unknown>;
+  public respawnAll(options?: MultipleShardRespawnOptions): Promise<Collection<number, Shard>>;
+  public spawn(options?: MultipleShardSpawnOptions): Promise<Collection<number, Shard>>;
+
+  public on(event: 'shardCreate', listener: (shard: Shard) => Awaitable<void>): this;
+
+  public once(event: 'shardCreate', listener: (shard: Shard) => Awaitable<void>): this;
+}
+
+export interface FetchRecommendedShardCountOptions {
+  guildsPerShard?: number;
+  multipleOf?: number;
+}
+
+export {
+  DiscordSnowflake as SnowflakeUtil,
+  SnowflakeGenerateOptions,
+  DeconstructedSnowflake,
+} from '@sapphire/snowflake';
+
+export class StageChannel extends BaseGuildVoiceChannel {
+  public get stageInstance(): StageInstance | null;
+  public topic: string | null;
+  public type: ChannelType.GuildStageVoice;
+  public createStageInstance(options: StageInstanceCreateOptions): Promise<StageInstance>;
+  public setTopic(topic: string): Promise<StageChannel>;
+}
+
+export class DirectoryChannel extends BaseChannel {
+  public flags: Readonly<ChannelFlagsBitField>;
+  public guild: InviteGuild;
+  public guildId: Snowflake;
+  public name: string;
+}
+
+export class StageInstance extends Base {
+  private constructor(client: Client<true>, data: RawStageInstanceData, channel: StageChannel);
+  public id: Snowflake;
+  public guildId: Snowflake;
+  public channelId: Snowflake;
+  public topic: string;
+  public privacyLevel: StageInstancePrivacyLevel;
+  /** @deprecated See https://github.com/discord/discord-api-docs/pull/4296 for more information */
+  public discoverableDisabled: boolean | null;
+  public guildScheduledEventId?: Snowflake;
+  public get channel(): StageChannel | null;
+  public get guild(): Guild | null;
+  public get guildScheduledEvent(): GuildScheduledEvent | null;
+  public edit(options: StageInstanceEditOptions): Promise<StageInstance>;
+  public delete(): Promise<StageInstance>;
+  public setTopic(topic: string): Promise<StageInstance>;
+  public get createdTimestamp(): number;
+  public get createdAt(): Date;
+}
+
+export class Sticker extends Base {
+  private constructor(client: Client<true>, data: RawStickerData);
+  public get createdTimestamp(): number;
+  public get createdAt(): Date;
+  public available: boolean | null;
+  public description: string | null;
+  public format: StickerFormatType;
+  public get guild(): Guild | null;
+  public guildId: Snowflake | null;
+  public id: Snowflake;
+  public name: string;
+  public packId: Snowflake | null;
+  public get partial(): boolean;
+  public sortValue: number | null;
+  public tags: string | null;
+  public type: StickerType | null;
+  public user: User | null;
+  public get url(): string;
+  public fetch(): Promise<Sticker>;
+  public fetchPack(): Promise<StickerPack | null>;
+  public fetchUser(): Promise<User | null>;
+  public edit(options?: GuildStickerEditOptions): Promise<Sticker>;
+  public delete(reason?: string): Promise<Sticker>;
+  public equals(other: Sticker | unknown): boolean;
+}
+
+export class StickerPack extends Base {
+  private constructor(client: Client<true>, data: RawStickerPackData);
+  public get createdTimestamp(): number;
+  public get createdAt(): Date;
+  public bannerId: Snowflake | null;
+  public get coverSticker(): Sticker | null;
+  public coverStickerId: Snowflake | null;
+  public description: string;
+  public id: Snowflake;
+  public name: string;
+  public skuId: Snowflake;
+  public stickers: Collection<Snowflake, Sticker>;
+  public bannerURL(options?: ImageURLOptions): string | null;
+}
+
+export class Sweepers {
+  public constructor(client: Client<true>, options: SweeperOptions);
+  public readonly client: Client;
+  public intervals: Record<SweeperKey, NodeJS.Timeout | null>;
+  public options: SweeperOptions;
+
+  public sweepApplicationCommands(
+    filter: CollectionSweepFilter<
+      SweeperDefinitions['applicationCommands'][0],
+      SweeperDefinitions['applicationCommands'][1]
+    >,
+  ): number;
+  public sweepAutoModerationRules(
+    filter: CollectionSweepFilter<
+      SweeperDefinitions['autoModerationRules'][0],
+      SweeperDefinitions['autoModerationRules'][1]
+    >,
+  ): number;
+  public sweepBans(filter: CollectionSweepFilter<SweeperDefinitions['bans'][0], SweeperDefinitions['bans'][1]>): number;
+  public sweepEmojis(
+    filter: CollectionSweepFilter<SweeperDefinitions['emojis'][0], SweeperDefinitions['emojis'][1]>,
+  ): number;
+  public sweepInvites(
+    filter: CollectionSweepFilter<SweeperDefinitions['invites'][0], SweeperDefinitions['invites'][1]>,
+  ): number;
+  public sweepGuildMembers(
+    filter: CollectionSweepFilter<SweeperDefinitions['guildMembers'][0], SweeperDefinitions['guildMembers'][1]>,
+  ): number;
+  public sweepMessages(
+    filter: CollectionSweepFilter<SweeperDefinitions['messages'][0], SweeperDefinitions['messages'][1]>,
+  ): number;
+  public sweepPresences(
+    filter: CollectionSweepFilter<SweeperDefinitions['presences'][0], SweeperDefinitions['presences'][1]>,
+  ): number;
+  public sweepReactions(
+    filter: CollectionSweepFilter<SweeperDefinitions['reactions'][0], SweeperDefinitions['reactions'][1]>,
+  ): number;
+  public sweepStageInstances(
+    filter: CollectionSweepFilter<SweeperDefinitions['stageInstances'][0], SweeperDefinitions['stageInstances'][1]>,
+  ): number;
+  public sweepStickers(
+    filter: CollectionSweepFilter<SweeperDefinitions['stickers'][0], SweeperDefinitions['stickers'][1]>,
+  ): number;
+  public sweepThreadMembers(
+    filter: CollectionSweepFilter<SweeperDefinitions['threadMembers'][0], SweeperDefinitions['threadMembers'][1]>,
+  ): number;
+  public sweepThreads(
+    filter: CollectionSweepFilter<SweeperDefinitions['threads'][0], SweeperDefinitions['threads'][1]>,
+  ): number;
+  public sweepUsers(
+    filter: CollectionSweepFilter<SweeperDefinitions['users'][0], SweeperDefinitions['users'][1]>,
+  ): number;
+  public sweepVoiceStates(
+    filter: CollectionSweepFilter<SweeperDefinitions['voiceStates'][0], SweeperDefinitions['voiceStates'][1]>,
+  ): number;
+
+  public static archivedThreadSweepFilter(
+    lifetime?: number,
+  ): GlobalSweepFilter<SweeperDefinitions['threads'][0], SweeperDefinitions['threads'][1]>;
+  public static expiredInviteSweepFilter(
+    lifetime?: number,
+  ): GlobalSweepFilter<SweeperDefinitions['invites'][0], SweeperDefinitions['invites'][1]>;
+  public static filterByLifetime<K, V>(options?: LifetimeFilterOptions<K, V>): GlobalSweepFilter<K, V>;
+  public static outdatedMessageSweepFilter(
+    lifetime?: number,
+  ): GlobalSweepFilter<SweeperDefinitions['messages'][0], SweeperDefinitions['messages'][1]>;
+}
+
+export type SystemChannelFlagsString = keyof typeof GuildSystemChannelFlags;
+
+export class SystemChannelFlagsBitField extends BitField<SystemChannelFlagsString> {
+  public static Flags: typeof GuildSystemChannelFlags;
+  public static resolve(bit?: BitFieldResolvable<SystemChannelFlagsString, number>): number;
+}
+
+export class Team extends Base {
+  private constructor(client: Client<true>, data: RawTeamData);
+  public id: Snowflake;
+  public name: string;
+  public icon: string | null;
+  public ownerId: Snowflake | null;
+  public members: Collection<Snowflake, TeamMember>;
+  public get owner(): TeamMember | null;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+
+  public iconURL(options?: ImageURLOptions): string | null;
+  public toJSON(): unknown;
+  public toString(): string;
+}
+
+export class TeamMember extends Base {
+  private constructor(team: Team, data: RawTeamMemberData);
+  public team: Team;
+  public get id(): Snowflake;
+  public permissions: string[];
+  public membershipState: TeamMemberMembershipState;
+  public user: User;
+
+  public toString(): UserMention;
+}
+
+export class TextChannel extends BaseGuildTextChannel {
+  public rateLimitPerUser: number;
+  public threads: GuildTextThreadManager<AllowedThreadTypeForTextChannel>;
+  public type: ChannelType.GuildText;
+}
+
+export type AnyThreadChannel<Forum extends boolean = boolean> = PublicThreadChannel<Forum> | PrivateThreadChannel;
+
+export interface PublicThreadChannel<Forum extends boolean = boolean> extends ThreadChannel<Forum> {
+  type: ChannelType.PublicThread | ChannelType.AnnouncementThread;
+}
+
+export interface PrivateThreadChannel extends ThreadChannel<false> {
+  get createdTimestamp(): number;
+  get createdAt(): Date;
+  type: ChannelType.PrivateThread;
+}
+
+export class ThreadChannel<Forum extends boolean = boolean> extends TextBasedChannelMixin(BaseChannel, true, [
+  'fetchWebhooks',
+  'createWebhook',
+  'setNSFW',
+]) {
+  private constructor(guild: Guild, data?: RawThreadChannelData, client?: Client<true>);
+  public archived: boolean | null;
+  public get archivedAt(): Date | null;
+  public archiveTimestamp: number | null;
+  public get createdAt(): Date | null;
+  private _createdTimestamp: number | null;
+  public get createdTimestamp(): number | null;
+  public autoArchiveDuration: ThreadAutoArchiveDuration | null;
+  public get editable(): boolean;
+  public flags: Readonly<ChannelFlagsBitField>;
+  public guild: Guild;
+  public guildId: Snowflake;
+  public get guildMembers(): Collection<Snowflake, GuildMember>;
+  public invitable: boolean | null;
+  public get joinable(): boolean;
+  public get joined(): boolean;
+  public locked: boolean | null;
+  public get manageable(): boolean;
+  public get viewable(): boolean;
+  public get sendable(): boolean;
+  public memberCount: number | null;
+  public messageCount: number | null;
+  public appliedTags: Snowflake[];
+  public totalMessageSent: number | null;
+  public members: ThreadMemberManager;
+  public name: string;
+  public ownerId: Snowflake | null;
+  public get parent(): If<Forum, ForumChannel, TextChannel | NewsChannel> | null;
+  public parentId: Snowflake | null;
+  public rateLimitPerUser: number | null;
+  public type: ThreadChannelType;
+  public get unarchivable(): boolean;
+  public delete(reason?: string): Promise<this>;
+  public edit(options: ThreadEditOptions): Promise<AnyThreadChannel>;
+  public join(): Promise<AnyThreadChannel>;
+  public leave(): Promise<AnyThreadChannel>;
+  public permissionsFor(memberOrRole: GuildMember | Role, checkAdmin?: boolean): Readonly<PermissionsBitField>;
+  public permissionsFor(
+    memberOrRole: GuildMemberResolvable | RoleResolvable,
+    checkAdmin?: boolean,
+  ): Readonly<PermissionsBitField> | null;
+  public fetchOwner(options?: BaseFetchOptions): Promise<ThreadMember | null>;
+  public fetchStarterMessage(options?: BaseFetchOptions): Promise<Message<true> | null>;
+  public setArchived(archived?: boolean, reason?: string): Promise<AnyThreadChannel>;
+  public setAutoArchiveDuration(
+    autoArchiveDuration: ThreadAutoArchiveDuration,
+    reason?: string,
+  ): Promise<AnyThreadChannel>;
+  public setInvitable(invitable?: boolean, reason?: string): Promise<AnyThreadChannel>;
+  public setLocked(locked?: boolean, reason?: string): Promise<AnyThreadChannel>;
+  public setName(name: string, reason?: string): Promise<AnyThreadChannel>;
+  // The following 3 methods can only be run on forum threads.
+  public setAppliedTags(appliedTags: Snowflake[], reason?: string): Promise<ThreadChannel<true>>;
+  public pin(reason?: string): Promise<ThreadChannel<true>>;
+  public unpin(reason?: string): Promise<ThreadChannel<true>>;
+  public toString(): ChannelMention;
+}
+
+export class ThreadMember<HasMemberData extends boolean = boolean> extends Base {
+  private constructor(thread: ThreadChannel, data: RawThreadMemberData, extra?: unknown);
+  public flags: ThreadMemberFlagsBitField;
+  private member: If<HasMemberData, GuildMember>;
+  public get guildMember(): HasMemberData extends true ? GuildMember : GuildMember | null;
+  public id: Snowflake;
+  public get joinedAt(): Date | null;
+  public joinedTimestamp: number | null;
+  public get manageable(): boolean;
+  public thread: AnyThreadChannel;
+  public get user(): User | null;
+  public get partial(): false;
+  public remove(reason?: string): Promise<ThreadMember>;
+}
+
+export type ThreadMemberFlagsString = keyof typeof ThreadMemberFlags;
+
+export class ThreadMemberFlagsBitField extends BitField<ThreadMemberFlagsString> {
+  public static Flags: typeof ThreadMemberFlags;
+  public static resolve(bit?: BitFieldResolvable<ThreadMemberFlagsString, number>): number;
+}
+
+export class Typing extends Base {
+  private constructor(channel: TextBasedChannel, user: PartialUser, data?: RawTypingData);
+  public channel: TextBasedChannel;
+  public user: User | PartialUser;
+  public startedTimestamp: number;
+  public get startedAt(): Date;
+  public get guild(): Guild | null;
+  public get member(): GuildMember | null;
+  public inGuild(): this is this & {
+    channel: TextChannel | NewsChannel | ThreadChannel;
+    get guild(): Guild;
+  };
+}
+
+export class User extends PartialTextBasedChannel(Base) {
+  protected constructor(client: Client<true>, data: RawUserData);
+  private _equals(user: APIUser): boolean;
+
+  public accentColor: number | null | undefined;
+  public avatar: string | null;
+  public avatarDecoration: string | null;
+  public banner: string | null | undefined;
+  public bot: boolean;
+  public get createdAt(): Date;
+  public get createdTimestamp(): number;
+  public discriminator: string;
+  public get displayName(): string;
+  public get defaultAvatarURL(): string;
+  public get dmChannel(): DMChannel | null;
+  public flags: Readonly<UserFlagsBitField> | null;
+  public globalName: string | null;
+  public get hexAccentColor(): HexColorString | null | undefined;
+  public id: Snowflake;
+  public get partial(): false;
+  public system: boolean;
+  public get tag(): string;
+  public username: string;
+  public avatarURL(options?: ImageURLOptions): string | null;
+  public avatarDecorationURL(options?: BaseImageURLOptions): string | null;
+  public bannerURL(options?: ImageURLOptions): string | null | undefined;
+  public createDM(force?: boolean): Promise<DMChannel>;
+  public deleteDM(): Promise<DMChannel>;
+  public displayAvatarURL(options?: ImageURLOptions): string;
+  public equals(user: User): boolean;
+  public fetch(force?: boolean): Promise<User>;
+  public fetchFlags(force?: boolean): Promise<UserFlagsBitField>;
+  public toString(): UserMention;
+}
+
+export class UserContextMenuCommandInteraction<
+  Cached extends CacheType = CacheType,
+> extends ContextMenuCommandInteraction<Cached> {
+  public commandType: ApplicationCommandType.User;
+  public get targetUser(): User;
+  public get targetMember(): CacheTypeReducer<Cached, GuildMember, APIInteractionGuildMember>;
+  public inGuild(): this is UserContextMenuCommandInteraction<'raw' | 'cached'>;
+  public inCachedGuild(): this is UserContextMenuCommandInteraction<'cached'>;
+  public inRawGuild(): this is UserContextMenuCommandInteraction<'raw'>;
+}
+
+export type UserFlagsString = keyof typeof UserFlags;
+
+export class UserFlagsBitField extends BitField<UserFlagsString> {
+  public static Flags: typeof UserFlags;
+  public static resolve(bit?: BitFieldResolvable<UserFlagsString, number>): number;
+}
+
+export function basename(path: string, ext?: string): string;
+export function cleanContent(str: string, channel: TextBasedChannel): string;
+export function discordSort<K, V extends { rawPosition: number; id: Snowflake }>(
+  collection: Collection<K, V>,
+): Collection<K, V>;
+export function cleanCodeBlockContent(text: string): string;
+export function fetchRecommendedShardCount(token: string, options?: FetchRecommendedShardCountOptions): Promise<number>;
+export function flatten(obj: unknown, ...props: Record<string, boolean | string>[]): unknown;
+export function makeError(obj: MakeErrorOptions): Error;
+export function makePlainError(err: Error): MakeErrorOptions;
+export function mergeDefault(def: unknown, given: unknown): unknown;
+export function moveElementInArray(array: unknown[], element: unknown, newIndex: number, offset?: boolean): number;
+export function parseEmoji(text: string): { animated: boolean; name: string; id: Snowflake | null } | null;
+export function resolveColor(color: ColorResolvable): number;
+export function resolvePartialEmoji(emoji: EmojiIdentifierResolvable): Partial<APIPartialEmoji> | null;
+export function verifyString(data: string, error?: typeof Error, errorMessage?: string, allowEmpty?: boolean): string;
+export function setPosition<T extends Channel | Role>(
+  item: T,
+  position: number,
+  relative: boolean,
+  sorted: Collection<Snowflake, T>,
+  client: Client<true>,
+  route: string,
+  reason?: string,
+): Promise<{ id: Snowflake; position: number }[]>;
+export function parseWebhookURL(url: string): WebhookClientDataIdWithToken | null;
+
+export interface MappedComponentBuilderTypes {
+  [ComponentType.Button]: ButtonBuilder;
+  [ComponentType.StringSelect]: StringSelectMenuBuilder;
+  [ComponentType.UserSelect]: UserSelectMenuBuilder;
+  [ComponentType.RoleSelect]: RoleSelectMenuBuilder;
+  [ComponentType.MentionableSelect]: MentionableSelectMenuBuilder;
+  [ComponentType.ChannelSelect]: ChannelSelectMenuBuilder;
+  [ComponentType.ActionRow]: ActionRowBuilder;
+  [ComponentType.TextInput]: TextInputBuilder;
+}
+
+export interface MappedComponentTypes {
+  [ComponentType.Button]: ButtonComponent;
+  [ComponentType.StringSelect]: StringSelectMenuComponent;
+  [ComponentType.UserSelect]: UserSelectMenuComponent;
+  [ComponentType.RoleSelect]: RoleSelectMenuComponent;
+  [ComponentType.MentionableSelect]: MentionableSelectMenuComponent;
+  [ComponentType.ChannelSelect]: ChannelSelectMenuComponent;
+  [ComponentType.ActionRow]: ActionRowComponent;
+  [ComponentType.TextInput]: TextInputComponent;
+}
+
+export interface ChannelCreateOptions {
+  allowFromUnknownGuild?: boolean;
+}
+
+export function createChannel(client: Client<true>, data: APIChannel, options?: ChannelCreateOptions): Channel;
+
+export function createComponent<T extends keyof MappedComponentTypes>(
+  data: APIMessageComponent & { type: T },
+): MappedComponentTypes[T];
+export function createComponent<C extends Component>(data: C): C;
+export function createComponent(data: APIMessageComponent | Component): Component;
+export function createComponentBuilder<T extends keyof MappedComponentBuilderTypes>(
+  data: APIMessageComponent & { type: T },
+): MappedComponentBuilderTypes[T];
+export function createComponentBuilder<C extends ComponentBuilder>(data: C): C;
+export function createComponentBuilder(data: APIMessageComponent | ComponentBuilder): ComponentBuilder;
+
+/** @deprecated This class is redundant as all methods of the class can be imported from discord.js directly. */
+export class Formatters extends null {
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static blockQuote: typeof blockQuote;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static bold: typeof bold;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static channelMention: typeof channelMention;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static codeBlock: typeof codeBlock;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static formatEmoji: typeof formatEmoji;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static hideLinkEmbed: typeof hideLinkEmbed;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static hyperlink: typeof hyperlink;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static inlineCode: typeof inlineCode;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static italic: typeof italic;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static quote: typeof quote;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static roleMention: typeof roleMention;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static spoiler: typeof spoiler;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static strikethrough: typeof strikethrough;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static time: typeof time;
+  /** @deprecated Import this property directly from discord.js instead. */
+  public static TimestampStyles: typeof TimestampStyles;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static underscore: typeof underscore;
+  /** @deprecated Import this method directly from discord.js instead. */
+  public static userMention: typeof userMention;
+}
+
+export type ComponentData =
+  | MessageActionRowComponentData
+  | ModalActionRowComponentData
+  | ActionRowData<MessageActionRowComponentData | ModalActionRowComponentData>;
+
+export class VoiceChannel extends BaseGuildVoiceChannel {
+  public get speakable(): boolean;
+  public type: ChannelType.GuildVoice;
+}
+
+export class VoiceRegion {
+  private constructor(data: RawVoiceRegionData);
+  public custom: boolean;
+  public deprecated: boolean;
+  public id: string;
+  public name: string;
+  public optimal: boolean;
+  public toJSON(): unknown;
+}
+
+export class VoiceState extends Base {
+  private constructor(guild: Guild, data: RawVoiceStateData);
+  public get channel(): VoiceBasedChannel | null;
+  public channelId: Snowflake | null;
+  public get deaf(): boolean | null;
+  public guild: Guild;
+  public id: Snowflake;
+  public get member(): GuildMember | null;
+  public get mute(): boolean | null;
+  public selfDeaf: boolean | null;
+  public selfMute: boolean | null;
+  public serverDeaf: boolean | null;
+  public serverMute: boolean | null;
+  public sessionId: string | null;
+  public streaming: boolean | null;
+  public selfVideo: boolean | null;
+  public suppress: boolean | null;
+  public requestToSpeakTimestamp: number | null;
+
+  public setDeaf(deaf?: boolean, reason?: string): Promise<GuildMember>;
+  public setMute(mute?: boolean, reason?: string): Promise<GuildMember>;
+  public disconnect(reason?: string): Promise<GuildMember>;
+  public setChannel(channel: GuildVoiceChannelResolvable | null, reason?: string): Promise<GuildMember>;
+  public setRequestToSpeak(request?: boolean): Promise<this>;
+  public setSuppressed(suppressed?: boolean): Promise<this>;
+  public edit(options: VoiceStateEditOptions): Promise<this>;
+}
+
+export class Webhook extends WebhookMixin() {
+  private constructor(client: Client<true>, data?: RawWebhookData);
+  public avatar: string | null;
+  public avatarURL(options?: ImageURLOptions): string | null;
+  public channelId: Snowflake;
+  public readonly client: Client;
+  public guildId: Snowflake;
+  public name: string;
+  public owner: User | APIUser | null;
+  public sourceGuild: Guild | APIPartialGuild | null;
+  public sourceChannel: NewsChannel | APIPartialChannel | null;
+  public token: string | null;
+  public type: WebhookType;
+  public applicationId: Snowflake | null;
+  public get channel(): TextChannel | VoiceChannel | NewsChannel | ForumChannel | StageChannel | null;
+  public isUserCreated(): this is this & {
+    type: WebhookType.Incoming;
+    applicationId: null;
+    owner: User | APIUser;
+  };
+  public isApplicationCreated(): this is this & {
+    type: WebhookType.Application;
+    applicationId: Snowflake;
+    owner: User | APIUser;
+  };
+  public isIncoming(): this is this & {
+    type: WebhookType.Incoming;
+    token: string;
+  };
+  public isChannelFollower(): this is this & {
+    type: WebhookType.ChannelFollower;
+    sourceGuild: Guild | APIPartialGuild;
+    sourceChannel: NewsChannel | APIPartialChannel;
+    token: null;
+    applicationId: null;
+    owner: User | APIUser;
+  };
+
+  public editMessage(
+    message: MessageResolvable,
+    options: string | MessagePayload | WebhookMessageEditOptions,
+  ): Promise<Message>;
+  public fetchMessage(message: Snowflake, options?: WebhookFetchMessageOptions): Promise<Message>;
+  public send(options: string | MessagePayload | WebhookMessageCreateOptions): Promise<Message>;
+}
+
+export class WebhookClient extends WebhookMixin(BaseClient) {
+  public constructor(data: WebhookClientData, options?: WebhookClientOptions);
+  public readonly client: this;
+  public options: WebhookClientOptions;
+  public token: string;
+  public editMessage(
+    message: MessageResolvable,
+    options: string | MessagePayload | WebhookMessageEditOptions,
+  ): Promise<APIMessage>;
+  public fetchMessage(message: Snowflake, options?: WebhookFetchMessageOptions): Promise<APIMessage>;
+  public send(options: string | MessagePayload | WebhookMessageCreateOptions): Promise<APIMessage>;
+}
+
+export class WebSocketManager extends EventEmitter {
+  private constructor(client: Client);
+  private readonly packetQueue: unknown[];
+  private destroyed: boolean;
+
+  public readonly client: Client;
+  public gateway: string | null;
+  public shards: Collection<number, WebSocketShard>;
+  public status: Status;
+  public get ping(): number;
+
+  public on(event: GatewayDispatchEvents, listener: (data: any, shardId: number) => void): this;
+  public once(event: GatewayDispatchEvents, listener: (data: any, shardId: number) => void): this;
+
+  private debug(message: string, shardId?: number): void;
+  private connect(): Promise<void>;
+  private broadcast(packet: unknown): void;
+  private destroy(): Promise<void>;
+  private handlePacket(packet?: unknown, shard?: WebSocketShard): boolean;
+  private checkShardsReady(): void;
+  private triggerClientReady(): void;
+}
+
+export interface WebSocketShardEventTypes {
+  ready: [];
+  resumed: [];
+  invalidSession: [];
+  destroyed: [];
+  close: [event: CloseEvent];
+  allReady: [unavailableGuilds?: Set<Snowflake>];
+}
+
+export class WebSocketShard extends EventEmitter {
+  private constructor(manager: WebSocketManager, id: number);
+  private closeSequence: number;
+  private sessionInfo: SessionInfo | null;
+  public lastPingTimestamp: number;
+  private expectedGuilds: Set<Snowflake> | null;
+  private readyTimeout: NodeJS.Timeout | null;
+
+  public manager: WebSocketManager;
+  public id: number;
+  public status: Status;
+  public ping: number;
+
+  private debug(message: string): void;
+  private onReadyPacket(packet: unknown): void;
+  private gotGuild(guildId: Snowflake): void;
+  private checkReady(): void;
+  private emitClose(event?: CloseEvent): void;
+
+  public send(data: unknown, important?: boolean): void;
+
+  public on<K extends keyof WebSocketShardEventTypes>(
+    event: K,
+    listener: (...args: WebSocketShardEventTypes[K]) => Awaitable<void>,
+  ): this;
+
+  public once<K extends keyof WebSocketShardEventTypes>(
+    event: K,
+    listener: (...args: WebSocketShardEventTypes[K]) => Awaitable<void>,
+  ): this;
+}
+
+export class Widget extends Base {
+  private constructor(client: Client<true>, data: RawWidgetData);
+  private _patch(data: RawWidgetData): void;
+  public fetch(): Promise<Widget>;
+  public id: Snowflake;
+  public name: string;
+  public instantInvite?: string;
+  public channels: Collection<Snowflake, WidgetChannel>;
+  public members: Collection<string, WidgetMember>;
+  public presenceCount: number;
+}
+
+export class WidgetMember extends Base {
+  private constructor(client: Client<true>, data: RawWidgetMemberData);
+  public id: string;
+  public username: string;
+  public discriminator: string;
+  public avatar: string | null;
+  public status: PresenceStatus;
+  public deaf: boolean | null;
+  public mute: boolean | null;
+  public selfDeaf: boolean | null;
+  public selfMute: boolean | null;
+  public suppress: boolean | null;
+  public channelId: Snowflake | null;
+  public avatarURL: string;
+  public activity: WidgetActivity | null;
+}
+
+export class WelcomeChannel extends Base {
+  private constructor(guild: Guild, data: RawWelcomeChannelData);
+  private _emoji: Omit<APIEmoji, 'animated'>;
+  public channelId: Snowflake;
+  public guild: Guild | InviteGuild;
+  public description: string;
+  public get channel(): TextChannel | NewsChannel | ForumChannel | null;
+  public get emoji(): GuildEmoji | Emoji;
+}
+
+export class WelcomeScreen extends Base {
+  private constructor(guild: Guild, data: RawWelcomeScreenData);
+  public get enabled(): boolean;
+  public guild: Guild | InviteGuild;
+  public description: string | null;
+  public welcomeChannels: Collection<Snowflake, WelcomeChannel>;
+}
+
+//#endregion
+
+//#region Constants
+
+export type NonSystemMessageType =
+  | MessageType.Default
+  | MessageType.Reply
+  | MessageType.ChatInputCommand
+  | MessageType.ContextMenuCommand;
+
+export type DeletableMessageType =
+  | MessageType.AutoModerationAction
+  | MessageType.ChannelFollowAdd
+  | MessageType.ChannelPinnedMessage
+  | MessageType.ChatInputCommand
+  | MessageType.ContextMenuCommand
+  | MessageType.Default
+  | MessageType.GuildBoost
+  | MessageType.GuildBoostTier1
+  | MessageType.GuildBoostTier2
+  | MessageType.GuildBoostTier3
+  | MessageType.GuildInviteReminder
+  | MessageType.InteractionPremiumUpsell
+  | MessageType.Reply
+  | MessageType.RoleSubscriptionPurchase
+  | MessageType.StageEnd
+  | MessageType.StageRaiseHand
+  | MessageType.StageSpeaker
+  | MessageType.StageStart
+  | MessageType.StageTopic
+  | MessageType.ThreadCreated
+  | MessageType.UserJoin;
+
+export const Constants: {
+  MaxBulkDeletableMessageAge: 1_209_600_000;
+  SweeperKeys: SweeperKey[];
+  NonSystemMessageTypes: NonSystemMessageType[];
+  TextBasedChannelTypes: TextBasedChannelTypes[];
+  GuildTextBasedChannelTypes: GuildTextBasedChannelTypes[];
+  ThreadChannelTypes: ThreadChannelType[];
+  VoiceBasedChannelTypes: VoiceBasedChannelTypes[];
+  SelectMenuTypes: SelectMenuType[];
+  DeletableMessageTypes: DeletableMessageType[];
+  StickerFormatExtensionMap: Record<StickerFormatType, ImageFormat>;
+};
+
+export const version: string;
+
+//#endregion
+
+//#region Errors
+export enum DiscordjsErrorCodes {
+  ClientInvalidOption = 'ClientInvalidOption',
+  ClientInvalidProvidedShards = 'ClientInvalidProvidedShards',
+  ClientMissingIntents = 'ClientMissingIntents',
+  ClientNotReady = 'ClientNotReady',
+
+  TokenInvalid = 'TokenInvalid',
+  TokenMissing = 'TokenMissing',
+  ApplicationCommandPermissionsTokenMissing = 'ApplicationCommandPermissionsTokenMissing',
+
+  /** @deprecated */
+  WSCloseRequested = 'WSCloseRequested',
+  /** @deprecated */
+  WSConnectionExists = 'WSConnectionExists',
+  /** @deprecated */
+  WSNotOpen = 'WSNotOpen',
+  ManagerDestroyed = 'ManagerDestroyed',
+
+  BitFieldInvalid = 'BitFieldInvalid',
+
+  /** @deprecated */
+  ShardingInvalid = 'ShardingInvalid',
+  /** @deprecated */
+  ShardingRequired = 'ShardingRequired',
+  /** @deprecated */
+  InvalidIntents = 'InvalidIntents',
+  /** @deprecated */
+  DisallowedIntents = 'DisallowedIntents',
+  ShardingNoShards = 'ShardingNoShards',
+  ShardingInProcess = 'ShardingInProcess',
+  ShardingInvalidEvalBroadcast = 'ShardingInvalidEvalBroadcast',
+  ShardingShardNotFound = 'ShardingShardNotFound',
+  ShardingAlreadySpawned = 'ShardingAlreadySpawned',
+  ShardingProcessExists = 'ShardingProcessExists',
+  ShardingWorkerExists = 'ShardingWorkerExists',
+  ShardingReadyTimeout = 'ShardingReadyTimeout',
+  ShardingReadyDisconnected = 'ShardingReadyDisconnected',
+  ShardingReadyDied = 'ShardingReadyDied',
+  ShardingNoChildExists = 'ShardingNoChildExists',
+  ShardingShardMiscalculation = 'ShardingShardMiscalculation',
+
+  ColorRange = 'ColorRange',
+  ColorConvert = 'ColorConvert',
+
+  InviteOptionsMissingChannel = 'InviteOptionsMissingChannel',
+
+  ButtonLabel = 'ButtonLabel',
+  ButtonURL = 'ButtonURL',
+  ButtonCustomId = 'ButtonCustomId',
+
+  SelectMenuCustomId = 'SelectMenuCustomId',
+  SelectMenuPlaceholder = 'SelectMenuPlaceholder',
+  SelectOptionLabel = 'SelectOptionLabel',
+  SelectOptionValue = 'SelectOptionValue',
+  SelectOptionDescription = 'SelectOptionDescription',
+
+  InteractionCollectorError = 'InteractionCollectorError',
+
+  FileNotFound = 'FileNotFound',
+
+  UserBannerNotFetched = 'UserBannerNotFetched',
+  UserNoDMChannel = 'UserNoDMChannel',
+
+  VoiceNotStageChannel = 'VoiceNotStageChannel',
+
+  VoiceStateNotOwn = 'VoiceStateNotOwn',
+  VoiceStateInvalidType = 'VoiceStateInvalidType',
+
+  ReqResourceType = 'ReqResourceType',
+
+  ImageFormat = 'ImageFormat',
+  ImageSize = 'ImageSize',
+
+  MessageBulkDeleteType = 'MessageBulkDeleteType',
+  MessageNonceType = 'MessageNonceType',
+  MessageContentType = 'MessageContentType',
+
+  SplitMaxLen = 'SplitMaxLen',
+
+  BanResolveId = 'BanResolveId',
+  FetchBanResolveId = 'FetchBanResolveId',
+
+  PruneDaysType = 'PruneDaysType',
+
+  GuildChannelResolve = 'GuildChannelResolve',
+  GuildVoiceChannelResolve = 'GuildVoiceChannelResolve',
+  GuildChannelOrphan = 'GuildChannelOrphan',
+  GuildChannelUnowned = 'GuildChannelUnowned',
+  GuildOwned = 'GuildOwned',
+  GuildMembersTimeout = 'GuildMembersTimeout',
+  GuildUncachedMe = 'GuildUncachedMe',
+  ChannelNotCached = 'ChannelNotCached',
+  StageChannelResolve = 'StageChannelResolve',
+  GuildScheduledEventResolve = 'GuildScheduledEventResolve',
+  FetchOwnerId = 'FetchOwnerId',
+
+  InvalidType = 'InvalidType',
+  InvalidElement = 'InvalidElement',
+
+  MessageThreadParent = 'MessageThreadParent',
+  MessageExistingThread = 'MessageExistingThread',
+  ThreadInvitableType = 'ThreadInvitableType',
+
+  WebhookMessage = 'WebhookMessage',
+  WebhookTokenUnavailable = 'WebhookTokenUnavailable',
+  WebhookURLInvalid = 'WebhookURLInvalid',
+  WebhookApplication = 'WebhookApplication',
+  MessageReferenceMissing = 'MessageReferenceMissing',
+
+  EmojiType = 'EmojiType',
+  EmojiManaged = 'EmojiManaged',
+  MissingManageGuildExpressionsPermission = 'MissingManageGuildExpressionsPermission',
+  /** @deprecated Use {@link MissingManageGuildExpressionsPermission} instead. */
+  MissingManageEmojisAndStickersPermission = 'MissingManageEmojisAndStickersPermission',
+
+  NotGuildSticker = 'NotGuildSticker',
+
+  ReactionResolveUser = 'ReactionResolveUser',
+
+  VanityURL = 'VanityURL',
+
+  InviteResolveCode = 'InviteResolveCode',
+
+  InviteNotFound = 'InviteNotFound',
+
+  DeleteGroupDMChannel = 'DeleteGroupDMChannel',
+  FetchGroupDMChannel = 'FetchGroupDMChannel',
+
+  MemberFetchNonceLength = 'MemberFetchNonceLength',
+
+  GlobalCommandPermissions = 'GlobalCommandPermissions',
+  GuildUncachedEntityResolve = 'GuildUncachedEntityResolve',
+
+  InteractionAlreadyReplied = 'InteractionAlreadyReplied',
+  InteractionNotReplied = 'InteractionNotReplied',
+  /** @deprecated */
+  InteractionEphemeralReplied = 'InteractionEphemeralReplied',
+
+  CommandInteractionOptionNotFound = 'CommandInteractionOptionNotFound',
+  CommandInteractionOptionType = 'CommandInteractionOptionType',
+  CommandInteractionOptionEmpty = 'CommandInteractionOptionEmpty',
+  CommandInteractionOptionNoSubcommand = 'CommandInteractionOptionNoSubcommand',
+  CommandInteractionOptionNoSubcommandGroup = 'CommandInteractionOptionNoSubcommandGroup',
+  AutocompleteInteractionOptionNoFocusedOption = 'AutocompleteInteractionOptionNoFocusedOption',
+
+  ModalSubmitInteractionFieldNotFound = 'ModalSubmitInteractionFieldNotFound',
+  ModalSubmitInteractionFieldType = 'ModalSubmitInteractionFieldType',
+
+  InvalidMissingScopes = 'InvalidMissingScopes',
+  InvalidScopesWithPermissions = 'InvalidScopesWithPermissions',
+
+  NotImplemented = 'NotImplemented',
+
+  SweepFilterReturn = 'SweepFilterReturn',
+
+  GuildForumMessageRequired = 'GuildForumMessageRequired',
+}
+
+export interface DiscordjsErrorFields<Name extends string> {
+  readonly name: `${Name} [${DiscordjsErrorCodes}]`;
+  get code(): DiscordjsErrorCodes;
+}
+
+export function DiscordjsErrorMixin<T, N extends string>(
+  Base: Constructable<T>,
+  name: N,
+): Constructable<T & DiscordjsErrorFields<N>>;
+
+export class DiscordjsError extends DiscordjsErrorMixin(Error, 'Error') {}
+
+export class DiscordjsTypeError extends DiscordjsErrorMixin(TypeError, 'TypeError') {}
+
+export class DiscordjsRangeError extends DiscordjsErrorMixin(RangeError, 'RangeError') {}
+
+//#endregion
+
+//#region Managers
+
+export abstract class BaseManager {
+  protected constructor(client: Client);
+  public readonly client: Client;
+}
+
+export abstract class DataManager<K, Holds, R> extends BaseManager {
+  protected constructor(client: Client<true>, holds: Constructable<Holds>);
+  public readonly holds: Constructable<Holds>;
+  public get cache(): Collection<K, Holds>;
+  public resolve(resolvable: Holds): Holds;
+  public resolve(resolvable: R): Holds | null;
+  public resolveId(resolvable: K | Holds): K;
+  public resolveId(resolvable: R): K | null;
+  public valueOf(): Collection<K, Holds>;
+}
+
+export abstract class CachedManager<K, Holds, R> extends DataManager<K, Holds, R> {
+  protected constructor(client: Client<true>, holds: Constructable<Holds>, iterable?: Iterable<Holds>);
+  private readonly _cache: Collection<K, Holds>;
+  private _add(data: unknown, cache?: boolean, { id, extras }?: { id: K; extras: unknown[] }): Holds;
+}
+
+export type ApplicationCommandDataResolvable =
+  | ApplicationCommandData
+  | RESTPostAPIApplicationCommandsJSONBody
+  | JSONEncodable<RESTPostAPIApplicationCommandsJSONBody>;
+
+export class ApplicationCommandManager<
+  ApplicationCommandScope = ApplicationCommand<{ guild: GuildResolvable }>,
+  PermissionsOptionsExtras = { guild: GuildResolvable },
+  PermissionsGuildType = null,
+> extends CachedManager<Snowflake, ApplicationCommandScope, ApplicationCommandResolvable> {
+  protected constructor(client: Client<true>, iterable?: Iterable<unknown>);
+  public permissions: ApplicationCommandPermissionsManager<
+    { command?: ApplicationCommandResolvable } & PermissionsOptionsExtras,
+    { command: ApplicationCommandResolvable } & PermissionsOptionsExtras,
+    PermissionsGuildType,
+    null
+  >;
+  private commandPath({ id, guildId }: { id?: Snowflake; guildId?: Snowflake }): string;
+  public create(command: ApplicationCommandDataResolvable, guildId?: Snowflake): Promise<ApplicationCommandScope>;
+  public delete(command: ApplicationCommandResolvable, guildId?: Snowflake): Promise<ApplicationCommandScope | null>;
+  public edit(
+    command: ApplicationCommandResolvable,
+    data: Partial<ApplicationCommandDataResolvable>,
+  ): Promise<ApplicationCommandScope>;
+  public edit(
+    command: ApplicationCommandResolvable,
+    data: Partial<ApplicationCommandDataResolvable>,
+    guildId: Snowflake,
+  ): Promise<ApplicationCommand>;
+  public fetch(
+    id: Snowflake,
+    options: FetchApplicationCommandOptions & { guildId: Snowflake },
+  ): Promise<ApplicationCommand>;
+  public fetch(options: FetchApplicationCommandOptions): Promise<Collection<string, ApplicationCommandScope>>;
+  public fetch(id: Snowflake, options?: FetchApplicationCommandOptions): Promise<ApplicationCommandScope>;
+  public fetch(
+    id?: Snowflake,
+    options?: FetchApplicationCommandOptions,
+  ): Promise<Collection<Snowflake, ApplicationCommandScope>>;
+  public set(
+    commands: readonly ApplicationCommandDataResolvable[],
+  ): Promise<Collection<Snowflake, ApplicationCommandScope>>;
+  public set(
+    commands: readonly ApplicationCommandDataResolvable[],
+    guildId: Snowflake,
+  ): Promise<Collection<Snowflake, ApplicationCommand>>;
+  private static transformCommand(command: ApplicationCommandDataResolvable): RESTPostAPIApplicationCommandsJSONBody;
+}
+
+export class ApplicationCommandPermissionsManager<
+  BaseOptions,
+  FetchSingleOptions,
+  GuildType,
+  CommandIdType,
+> extends BaseManager {
+  private constructor(manager: ApplicationCommandManager | GuildApplicationCommandManager | ApplicationCommand);
+  private manager: ApplicationCommandManager | GuildApplicationCommandManager | ApplicationCommand;
+
+  public commandId: CommandIdType;
+  public guild: GuildType;
+  public guildId: Snowflake | null;
+  public add(
+    options: FetchSingleOptions & EditApplicationCommandPermissionsMixin,
+  ): Promise<ApplicationCommandPermissions[]>;
+  public has(
+    options: FetchSingleOptions & {
+      permissionId: ApplicationCommandPermissionIdResolvable;
+      permissionType?: ApplicationCommandPermissionType;
+    },
+  ): Promise<boolean>;
+  public fetch(options: FetchSingleOptions): Promise<ApplicationCommandPermissions[]>;
+  public fetch(options: BaseOptions): Promise<Collection<Snowflake, ApplicationCommandPermissions[]>>;
+  public remove(
+    options:
+      | (FetchSingleOptions & {
+          token: string;
+          channels?: readonly (GuildChannelResolvable | ChannelPermissionConstant)[];
+          roles?: readonly (RoleResolvable | RolePermissionConstant)[];
+          users: readonly UserResolvable[];
+        })
+      | (FetchSingleOptions & {
+          token: string;
+          channels?: readonly (GuildChannelResolvable | ChannelPermissionConstant)[];
+          roles: readonly (RoleResolvable | RolePermissionConstant)[];
+          users?: readonly UserResolvable[];
+        })
+      | (FetchSingleOptions & {
+          token: string;
+          channels: readonly (GuildChannelResolvable | ChannelPermissionConstant)[];
+          roles?: readonly (RoleResolvable | RolePermissionConstant)[];
+          users?: readonly UserResolvable[];
+        }),
+  ): Promise<ApplicationCommandPermissions[]>;
+  public set(
+    options: FetchSingleOptions & EditApplicationCommandPermissionsMixin,
+  ): Promise<ApplicationCommandPermissions[]>;
+  private permissionsPath(guildId: Snowflake, commandId?: Snowflake): string;
+}
+
+export class AutoModerationRuleManager extends CachedManager<
+  Snowflake,
+  AutoModerationRule,
+  AutoModerationRuleResolvable
+> {
+  private constructor(guild: Guild, iterable: unknown);
+  public guild: Guild;
+  public create(options: AutoModerationRuleCreateOptions): Promise<AutoModerationRule>;
+  public edit(
+    autoModerationRule: AutoModerationRuleResolvable,
+    options: AutoModerationRuleEditOptions,
+  ): Promise<AutoModerationRule>;
+  public fetch(options: AutoModerationRuleResolvable | FetchAutoModerationRuleOptions): Promise<AutoModerationRule>;
+  public fetch(options?: FetchAutoModerationRulesOptions): Promise<Collection<Snowflake, AutoModerationRule>>;
+  public delete(autoModerationRule: AutoModerationRuleResolvable, reason?: string): Promise<void>;
+}
+
+export class BaseGuildEmojiManager extends CachedManager<Snowflake, GuildEmoji, EmojiResolvable> {
+  protected constructor(client: Client<true>, iterable?: Iterable<RawGuildEmojiData>);
+  public resolveIdentifier(emoji: EmojiIdentifierResolvable): string | null;
+}
+
+export class CategoryChannelChildManager extends DataManager<Snowflake, CategoryChildChannel, GuildChannelResolvable> {
+  private constructor(channel: CategoryChannel);
+
+  public channel: CategoryChannel;
+  public get guild(): Guild;
+  public create<T extends CategoryChannelType>(
+    options: CategoryCreateChannelOptions & { type: T },
+  ): Promise<MappedChannelCategoryTypes[T]>;
+  public create(options: CategoryCreateChannelOptions): Promise<TextChannel>;
+}
+
+export class ChannelManager extends CachedManager<Snowflake, Channel, ChannelResolvable> {
+  private constructor(client: Client<true>, iterable: Iterable<RawChannelData>);
+  public fetch(id: Snowflake, options?: FetchChannelOptions): Promise<Channel | null>;
+}
+
+export type FetchGuildApplicationCommandFetchOptions = Omit<FetchApplicationCommandOptions, 'guildId'>;
+
+export class GuildApplicationCommandManager extends ApplicationCommandManager<ApplicationCommand, {}, Guild> {
+  private constructor(guild: Guild, iterable?: Iterable<RawApplicationCommandData>);
+  public guild: Guild;
+  public create(command: ApplicationCommandDataResolvable): Promise<ApplicationCommand>;
+  public delete(command: ApplicationCommandResolvable): Promise<ApplicationCommand | null>;
+  public edit(
+    command: ApplicationCommandResolvable,
+    data: Partial<ApplicationCommandDataResolvable>,
+  ): Promise<ApplicationCommand>;
+  public fetch(id: Snowflake, options?: FetchGuildApplicationCommandFetchOptions): Promise<ApplicationCommand>;
+  public fetch(options: FetchGuildApplicationCommandFetchOptions): Promise<Collection<Snowflake, ApplicationCommand>>;
+  public fetch(
+    id?: undefined,
+    options?: FetchGuildApplicationCommandFetchOptions,
+  ): Promise<Collection<Snowflake, ApplicationCommand>>;
+  public set(commands: ApplicationCommandDataResolvable[]): Promise<Collection<Snowflake, ApplicationCommand>>;
+}
+
+export type MappedGuildChannelTypes = {
+  [ChannelType.GuildCategory]: CategoryChannel;
+} & MappedChannelCategoryTypes;
+
+export type GuildChannelTypes = CategoryChannelType | ChannelType.GuildCategory;
+
+export class GuildChannelManager extends CachedManager<Snowflake, GuildBasedChannel, GuildChannelResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawGuildChannelData>);
+  public get channelCountWithoutThreads(): number;
+  public guild: Guild;
+
+  public addFollower(
+    channel: NewsChannel | Snowflake,
+    targetChannel: TextChannelResolvable,
+    reason?: string,
+  ): Promise<Snowflake>;
+  public create<T extends GuildChannelTypes>(
+    options: GuildChannelCreateOptions & { type: T },
+  ): Promise<MappedGuildChannelTypes[T]>;
+  public create(options: GuildChannelCreateOptions): Promise<TextChannel>;
+  public createWebhook(options: WebhookCreateOptions): Promise<Webhook>;
+  public edit(channel: GuildChannelResolvable, data: GuildChannelEditOptions): Promise<GuildChannel>;
+  public fetch(id: Snowflake, options?: BaseFetchOptions): Promise<GuildBasedChannel | null>;
+  public fetch(
+    id?: undefined,
+    options?: BaseFetchOptions,
+  ): Promise<Collection<Snowflake, NonThreadGuildBasedChannel | null>>;
+  public fetchWebhooks(channel: GuildChannelResolvable): Promise<Collection<Snowflake, Webhook>>;
+  public setPosition(
+    channel: GuildChannelResolvable,
+    position: number,
+    options?: SetChannelPositionOptions,
+  ): Promise<GuildChannel>;
+  public setPositions(channelPositions: readonly ChannelPosition[]): Promise<Guild>;
+  public fetchActiveThreads(cache?: boolean): Promise<FetchedThreads>;
+  private rawFetchGuildActiveThreads(): Promise<RESTGetAPIGuildThreadsResult>;
+  public delete(channel: GuildChannelResolvable, reason?: string): Promise<void>;
+}
+
+export class GuildEmojiManager extends BaseGuildEmojiManager {
+  private constructor(guild: Guild, iterable?: Iterable<RawGuildEmojiData>);
+  public guild: Guild;
+  public create(options: GuildEmojiCreateOptions): Promise<GuildEmoji>;
+  public fetch(id: Snowflake, options?: BaseFetchOptions): Promise<GuildEmoji>;
+  public fetch(id?: undefined, options?: BaseFetchOptions): Promise<Collection<Snowflake, GuildEmoji>>;
+  public fetchAuthor(emoji: EmojiResolvable): Promise<User>;
+  public delete(emoji: EmojiResolvable, reason?: string): Promise<void>;
+  public edit(emoji: EmojiResolvable, options: GuildEmojiEditOptions): Promise<GuildEmoji>;
+}
+
+export class GuildEmojiRoleManager extends DataManager<Snowflake, Role, RoleResolvable> {
+  private constructor(emoji: GuildEmoji);
+  public emoji: GuildEmoji;
+  public guild: Guild;
+  public add(
+    roleOrRoles: RoleResolvable | readonly RoleResolvable[] | Collection<Snowflake, Role>,
+  ): Promise<GuildEmoji>;
+  public set(roles: readonly RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
+  public remove(
+    roleOrRoles: RoleResolvable | readonly RoleResolvable[] | Collection<Snowflake, Role>,
+  ): Promise<GuildEmoji>;
+}
+
+export class GuildManager extends CachedManager<Snowflake, Guild, GuildResolvable> {
+  private constructor(client: Client<true>, iterable?: Iterable<RawGuildData>);
+  public create(options: GuildCreateOptions): Promise<Guild>;
+  public fetch(options: Snowflake | FetchGuildOptions): Promise<Guild>;
+  public fetch(options?: FetchGuildsOptions): Promise<Collection<Snowflake, OAuth2Guild>>;
+}
+
+export interface AddOrRemoveGuildMemberRoleOptions {
+  user: GuildMemberResolvable;
+  role: RoleResolvable;
+  reason?: string;
+}
+
+export class GuildMemberManager extends CachedManager<Snowflake, GuildMember, GuildMemberResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawGuildMemberData>);
+  public guild: Guild;
+  public get me(): GuildMember | null;
+  public add(
+    user: UserResolvable,
+    options: AddGuildMemberOptions & { fetchWhenExisting: false },
+  ): Promise<GuildMember | null>;
+  public add(user: UserResolvable, options: AddGuildMemberOptions): Promise<GuildMember>;
+  public ban(user: UserResolvable, options?: BanOptions): Promise<GuildMember | User | Snowflake>;
+  public edit(user: UserResolvable, options: GuildMemberEditOptions): Promise<GuildMember>;
+  public fetch(
+    options: UserResolvable | FetchMemberOptions | (FetchMembersOptions & { user: UserResolvable }),
+  ): Promise<GuildMember>;
+  public fetch(options?: FetchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
+  public fetchMe(options?: BaseFetchOptions): Promise<GuildMember>;
+  public kick(user: UserResolvable, reason?: string): Promise<GuildMember | User | Snowflake>;
+  public list(options?: GuildListMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
+  public prune(options: GuildPruneMembersOptions & { dry?: false; count: false }): Promise<null>;
+  public prune(options?: GuildPruneMembersOptions): Promise<number>;
+  public search(options: GuildSearchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
+  public unban(user: UserResolvable, reason?: string): Promise<User | null>;
+  public addRole(options: AddOrRemoveGuildMemberRoleOptions): Promise<GuildMember | User | Snowflake>;
+  public removeRole(options: AddOrRemoveGuildMemberRoleOptions): Promise<GuildMember | User | Snowflake>;
+}
+
+export class GuildBanManager extends CachedManager<Snowflake, GuildBan, GuildBanResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawGuildBanData>);
+  public guild: Guild;
+  public create(user: UserResolvable, options?: BanOptions): Promise<GuildMember | User | Snowflake>;
+  public fetch(options: UserResolvable | FetchBanOptions): Promise<GuildBan>;
+  public fetch(options?: FetchBansOptions): Promise<Collection<Snowflake, GuildBan>>;
+  public remove(user: UserResolvable, reason?: string): Promise<User | null>;
+}
+
+export class GuildInviteManager extends DataManager<string, Invite, InviteResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawInviteData>);
+  public guild: Guild;
+  public create(channel: GuildInvitableChannelResolvable, options?: InviteCreateOptions): Promise<Invite>;
+  public fetch(options: InviteResolvable | FetchInviteOptions): Promise<Invite>;
+  public fetch(options?: FetchInvitesOptions): Promise<Collection<string, Invite>>;
+  public delete(invite: InviteResolvable, reason?: string): Promise<Invite>;
+}
+
+export class GuildScheduledEventManager extends CachedManager<
+  Snowflake,
+  GuildScheduledEvent,
+  GuildScheduledEventResolvable
+> {
+  private constructor(guild: Guild, iterable?: Iterable<RawGuildScheduledEventData>);
+  public guild: Guild;
+  public create(options: GuildScheduledEventCreateOptions): Promise<GuildScheduledEvent>;
+  public fetch(): Promise<Collection<Snowflake, GuildScheduledEvent>>;
+  public fetch<
+    T extends GuildScheduledEventResolvable | FetchGuildScheduledEventOptions | FetchGuildScheduledEventsOptions,
+  >(options?: T): Promise<GuildScheduledEventManagerFetchResult<T>>;
+  public edit<S extends GuildScheduledEventStatus, T extends GuildScheduledEventSetStatusArg<S>>(
+    guildScheduledEvent: GuildScheduledEventResolvable,
+    options: GuildScheduledEventEditOptions<S, T>,
+  ): Promise<GuildScheduledEvent<T>>;
+  public delete(guildScheduledEvent: GuildScheduledEventResolvable): Promise<void>;
+  public fetchSubscribers<T extends FetchGuildScheduledEventSubscribersOptions>(
+    guildScheduledEvent: GuildScheduledEventResolvable,
+    options?: T,
+  ): Promise<GuildScheduledEventManagerFetchSubscribersResult<T>>;
+}
+
+export class GuildStickerManager extends CachedManager<Snowflake, Sticker, StickerResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawStickerData>);
+  public guild: Guild;
+  public create(options: GuildStickerCreateOptions): Promise<Sticker>;
+  public edit(sticker: StickerResolvable, data?: GuildStickerEditOptions): Promise<Sticker>;
+  public delete(sticker: StickerResolvable, reason?: string): Promise<void>;
+  public fetch(id: Snowflake, options?: BaseFetchOptions): Promise<Sticker>;
+  public fetch(id?: Snowflake, options?: BaseFetchOptions): Promise<Collection<Snowflake, Sticker>>;
+  public fetchUser(sticker: StickerResolvable): Promise<User | null>;
+}
+
+export class GuildMemberRoleManager extends DataManager<Snowflake, Role, RoleResolvable> {
+  private constructor(member: GuildMember);
+  public get hoist(): Role | null;
+  public get icon(): Role | null;
+  public get color(): Role | null;
+  public get highest(): Role;
+  public get premiumSubscriberRole(): Role | null;
+  public get botRole(): Role | null;
+  public member: GuildMember;
+  public guild: Guild;
+
+  public add(
+    roleOrRoles: RoleResolvable | readonly RoleResolvable[] | Collection<Snowflake, Role>,
+    reason?: string,
+  ): Promise<GuildMember>;
+  public set(roles: readonly RoleResolvable[] | Collection<Snowflake, Role>, reason?: string): Promise<GuildMember>;
+  public remove(
+    roleOrRoles: RoleResolvable | readonly RoleResolvable[] | Collection<Snowflake, Role>,
+    reason?: string,
+  ): Promise<GuildMember>;
+}
+
+export abstract class MessageManager<InGuild extends boolean = boolean> extends CachedManager<
+  Snowflake,
+  Message<InGuild>,
+  MessageResolvable
+> {
+  protected constructor(channel: TextBasedChannel, iterable?: Iterable<RawMessageData>);
+  public channel: TextBasedChannel;
+  public delete(message: MessageResolvable): Promise<void>;
+  public edit(
+    message: MessageResolvable,
+    options: string | MessagePayload | MessageEditOptions,
+  ): Promise<Message<InGuild>>;
+  public fetch(options: MessageResolvable | FetchMessageOptions): Promise<Message<InGuild>>;
+  public fetch(options?: FetchMessagesOptions): Promise<Collection<Snowflake, Message<InGuild>>>;
+  public fetchPinned(cache?: boolean): Promise<Collection<Snowflake, Message<InGuild>>>;
+  public react(message: MessageResolvable, emoji: EmojiIdentifierResolvable): Promise<void>;
+  public pin(message: MessageResolvable, reason?: string): Promise<void>;
+  public unpin(message: MessageResolvable, reason?: string): Promise<void>;
+}
+
+export class DMMessageManager extends MessageManager {
+  public channel: DMChannel;
+}
+
+export class GuildMessageManager extends MessageManager<true> {
+  public channel: GuildTextBasedChannel;
+  public crosspost(message: MessageResolvable): Promise<Message<true>>;
+}
+
+export class PermissionOverwriteManager extends CachedManager<
+  Snowflake,
+  PermissionOverwrites,
+  PermissionOverwriteResolvable
+> {
+  private constructor(client: Client<true>, iterable?: Iterable<RawPermissionOverwriteData>);
+  public set(
+    overwrites: readonly OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>,
+    reason?: string,
+  ): Promise<NonThreadGuildBasedChannel>;
+  private upsert(
+    userOrRole: RoleResolvable | UserResolvable,
+    options: PermissionOverwriteOptions,
+    overwriteOptions?: GuildChannelOverwriteOptions,
+    existing?: PermissionOverwrites,
+  ): Promise<NonThreadGuildBasedChannel>;
+  public create(
+    userOrRole: RoleResolvable | UserResolvable,
+    options: PermissionOverwriteOptions,
+    overwriteOptions?: GuildChannelOverwriteOptions,
+  ): Promise<NonThreadGuildBasedChannel>;
+  public edit(
+    userOrRole: RoleResolvable | UserResolvable,
+    options: PermissionOverwriteOptions,
+    overwriteOptions?: GuildChannelOverwriteOptions,
+  ): Promise<NonThreadGuildBasedChannel>;
+  public delete(userOrRole: RoleResolvable | UserResolvable, reason?: string): Promise<NonThreadGuildBasedChannel>;
+}
+
+export class PresenceManager extends CachedManager<Snowflake, Presence, PresenceResolvable> {
+  private constructor(client: Client<true>, iterable?: Iterable<RawPresenceData>);
+}
+
+export class ReactionManager extends CachedManager<Snowflake | string, MessageReaction, MessageReactionResolvable> {
+  private constructor(message: Message, iterable?: Iterable<RawMessageReactionData>);
+  public message: Message;
+  public removeAll(): Promise<Message>;
+}
+
+export class ReactionUserManager extends CachedManager<Snowflake, User, UserResolvable> {
+  private constructor(reaction: MessageReaction, iterable?: Iterable<RawUserData>);
+  public reaction: MessageReaction;
+  public fetch(options?: FetchReactionUsersOptions): Promise<Collection<Snowflake, User>>;
+  public remove(user?: UserResolvable): Promise<MessageReaction>;
+}
+
+export class RoleManager extends CachedManager<Snowflake, Role, RoleResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawRoleData>);
+  public get everyone(): Role;
+  public get highest(): Role;
+  public guild: Guild;
+  public get premiumSubscriberRole(): Role | null;
+  public botRoleFor(user: UserResolvable): Role | null;
+  public fetch(id: Snowflake, options?: BaseFetchOptions): Promise<Role | null>;
+  public fetch(id?: undefined, options?: BaseFetchOptions): Promise<Collection<Snowflake, Role>>;
+  public create(options?: RoleCreateOptions): Promise<Role>;
+  public edit(role: RoleResolvable, options: RoleEditOptions): Promise<Role>;
+  public delete(role: RoleResolvable, reason?: string): Promise<void>;
+  public setPosition(role: RoleResolvable, position: number, options?: SetRolePositionOptions): Promise<Role>;
+  public setPositions(rolePositions: readonly RolePosition[]): Promise<Guild>;
+  public comparePositions(role1: RoleResolvable, role2: RoleResolvable): number;
+}
+
+export class StageInstanceManager extends CachedManager<Snowflake, StageInstance, StageInstanceResolvable> {
+  private constructor(guild: Guild, iterable?: Iterable<RawStageInstanceData>);
+  public guild: Guild;
+  public create(channel: StageChannelResolvable, options: StageInstanceCreateOptions): Promise<StageInstance>;
+  public fetch(channel: StageChannelResolvable, options?: BaseFetchOptions): Promise<StageInstance>;
+  public edit(channel: StageChannelResolvable, options: StageInstanceEditOptions): Promise<StageInstance>;
+  public delete(channel: StageChannelResolvable): Promise<void>;
+}
+
+export class ThreadManager<Forum extends boolean = boolean> extends CachedManager<
+  Snowflake,
+  ThreadChannel<Forum>,
+  ThreadChannelResolvable
+> {
+  protected constructor(channel: TextChannel | NewsChannel | ForumChannel, iterable?: Iterable<RawThreadChannelData>);
+  public channel: If<Forum, ForumChannel, TextChannel | NewsChannel>;
+  public fetch(options: ThreadChannelResolvable, cacheOptions?: BaseFetchOptions): Promise<AnyThreadChannel | null>;
+  public fetch(
+    options: FetchThreadsOptions & { archived: FetchArchivedThreadOptions },
+    cacheOptions?: { cache?: boolean },
+  ): Promise<FetchedThreadsMore>;
+  public fetch(options?: FetchThreadsOptions, cacheOptions?: { cache?: boolean }): Promise<FetchedThreads>;
+  public fetchArchived(options?: FetchArchivedThreadOptions, cache?: boolean): Promise<FetchedThreadsMore>;
+  public fetchActive(cache?: boolean): Promise<FetchedThreads>;
+}
+
+export class GuildTextThreadManager<AllowedThreadType> extends ThreadManager<false> {
+  public create(options: GuildTextThreadCreateOptions<AllowedThreadType>): Promise<ThreadChannel>;
+}
+
+export class GuildForumThreadManager extends ThreadManager<true> {
+  public create(options: GuildForumThreadCreateOptions): Promise<ThreadChannel>;
+}
+
+export class ThreadMemberManager extends CachedManager<Snowflake, ThreadMember, ThreadMemberResolvable> {
+  private constructor(thread: ThreadChannel, iterable?: Iterable<RawThreadMemberData>);
+  public thread: AnyThreadChannel;
+  public get me(): ThreadMember | null;
+  public add(member: UserResolvable | '@me', reason?: string): Promise<Snowflake>;
+
+  public fetch(
+    options: ThreadMember<true> | ((FetchThreadMemberOptions & { withMember: true }) | { member: ThreadMember<true> }),
+  ): Promise<ThreadMember<true>>;
+
+  public fetch(options: ThreadMemberResolvable | FetchThreadMemberOptions): Promise<ThreadMember>;
+
+  public fetch(
+    options: FetchThreadMembersWithGuildMemberDataOptions,
+  ): Promise<Collection<Snowflake, ThreadMember<true>>>;
+
+  public fetch(options?: FetchThreadMembersWithoutGuildMemberDataOptions): Promise<Collection<Snowflake, ThreadMember>>;
+  public fetchMe(options?: BaseFetchOptions): Promise<ThreadMember>;
+  public remove(id: Snowflake | '@me', reason?: string): Promise<Snowflake>;
+}
+
+export class UserManager extends CachedManager<Snowflake, User, UserResolvable> {
+  private constructor(client: Client<true>, iterable?: Iterable<RawUserData>);
+  private dmChannel(userId: Snowflake): DMChannel | null;
+  public createDM(user: UserResolvable, options?: BaseFetchOptions): Promise<DMChannel>;
+  public deleteDM(user: UserResolvable): Promise<DMChannel>;
+  public fetch(user: UserResolvable, options?: BaseFetchOptions): Promise<User>;
+  public fetchFlags(user: UserResolvable, options?: BaseFetchOptions): Promise<UserFlagsBitField>;
+  public send(user: UserResolvable, options: string | MessagePayload | MessageCreateOptions): Promise<Message>;
+}
+
+export class VoiceStateManager extends CachedManager<Snowflake, VoiceState, typeof VoiceState> {
+  private constructor(guild: Guild, iterable?: Iterable<RawVoiceStateData>);
+  public guild: Guild;
+}
+
+//#endregion
+
+//#region Mixins
+
+// Model the TextBasedChannel mixin system, allowing application of these fields
+// to the classes that use these methods without having to manually add them
+// to each of those classes
+
+export type Constructable<T> = abstract new (...args: any[]) => T;
+export function PartialTextBasedChannel<T>(
+  Base?: Constructable<T>,
+): Constructable<T & PartialTextBasedChannelFields<false>>;
+
+export function TextBasedChannelMixin<
+  T,
+  InGuild extends boolean = boolean,
+  I extends keyof TextBasedChannelFields<InGuild> = never,
+>(
+  Base?: Constructable<T>,
+  inGuild?: InGuild,
+  ignore?: I[],
+): Constructable<T & Omit<TextBasedChannelFields<InGuild>, I>>;
+
+export interface PartialTextBasedChannelFields<InGuild extends boolean = boolean> {
+  send(options: string | MessagePayload | MessageCreateOptions): Promise<Message<InGuild>>;
+}
+
+export interface TextBasedChannelFields<InGuild extends boolean = boolean>
+  extends PartialTextBasedChannelFields<InGuild> {
+  lastMessageId: Snowflake | null;
+  get lastMessage(): Message | null;
+  lastPinTimestamp: number | null;
+  get lastPinAt(): Date | null;
+  messages: If<InGuild, GuildMessageManager, DMMessageManager>;
+  awaitMessageComponent<T extends MessageComponentType>(
+    options?: AwaitMessageCollectorOptionsParams<T, true>,
+  ): Promise<MappedInteractionTypes[T]>;
+  awaitMessages(options?: AwaitMessagesOptions): Promise<Collection<Snowflake, Message>>;
+  bulkDelete(
+    messages: Collection<Snowflake, Message> | readonly MessageResolvable[] | number,
+    filterOld?: boolean,
+  ): Promise<Collection<Snowflake, Message | PartialMessage | undefined>>;
+  createMessageComponentCollector<T extends MessageComponentType>(
+    options?: MessageChannelCollectorOptionsParams<T, true>,
+  ): InteractionCollector<MappedInteractionTypes[T]>;
+  createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+  createWebhook(options: ChannelWebhookCreateOptions): Promise<Webhook>;
+  fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
+  sendTyping(): Promise<void>;
+  setRateLimitPerUser(rateLimitPerUser: number, reason?: string): Promise<this>;
+  setNSFW(nsfw?: boolean, reason?: string): Promise<this>;
+}
+
+export function PartialWebhookMixin<T>(Base?: Constructable<T>): Constructable<T & PartialWebhookFields>;
+export function WebhookMixin<T>(Base?: Constructable<T>): Constructable<T & WebhookFields>;
+
+export interface PartialWebhookFields {
+  id: Snowflake;
+  get url(): string;
+  deleteMessage(message: MessageResolvable | APIMessage | '@original', threadId?: Snowflake): Promise<void>;
+  editMessage(
+    message: MessageResolvable | '@original',
+    options: string | MessagePayload | WebhookMessageEditOptions,
+  ): Promise<APIMessage | Message>;
+  fetchMessage(message: Snowflake | '@original', options?: WebhookFetchMessageOptions): Promise<APIMessage | Message>;
+  send(
+    options: string | MessagePayload | InteractionReplyOptions | WebhookMessageCreateOptions,
+  ): Promise<APIMessage | Message>;
+}
+
+export interface WebhookFields extends PartialWebhookFields {
+  get createdAt(): Date;
+  get createdTimestamp(): number;
+  delete(reason?: string): Promise<void>;
+  edit(options: WebhookEditOptions): Promise<Webhook>;
+  sendSlackMessage(body: unknown): Promise<boolean>;
+}
+
+//#endregion
+
+//#region Typedefs
+
+export type ActivitiesOptions = Omit<ActivityOptions, 'shardId'>;
+
+export interface ActivityOptions {
+  name: string;
+  state?: string;
+  url?: string;
+  type?: ActivityType;
+  shardId?: number | readonly number[];
+}
+
+export interface AddGuildMemberOptions {
+  accessToken: string;
+  nick?: string;
+  roles?: Collection<Snowflake, Role> | RoleResolvable[];
+  mute?: boolean;
+  deaf?: boolean;
+  force?: boolean;
+  fetchWhenExisting?: boolean;
+}
+
+export type AllowedPartial = User | Channel | GuildMember | Message | MessageReaction | ThreadMember;
+
+export type AllowedThreadTypeForNewsChannel = ChannelType.AnnouncementThread;
+
+export type AllowedThreadTypeForTextChannel = ChannelType.PublicThread | ChannelType.PrivateThread;
+
+export interface BaseApplicationCommandData {
+  name: string;
+  nameLocalizations?: LocalizationMap;
+  dmPermission?: boolean;
+  defaultMemberPermissions?: PermissionResolvable | null;
+  nsfw?: boolean;
+}
+
+export interface AttachmentData {
+  name?: string;
+  description?: string;
+}
+
+export type CommandOptionDataTypeResolvable = ApplicationCommandOptionType;
+
+export type CommandOptionChannelResolvableType = ApplicationCommandOptionType.Channel;
+
+export type CommandOptionChoiceResolvableType =
+  | ApplicationCommandOptionType.String
+  | CommandOptionNumericResolvableType;
+
+export type CommandOptionNumericResolvableType =
+  | ApplicationCommandOptionType.Number
+  | ApplicationCommandOptionType.Integer;
+
+export type CommandOptionSubOptionResolvableType =
+  | ApplicationCommandOptionType.Subcommand
+  | ApplicationCommandOptionType.SubcommandGroup;
+
+export type CommandOptionNonChoiceResolvableType = Exclude<
+  CommandOptionDataTypeResolvable,
+  CommandOptionChoiceResolvableType | CommandOptionSubOptionResolvableType | CommandOptionChannelResolvableType
+>;
+
+export interface BaseApplicationCommandOptionsData {
+  name: string;
+  nameLocalizations?: LocalizationMap;
+  description: string;
+  descriptionLocalizations?: LocalizationMap;
+  required?: boolean;
+  autocomplete?: never;
+}
+
+export interface UserApplicationCommandData extends BaseApplicationCommandData {
+  type: ApplicationCommandType.User;
+}
+
+export interface MessageApplicationCommandData extends BaseApplicationCommandData {
+  type: ApplicationCommandType.Message;
+}
+
+export interface ChatInputApplicationCommandData extends BaseApplicationCommandData {
+  description: string;
+  descriptionLocalizations?: LocalizationMap;
+  type?: ApplicationCommandType.ChatInput;
+  options?: readonly ApplicationCommandOptionData[];
+}
+
+export type ApplicationCommandData =
+  | UserApplicationCommandData
+  | MessageApplicationCommandData
+  | ChatInputApplicationCommandData;
+
+export interface ApplicationCommandChannelOptionData extends BaseApplicationCommandOptionsData {
+  type: CommandOptionChannelResolvableType;
+  channelTypes?: readonly ApplicationCommandOptionAllowedChannelTypes[];
+  channel_types?: readonly ApplicationCommandOptionAllowedChannelTypes[];
+}
+
+export interface ApplicationCommandChannelOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Channel;
+  channelTypes?: readonly ApplicationCommandOptionAllowedChannelTypes[];
+}
+
+export interface ApplicationCommandRoleOptionData extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Role;
+}
+
+export interface ApplicationCommandRoleOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Role;
+}
+
+export interface ApplicationCommandUserOptionData extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.User;
+}
+
+export interface ApplicationCommandUserOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.User;
+}
+
+export interface ApplicationCommandMentionableOptionData extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Mentionable;
+}
+
+export interface ApplicationCommandMentionableOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Mentionable;
+}
+
+export interface ApplicationCommandAttachmentOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Attachment;
+}
+
+export interface ApplicationCommandAutocompleteNumericOption
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: CommandOptionNumericResolvableType;
+  minValue?: number;
+  maxValue?: number;
+  autocomplete: true;
+}
+
+export interface ApplicationCommandAutocompleteStringOption
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: ApplicationCommandOptionType.String;
+  minLength?: number;
+  maxLength?: number;
+  autocomplete: true;
+}
+
+export interface ApplicationCommandAutocompleteNumericOptionData
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: CommandOptionNumericResolvableType;
+  minValue?: number;
+  min_value?: number;
+  maxValue?: number;
+  max_value?: number;
+  autocomplete: true;
+}
+
+export interface ApplicationCommandAutocompleteStringOptionData
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: ApplicationCommandOptionType.String;
+  minLength?: number;
+  min_length?: number;
+  maxLength?: number;
+  max_length?: number;
+  autocomplete: true;
+}
+
+export interface ApplicationCommandChoicesData<Type extends string | number = string | number>
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: CommandOptionChoiceResolvableType;
+  choices?: readonly ApplicationCommandOptionChoiceData<Type>[];
+  autocomplete?: false;
+}
+
+export interface ApplicationCommandChoicesOption<Type extends string | number = string | number>
+  extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+  type: CommandOptionChoiceResolvableType;
+  choices?: readonly ApplicationCommandOptionChoiceData<Type>[];
+  autocomplete?: false;
+}
+
+export interface ApplicationCommandNumericOptionData extends ApplicationCommandChoicesData<number> {
+  type: CommandOptionNumericResolvableType;
+  minValue?: number;
+  min_value?: number;
+  maxValue?: number;
+  max_value?: number;
+}
+
+export interface ApplicationCommandStringOptionData extends ApplicationCommandChoicesData<string> {
+  type: ApplicationCommandOptionType.String;
+  minLength?: number;
+  min_length?: number;
+  maxLength?: number;
+  max_length?: number;
+}
+
+export interface ApplicationCommandBooleanOptionData extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Boolean;
+}
+
+export interface ApplicationCommandNumericOption extends ApplicationCommandChoicesOption<number> {
+  type: CommandOptionNumericResolvableType;
+  minValue?: number;
+  maxValue?: number;
+}
+
+export interface ApplicationCommandStringOption extends ApplicationCommandChoicesOption<string> {
+  type: ApplicationCommandOptionType.String;
+  minLength?: number;
+  maxLength?: number;
+}
+
+export interface ApplicationCommandBooleanOption extends BaseApplicationCommandOptionsData {
+  type: ApplicationCommandOptionType.Boolean;
+}
+
+export interface ApplicationCommandSubGroupData extends Omit<BaseApplicationCommandOptionsData, 'required'> {
+  type: ApplicationCommandOptionType.SubcommandGroup;
+  options: readonly ApplicationCommandSubCommandData[];
+}
+
+export interface ApplicationCommandSubGroup extends Omit<BaseApplicationCommandOptionsData, 'required'> {
+  type: ApplicationCommandOptionType.SubcommandGroup;
+  options?: readonly ApplicationCommandSubCommand[];
+}
+
+export interface ApplicationCommandSubCommandData extends Omit<BaseApplicationCommandOptionsData, 'required'> {
+  type: ApplicationCommandOptionType.Subcommand;
+  options?: readonly Exclude<
+    ApplicationCommandOptionData,
+    ApplicationCommandSubGroupData | ApplicationCommandSubCommandData
+  >[];
+}
+
+export interface ApplicationCommandSubCommand extends Omit<BaseApplicationCommandOptionsData, 'required'> {
+  type: ApplicationCommandOptionType.Subcommand;
+  options?: readonly Exclude<ApplicationCommandOption, ApplicationCommandSubGroup | ApplicationCommandSubCommand>[];
+}
+
+export interface ApplicationCommandNonOptionsData extends BaseApplicationCommandOptionsData {
+  type: CommandOptionNonChoiceResolvableType;
+}
+
+export interface ApplicationCommandNonOptions extends BaseApplicationCommandOptionsData {
+  type: Exclude<CommandOptionNonChoiceResolvableType, ApplicationCommandOptionType>;
+}
+
+export type ApplicationCommandOptionData =
+  | ApplicationCommandSubGroupData
+  | ApplicationCommandNonOptionsData
+  | ApplicationCommandChannelOptionData
+  | ApplicationCommandAutocompleteNumericOptionData
+  | ApplicationCommandAutocompleteStringOptionData
+  | ApplicationCommandNumericOptionData
+  | ApplicationCommandStringOptionData
+  | ApplicationCommandRoleOptionData
+  | ApplicationCommandUserOptionData
+  | ApplicationCommandMentionableOptionData
+  | ApplicationCommandBooleanOptionData
+  | ApplicationCommandSubCommandData;
+
+export type ApplicationCommandOption =
+  | ApplicationCommandSubGroup
+  | ApplicationCommandAutocompleteNumericOption
+  | ApplicationCommandAutocompleteStringOption
+  | ApplicationCommandNonOptions
+  | ApplicationCommandChannelOption
+  | ApplicationCommandNumericOption
+  | ApplicationCommandStringOption
+  | ApplicationCommandRoleOption
+  | ApplicationCommandUserOption
+  | ApplicationCommandMentionableOption
+  | ApplicationCommandBooleanOption
+  | ApplicationCommandAttachmentOption
+  | ApplicationCommandSubCommand;
+
+export interface ApplicationCommandOptionChoiceData<Value extends string | number = string | number> {
+  name: string;
+  nameLocalizations?: LocalizationMap;
+  value: Value;
+}
+
+export interface ApplicationCommandPermissions {
+  id: Snowflake;
+  type: ApplicationCommandPermissionType;
+  permission: boolean;
+}
+
+export interface ApplicationCommandPermissionsUpdateData {
+  id: Snowflake;
+  guildId: Snowflake;
+  applicationId: Snowflake;
+  permissions: readonly ApplicationCommandPermissions[];
+}
+
+export interface EditApplicationCommandPermissionsMixin {
+  permissions: readonly ApplicationCommandPermissions[];
+  token: string;
+}
+
+export type ChannelPermissionConstant = Snowflake;
+
+export type RolePermissionConstant = Snowflake;
+
+export type ApplicationCommandPermissionIdResolvable =
+  | GuildChannelResolvable
+  | RoleResolvable
+  | UserResolvable
+  | ChannelPermissionConstant
+  | RolePermissionConstant;
+
+export type ApplicationCommandResolvable = ApplicationCommand | Snowflake;
+
+export type ApplicationFlagsString = keyof typeof ApplicationFlags;
+
+export interface ApplicationRoleConnectionMetadataEditOptions {
+  name: string;
+  nameLocalizations?: LocalizationMap | null;
+  description: string;
+  descriptionLocalizations?: LocalizationMap | null;
+  key: string;
+  type: ApplicationRoleConnectionMetadataType;
+}
+
+export interface AuditLogChange {
+  key: APIAuditLogChange['key'];
+  old?: APIAuditLogChange['old_value'];
+  new?: APIAuditLogChange['new_value'];
+}
+
+export interface AutoModerationAction {
+  type: AutoModerationActionType;
+  metadata: AutoModerationActionMetadata;
+}
+
+export interface AutoModerationActionMetadata {
+  channelId: Snowflake | null;
+  durationSeconds: number | null;
+  customMessage: string | null;
+}
+
+export interface AutoModerationTriggerMetadata {
+  keywordFilter: string[];
+  regexPatterns: string[];
+  presets: AutoModerationRuleKeywordPresetType[];
+  allowList: string[];
+  mentionTotalLimit: number | null;
+  mentionRaidProtectionEnabled: boolean;
+}
+
+export type AwaitMessageComponentOptions<T extends CollectedMessageInteraction> = Omit<
+  MessageComponentCollectorOptions<T>,
+  'max' | 'maxComponents' | 'maxUsers'
+>;
+
+export type ModalSubmitInteractionCollectorOptions<T extends ModalSubmitInteraction> = Omit<
+  InteractionCollectorOptions<T>,
+  'channel' | 'message' | 'guild' | 'interactionType'
+>;
+
+export type AwaitModalSubmitOptions<T extends ModalSubmitInteraction> = Omit<
+  ModalSubmitInteractionCollectorOptions<T>,
+  'max' | 'maxComponents' | 'maxUsers'
+> & {
+  time: number;
+};
+
+export interface AwaitMessagesOptions extends MessageCollectorOptions {
+  errors?: string[];
+}
+
+export interface AwaitReactionsOptions extends ReactionCollectorOptions {
+  errors?: string[];
+}
+
+export interface BanOptions {
+  /** @deprecated Use {@link deleteMessageSeconds} instead. */
+  deleteMessageDays?: number;
+  deleteMessageSeconds?: number;
+  reason?: string;
+}
+
+export type Base64Resolvable = Buffer | Base64String;
+
+export type Base64String = string;
+
+export interface BaseFetchOptions {
+  cache?: boolean;
+  force?: boolean;
+}
+
+export type BitFieldResolvable<T extends string, N extends number | bigint> =
+  | RecursiveReadonlyArray<T | N | `${bigint}` | Readonly<BitField<T, N>>>
+  | T
+  | N
+  | `${bigint}`
+  | Readonly<BitField<T, N>>;
+
+export type BufferResolvable = Buffer | string;
+
+export interface Caches {
+  AutoModerationRuleManager: [manager: typeof AutoModerationRuleManager, holds: typeof AutoModerationRule];
+  ApplicationCommandManager: [manager: typeof ApplicationCommandManager, holds: typeof ApplicationCommand];
+  BaseGuildEmojiManager: [manager: typeof BaseGuildEmojiManager, holds: typeof GuildEmoji];
+  DMMessageManager: [manager: typeof MessageManager, holds: typeof Message<false>];
+  GuildEmojiManager: [manager: typeof GuildEmojiManager, holds: typeof GuildEmoji];
+  // TODO: ChannelManager: [manager: typeof ChannelManager, holds: typeof Channel];
+  // TODO: GuildChannelManager: [manager: typeof GuildChannelManager, holds: typeof GuildChannel];
+  // TODO: GuildManager: [manager: typeof GuildManager, holds: typeof Guild];
+  GuildMemberManager: [manager: typeof GuildMemberManager, holds: typeof GuildMember];
+  GuildBanManager: [manager: typeof GuildBanManager, holds: typeof GuildBan];
+  GuildForumThreadManager: [manager: typeof GuildForumThreadManager, holds: typeof ThreadChannel<true>];
+  GuildInviteManager: [manager: typeof GuildInviteManager, holds: typeof Invite];
+  GuildMessageManager: [manager: typeof GuildMessageManager, holds: typeof Message<true>];
+  GuildScheduledEventManager: [manager: typeof GuildScheduledEventManager, holds: typeof GuildScheduledEvent];
+  GuildStickerManager: [manager: typeof GuildStickerManager, holds: typeof Sticker];
+  GuildTextThreadManager: [manager: typeof GuildTextThreadManager, holds: typeof ThreadChannel<false>];
+  MessageManager: [manager: typeof MessageManager, holds: typeof Message];
+  // TODO: PermissionOverwriteManager: [manager: typeof PermissionOverwriteManager, holds: typeof PermissionOverwrites];
+  PresenceManager: [manager: typeof PresenceManager, holds: typeof Presence];
+  ReactionManager: [manager: typeof ReactionManager, holds: typeof MessageReaction];
+  ReactionUserManager: [manager: typeof ReactionUserManager, holds: typeof User];
+  // TODO: RoleManager: [manager: typeof RoleManager, holds: typeof Role];
+  StageInstanceManager: [manager: typeof StageInstanceManager, holds: typeof StageInstance];
+  ThreadManager: [manager: typeof ThreadManager, holds: typeof ThreadChannel];
+  ThreadMemberManager: [manager: typeof ThreadMemberManager, holds: typeof ThreadMember];
+  UserManager: [manager: typeof UserManager, holds: typeof User];
+  VoiceStateManager: [manager: typeof VoiceStateManager, holds: typeof VoiceState];
+}
+
+export type CacheConstructors = {
+  [K in keyof Caches]: Caches[K][0] & { name: K };
+};
+
+type OverriddenCaches =
+  | 'DMMessageManager'
+  | 'GuildForumThreadManager'
+  | 'GuildMessageManager'
+  | 'GuildTextThreadManager';
+
+// This doesn't actually work the way it looks 😢.
+// Narrowing the type of `manager.name` doesn't propagate type information to `holds` and the return type.
+export type CacheFactory = (
+  managerType: CacheConstructors[Exclude<keyof Caches, OverriddenCaches>],
+  holds: Caches[(typeof manager)['name']][1],
+  manager: CacheConstructors[keyof Caches],
+) => (typeof manager)['prototype'] extends DataManager<infer K, infer V, any> ? Collection<K, V> : never;
+
+export type CacheWithLimitsOptions = {
+  [K in keyof Caches]?: Caches[K][0]['prototype'] extends DataManager<infer K, infer V, any>
+    ? LimitedCollectionOptions<K, V> | number
+    : never;
+};
+
+export interface CategoryCreateChannelOptions {
+  name: string;
+  permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
+  topic?: string;
+  type?: CategoryChannelType;
+  nsfw?: boolean;
+  bitrate?: number;
+  userLimit?: number;
+  rateLimitPerUser?: number;
+  position?: number;
+  rtcRegion?: string;
+  videoQualityMode?: VideoQualityMode;
+  availableTags?: GuildForumTagData[];
+  defaultReactionEmoji?: DefaultReactionEmoji;
+  defaultAutoArchiveDuration?: ThreadAutoArchiveDuration;
+  defaultSortOrder?: SortOrderType;
+  defaultForumLayout?: ForumLayoutType;
+  reason?: string;
+}
+
+export interface ChannelCreationOverwrites {
+  allow?: PermissionResolvable;
+  deny?: PermissionResolvable;
+  id: RoleResolvable | UserResolvable;
+}
+
+export type ChannelMention = `<#${Snowflake}>`;
+
+export interface ChannelPosition {
+  channel: NonThreadGuildBasedChannel | Snowflake;
+  lockPermissions?: boolean;
+  parent?: CategoryChannelResolvable | null;
+  position?: number;
+}
+
+export type GuildTextChannelResolvable = TextChannel | NewsChannel | Snowflake;
+export type ChannelResolvable = Channel | Snowflake;
+
+export interface ChannelWebhookCreateOptions {
+  name: string;
+  avatar?: BufferResolvable | Base64Resolvable | null;
+  reason?: string;
+}
+
+export interface WebhookCreateOptions extends ChannelWebhookCreateOptions {
+  channel: TextChannel | NewsChannel | VoiceChannel | StageChannel | ForumChannel | Snowflake;
+}
+
+export interface ClientEvents {
+  applicationCommandPermissionsUpdate: [data: ApplicationCommandPermissionsUpdateData];
+  autoModerationActionExecution: [autoModerationActionExecution: AutoModerationActionExecution];
+  autoModerationRuleCreate: [autoModerationRule: AutoModerationRule];
+  autoModerationRuleDelete: [autoModerationRule: AutoModerationRule];
+  autoModerationRuleUpdate: [
+    oldAutoModerationRule: AutoModerationRule | null,
+    newAutoModerationRule: AutoModerationRule,
+  ];
+  cacheSweep: [message: string];
+  channelCreate: [channel: NonThreadGuildBasedChannel];
+  channelDelete: [channel: DMChannel | NonThreadGuildBasedChannel];
+  channelPinsUpdate: [channel: TextBasedChannel, date: Date];
+  channelUpdate: [
+    oldChannel: DMChannel | NonThreadGuildBasedChannel,
+    newChannel: DMChannel | NonThreadGuildBasedChannel,
+  ];
+  debug: [message: string];
+  warn: [message: string];
+  emojiCreate: [emoji: GuildEmoji];
+  emojiDelete: [emoji: GuildEmoji];
+  emojiUpdate: [oldEmoji: GuildEmoji, newEmoji: GuildEmoji];
+  error: [error: Error];
+  guildAuditLogEntryCreate: [auditLogEntry: GuildAuditLogsEntry, guild: Guild];
+  guildAvailable: [guild: Guild];
+  guildBanAdd: [ban: GuildBan];
+  guildBanRemove: [ban: GuildBan];
+  guildCreate: [guild: Guild];
+  guildDelete: [guild: Guild];
+  guildUnavailable: [guild: Guild];
+  guildIntegrationsUpdate: [guild: Guild];
+  guildMemberAdd: [member: GuildMember];
+  guildMemberAvailable: [member: GuildMember | PartialGuildMember];
+  guildMemberRemove: [member: GuildMember | PartialGuildMember];
+  guildMembersChunk: [
+    members: Collection<Snowflake, GuildMember>,
+    guild: Guild,
+    data: { index: number; count: number; notFound: unknown[]; nonce: string | undefined },
+  ];
+  guildMemberUpdate: [oldMember: GuildMember | PartialGuildMember, newMember: GuildMember];
+  guildUpdate: [oldGuild: Guild, newGuild: Guild];
+  inviteCreate: [invite: Invite];
+  inviteDelete: [invite: Invite];
+  messageCreate: [message: Message];
+  messageDelete: [message: Message | PartialMessage];
+  messageReactionRemoveAll: [
+    message: Message | PartialMessage,
+    reactions: Collection<string | Snowflake, MessageReaction>,
+  ];
+  messageReactionRemoveEmoji: [reaction: MessageReaction | PartialMessageReaction];
+  messageDeleteBulk: [messages: Collection<Snowflake, Message | PartialMessage>, channel: GuildTextBasedChannel];
+  messageReactionAdd: [reaction: MessageReaction | PartialMessageReaction, user: User | PartialUser];
+  messageReactionRemove: [reaction: MessageReaction | PartialMessageReaction, user: User | PartialUser];
+  messageUpdate: [oldMessage: Message | PartialMessage, newMessage: Message | PartialMessage];
+  presenceUpdate: [oldPresence: Presence | null, newPresence: Presence];
+  ready: [client: Client<true>];
+  invalidated: [];
+  roleCreate: [role: Role];
+  roleDelete: [role: Role];
+  roleUpdate: [oldRole: Role, newRole: Role];
+  threadCreate: [thread: AnyThreadChannel, newlyCreated: boolean];
+  threadDelete: [thread: AnyThreadChannel];
+  threadListSync: [threads: Collection<Snowflake, AnyThreadChannel>, guild: Guild];
+  threadMemberUpdate: [oldMember: ThreadMember, newMember: ThreadMember];
+  threadMembersUpdate: [
+    addedMembers: Collection<Snowflake, ThreadMember>,
+    removedMembers: Collection<Snowflake, ThreadMember | PartialThreadMember>,
+    thread: AnyThreadChannel,
+  ];
+  threadUpdate: [oldThread: AnyThreadChannel, newThread: AnyThreadChannel];
+  typingStart: [typing: Typing];
+  userUpdate: [oldUser: User | PartialUser, newUser: User];
+  voiceStateUpdate: [oldState: VoiceState, newState: VoiceState];
+  /** @deprecated Use {@link webhooksUpdate} instead. */
+  webhookUpdate: ClientEvents['webhooksUpdate'];
+  webhooksUpdate: [channel: TextChannel | NewsChannel | VoiceChannel | ForumChannel];
+  interactionCreate: [interaction: Interaction];
+  shardDisconnect: [closeEvent: CloseEvent, shardId: number];
+  shardError: [error: Error, shardId: number];
+  shardReady: [shardId: number, unavailableGuilds: Set<Snowflake> | undefined];
+  shardReconnecting: [shardId: number];
+  shardResume: [shardId: number, replayedEvents: number];
+  stageInstanceCreate: [stageInstance: StageInstance];
+  stageInstanceUpdate: [oldStageInstance: StageInstance | null, newStageInstance: StageInstance];
+  stageInstanceDelete: [stageInstance: StageInstance];
+  stickerCreate: [sticker: Sticker];
+  stickerDelete: [sticker: Sticker];
+  stickerUpdate: [oldSticker: Sticker, newSticker: Sticker];
+  guildScheduledEventCreate: [guildScheduledEvent: GuildScheduledEvent];
+  guildScheduledEventUpdate: [
+    oldGuildScheduledEvent: GuildScheduledEvent | null,
+    newGuildScheduledEvent: GuildScheduledEvent,
+  ];
+  guildScheduledEventDelete: [guildScheduledEvent: GuildScheduledEvent];
+  guildScheduledEventUserAdd: [guildScheduledEvent: GuildScheduledEvent, user: User];
+  guildScheduledEventUserRemove: [guildScheduledEvent: GuildScheduledEvent, user: User];
+}
+
+export interface ClientFetchInviteOptions {
+  guildScheduledEventId?: Snowflake;
+}
+
+export interface ClientOptions {
+  shards?: number | number[] | 'auto';
+  shardCount?: number;
+  closeTimeout?: number;
+  makeCache?: CacheFactory;
+  allowedMentions?: MessageMentionOptions;
+  partials?: Partials[];
+  failIfNotExists?: boolean;
+  presence?: PresenceData;
+  intents: BitFieldResolvable<GatewayIntentsString, number>;
+  waitGuildTimeout?: number;
+  sweepers?: SweeperOptions;
+  ws?: WebSocketOptions;
+  rest?: Partial<RESTOptions>;
+  jsonTransformer?: (obj: unknown) => unknown;
+}
+
+export type ClientPresenceStatus = 'online' | 'idle' | 'dnd';
+
+export interface ClientPresenceStatusData {
+  web?: ClientPresenceStatus;
+  mobile?: ClientPresenceStatus;
+  desktop?: ClientPresenceStatus;
+}
+
+export interface ClientUserEditOptions {
+  username?: string;
+  avatar?: BufferResolvable | Base64Resolvable | null;
+}
+
+export interface CloseEvent {
+  /** @deprecated */
+  wasClean: boolean;
+  code: number;
+  /** @deprecated */
+  reason: string;
+}
+
+export type CollectorFilter<T extends unknown[]> = (...args: T) => boolean | Promise<boolean>;
+
+export interface CollectorOptions<T extends unknown[]> {
+  filter?: CollectorFilter<T>;
+  time?: number;
+  idle?: number;
+  dispose?: boolean;
+}
+
+export interface CollectorResetTimerOptions {
+  time?: number;
+  idle?: number;
+}
+
+export type ColorResolvable =
+  | keyof typeof Colors
+  | 'Random'
+  | readonly [red: number, green: number, blue: number]
+  | number
+  | HexColorString;
+
+export interface CommandInteractionOption<Cached extends CacheType = CacheType> {
+  name: string;
+  type: ApplicationCommandOptionType;
+  value?: string | number | boolean;
+  focused?: boolean;
+  autocomplete?: boolean;
+  options?: CommandInteractionOption[];
+  user?: User;
+  member?: CacheTypeReducer<Cached, GuildMember, APIInteractionDataResolvedGuildMember>;
+  channel?: CacheTypeReducer<Cached, GuildBasedChannel, APIInteractionDataResolvedChannel>;
+  role?: CacheTypeReducer<Cached, Role, APIRole>;
+  attachment?: Attachment;
+  message?: Message<BooleanCache<Cached>>;
+}
+
+export interface CommandInteractionResolvedData<Cached extends CacheType = CacheType> {
+  users?: Collection<Snowflake, User>;
+  members?: Collection<Snowflake, CacheTypeReducer<Cached, GuildMember, APIInteractionDataResolvedGuildMember>>;
+  roles?: Collection<Snowflake, CacheTypeReducer<Cached, Role, APIRole>>;
+  channels?: Collection<Snowflake, CacheTypeReducer<Cached, Channel, APIInteractionDataResolvedChannel>>;
+  messages?: Collection<Snowflake, CacheTypeReducer<Cached, Message, APIMessage>>;
+  attachments?: Collection<Snowflake, Attachment>;
+}
+
+export type AutocompleteFocusedOption = Pick<CommandInteractionOption, 'name'> & {
+  focused: true;
+  type:
+    | ApplicationCommandOptionType.String
+    | ApplicationCommandOptionType.Integer
+    | ApplicationCommandOptionType.Number;
+  value: string;
+};
+
+export declare const Colors: {
+  Default: 0x000000;
+  White: 0xffffff;
+  Aqua: 0x1abc9c;
+  Green: 0x57f287;
+  Blue: 0x3498db;
+  Yellow: 0xfee75c;
+  Purple: 0x9b59b6;
+  LuminousVividPink: 0xe91e63;
+  Fuchsia: 0xeb459e;
+  Gold: 0xf1c40f;
+  Orange: 0xe67e22;
+  Red: 0xed4245;
+  Grey: 0x95a5a6;
+  Navy: 0x34495e;
+  DarkAqua: 0x11806a;
+  DarkGreen: 0x1f8b4c;
+  DarkBlue: 0x206694;
+  DarkPurple: 0x71368a;
+  DarkVividPink: 0xad1457;
+  DarkGold: 0xc27c0e;
+  DarkOrange: 0xa84300;
+  DarkRed: 0x992d22;
+  DarkGrey: 0x979c9f;
+  DarkerGrey: 0x7f8c8d;
+  LightGrey: 0xbcc0c0;
+  DarkNavy: 0x2c3e50;
+  Blurple: 0x5865f2;
+  Greyple: 0x99aab5;
+  DarkButNotBlack: 0x2c2f33;
+  NotQuiteBlack: 0x23272a;
+};
+
+export enum Events {
+  ApplicationCommandPermissionsUpdate = 'applicationCommandPermissionsUpdate',
+  AutoModerationActionExecution = 'autoModerationActionExecution',
+  AutoModerationRuleCreate = 'autoModerationRuleCreate',
+  AutoModerationRuleDelete = 'autoModerationRuleDelete',
+  AutoModerationRuleUpdate = 'autoModerationRuleUpdate',
+  ClientReady = 'ready',
+  GuildAuditLogEntryCreate = 'guildAuditLogEntryCreate',
+  GuildAvailable = 'guildAvailable',
+  GuildCreate = 'guildCreate',
+  GuildDelete = 'guildDelete',
+  GuildUpdate = 'guildUpdate',
+  GuildUnavailable = 'guildUnavailable',
+  GuildMemberAdd = 'guildMemberAdd',
+  GuildMemberRemove = 'guildMemberRemove',
+  GuildMemberUpdate = 'guildMemberUpdate',
+  GuildMemberAvailable = 'guildMemberAvailable',
+  GuildMembersChunk = 'guildMembersChunk',
+  GuildIntegrationsUpdate = 'guildIntegrationsUpdate',
+  GuildRoleCreate = 'roleCreate',
+  GuildRoleDelete = 'roleDelete',
+  InviteCreate = 'inviteCreate',
+  InviteDelete = 'inviteDelete',
+  GuildRoleUpdate = 'roleUpdate',
+  GuildEmojiCreate = 'emojiCreate',
+  GuildEmojiDelete = 'emojiDelete',
+  GuildEmojiUpdate = 'emojiUpdate',
+  GuildBanAdd = 'guildBanAdd',
+  GuildBanRemove = 'guildBanRemove',
+  ChannelCreate = 'channelCreate',
+  ChannelDelete = 'channelDelete',
+  ChannelUpdate = 'channelUpdate',
+  ChannelPinsUpdate = 'channelPinsUpdate',
+  MessageCreate = 'messageCreate',
+  MessageDelete = 'messageDelete',
+  MessageUpdate = 'messageUpdate',
+  MessageBulkDelete = 'messageDeleteBulk',
+  MessageReactionAdd = 'messageReactionAdd',
+  MessageReactionRemove = 'messageReactionRemove',
+  MessageReactionRemoveAll = 'messageReactionRemoveAll',
+  MessageReactionRemoveEmoji = 'messageReactionRemoveEmoji',
+  ThreadCreate = 'threadCreate',
+  ThreadDelete = 'threadDelete',
+  ThreadUpdate = 'threadUpdate',
+  ThreadListSync = 'threadListSync',
+  ThreadMemberUpdate = 'threadMemberUpdate',
+  ThreadMembersUpdate = 'threadMembersUpdate',
+  UserUpdate = 'userUpdate',
+  PresenceUpdate = 'presenceUpdate',
+  VoiceServerUpdate = 'voiceServerUpdate',
+  VoiceStateUpdate = 'voiceStateUpdate',
+  TypingStart = 'typingStart',
+  WebhooksUpdate = 'webhookUpdate',
+  InteractionCreate = 'interactionCreate',
+  Error = 'error',
+  Warn = 'warn',
+  Debug = 'debug',
+  CacheSweep = 'cacheSweep',
+  ShardDisconnect = 'shardDisconnect',
+  ShardError = 'shardError',
+  ShardReconnecting = 'shardReconnecting',
+  ShardReady = 'shardReady',
+  ShardResume = 'shardResume',
+  Invalidated = 'invalidated',
+  Raw = 'raw',
+  StageInstanceCreate = 'stageInstanceCreate',
+  StageInstanceUpdate = 'stageInstanceUpdate',
+  StageInstanceDelete = 'stageInstanceDelete',
+  GuildStickerCreate = 'stickerCreate',
+  GuildStickerDelete = 'stickerDelete',
+  GuildStickerUpdate = 'stickerUpdate',
+  GuildScheduledEventCreate = 'guildScheduledEventCreate',
+  GuildScheduledEventUpdate = 'guildScheduledEventUpdate',
+  GuildScheduledEventDelete = 'guildScheduledEventDelete',
+  GuildScheduledEventUserAdd = 'guildScheduledEventUserAdd',
+  GuildScheduledEventUserRemove = 'guildScheduledEventUserRemove',
+}
+
+export enum ShardEvents {
+  Death = 'death',
+  Disconnect = 'disconnect',
+  Error = 'error',
+  Message = 'message',
+  Ready = 'ready',
+  Reconnecting = 'reconnecting',
+  Resume = 'resume',
+  Spawn = 'spawn',
+}
+
+export enum WebSocketShardEvents {
+  Close = 'close',
+  Destroyed = 'destroyed',
+  InvalidSession = 'invalidSession',
+  Ready = 'ready',
+  Resumed = 'resumed',
+  AllReady = 'allReady',
+}
+
+export enum Status {
+  Ready = 0,
+  Connecting = 1,
+  Reconnecting = 2,
+  Idle = 3,
+  Nearly = 4,
+  Disconnected = 5,
+  WaitingForGuilds = 6,
+  Identifying = 7,
+  Resuming = 8,
+}
+
+export interface GuildScheduledEventInviteURLCreateOptions extends InviteCreateOptions {
+  channel?: GuildInvitableChannelResolvable;
+}
+
+export interface RoleCreateOptions extends RoleData {
+  reason?: string;
+}
+
+export interface RoleEditOptions extends RoleData {
+  reason?: string;
+}
+
+export interface StageInstanceCreateOptions {
+  topic: string;
+  privacyLevel?: StageInstancePrivacyLevel;
+  sendStartNotification?: boolean;
+}
+
+export interface CrosspostedChannel {
+  channelId: Snowflake;
+  guildId: Snowflake;
+  type: ChannelType;
+  name: string;
+}
+
+export type DateResolvable = Date | number | string;
+
+export interface GuildTemplateEditOptions {
+  name?: string;
+  description?: string;
+}
+
+export interface EmbedField {
+  name: string;
+  value: string;
+  inline: boolean;
+}
+
+export type EmojiIdentifierResolvable =
+  | EmojiResolvable
+  | `${'' | 'a:'}${string}:${Snowflake}`
+  | `<${'' | 'a'}:${string}:${Snowflake}>`
+  | string;
+
+export type EmojiResolvable = Snowflake | GuildEmoji | ReactionEmoji;
+
+export interface ErrorEvent {
+  error: unknown;
+  message: string;
+  type: string;
+  target: WebSocket;
+}
+
+export interface FetchApplicationCommandOptions extends BaseFetchOptions {
+  guildId?: Snowflake;
+  locale?: LocaleString;
+  withLocalizations?: boolean;
+}
+
+export interface FetchArchivedThreadOptions {
+  type?: 'public' | 'private';
+  fetchAll?: boolean;
+  before?: ThreadChannelResolvable | DateResolvable;
+  limit?: number;
+}
+
+export interface FetchAutoModerationRuleOptions extends BaseFetchOptions {
+  autoModerationRule: AutoModerationRuleResolvable;
+}
+
+export interface FetchAutoModerationRulesOptions {
+  cache?: boolean;
+}
+
+export interface FetchBanOptions extends BaseFetchOptions {
+  user: UserResolvable;
+}
+
+export interface FetchBansOptions {
+  limit?: number;
+  before?: Snowflake;
+  after?: Snowflake;
+  cache?: boolean;
+}
+
+export interface FetchChannelOptions extends BaseFetchOptions {
+  allowUnknownGuild?: boolean;
+}
+
+export interface FetchedThreads {
+  threads: Collection<Snowflake, AnyThreadChannel>;
+  members: Collection<Snowflake, ThreadMember>;
+}
+
+export interface FetchedThreadsMore extends FetchedThreads {
+  hasMore: boolean;
+}
+
+export interface FetchGuildOptions extends BaseFetchOptions {
+  guild: GuildResolvable;
+  withCounts?: boolean;
+}
+
+export interface FetchGuildsOptions {
+  before?: Snowflake;
+  after?: Snowflake;
+  limit?: number;
+}
+
+export interface FetchGuildScheduledEventOptions extends BaseFetchOptions {
+  guildScheduledEvent: GuildScheduledEventResolvable;
+  withUserCount?: boolean;
+}
+
+export interface FetchGuildScheduledEventsOptions {
+  cache?: boolean;
+  withUserCount?: boolean;
+}
+
+export interface FetchGuildScheduledEventSubscribersOptions {
+  limit?: number;
+  withMember?: boolean;
+}
+
+interface FetchInviteOptions extends BaseFetchOptions {
+  code: string;
+}
+
+interface FetchInvitesOptions {
+  channelId?: GuildInvitableChannelResolvable;
+  cache?: boolean;
+}
+
+export interface FetchMemberOptions extends BaseFetchOptions {
+  user: UserResolvable;
+}
+
+export interface FetchMembersOptions {
+  user?: UserResolvable | UserResolvable[];
+  query?: string;
+  limit?: number;
+  withPresences?: boolean;
+  time?: number;
+  nonce?: string;
+}
+
+export interface FetchMessageOptions extends BaseFetchOptions {
+  message: MessageResolvable;
+}
+
+export interface FetchMessagesOptions {
+  limit?: number;
+  before?: Snowflake;
+  after?: Snowflake;
+  around?: Snowflake;
+  cache?: boolean;
+}
+
+export interface FetchReactionUsersOptions {
+  limit?: number;
+  after?: Snowflake;
+}
+
+export interface FetchThreadMemberOptions extends BaseFetchOptions {
+  member: ThreadMemberResolvable;
+  withMember?: boolean;
+}
+
+export interface FetchThreadMembersWithGuildMemberDataOptions {
+  withMember: true;
+  after?: Snowflake;
+  limit?: number;
+  cache?: boolean;
+}
+
+export interface FetchThreadMembersWithoutGuildMemberDataOptions {
+  withMember?: false;
+  cache?: boolean;
+}
+
+export type FetchThreadMembersOptions =
+  | FetchThreadMembersWithGuildMemberDataOptions
+  | FetchThreadMembersWithoutGuildMemberDataOptions;
+
+export interface FetchThreadsOptions {
+  archived?: FetchArchivedThreadOptions;
+}
+
+export interface AttachmentPayload {
+  attachment: BufferResolvable | Stream;
+  name?: string;
+  description?: string;
+}
+
+export type GlobalSweepFilter<K, V> = () => ((value: V, key: K, collection: Collection<K, V>) => boolean) | null;
+
+interface GuildAuditLogsTypes {
+  [AuditLogEvent.GuildUpdate]: ['Guild', 'Update'];
+  [AuditLogEvent.ChannelCreate]: ['Channel', 'Create'];
+  [AuditLogEvent.ChannelUpdate]: ['Channel', 'Update'];
+  [AuditLogEvent.ChannelDelete]: ['Channel', 'Delete'];
+  [AuditLogEvent.ChannelOverwriteCreate]: ['Channel', 'Create'];
+  [AuditLogEvent.ChannelOverwriteUpdate]: ['Channel', 'Update'];
+  [AuditLogEvent.ChannelOverwriteDelete]: ['Channel', 'Delete'];
+  [AuditLogEvent.MemberKick]: ['User', 'Delete'];
+  [AuditLogEvent.MemberPrune]: ['User', 'Delete'];
+  [AuditLogEvent.MemberBanAdd]: ['User', 'Delete'];
+  [AuditLogEvent.MemberBanRemove]: ['User', 'Create'];
+  [AuditLogEvent.MemberUpdate]: ['User', 'Update'];
+  [AuditLogEvent.MemberRoleUpdate]: ['User', 'Update'];
+  [AuditLogEvent.MemberMove]: ['User', 'Update'];
+  [AuditLogEvent.MemberDisconnect]: ['User', 'Delete'];
+  [AuditLogEvent.BotAdd]: ['User', 'Create'];
+  [AuditLogEvent.RoleCreate]: ['Role', 'Create'];
+  [AuditLogEvent.RoleUpdate]: ['Role', 'Update'];
+  [AuditLogEvent.RoleDelete]: ['Role', 'Delete'];
+  [AuditLogEvent.InviteCreate]: ['Invite', 'Create'];
+  [AuditLogEvent.InviteUpdate]: ['Invite', 'Update'];
+  [AuditLogEvent.InviteDelete]: ['Invite', 'Delete'];
+  [AuditLogEvent.WebhookCreate]: ['Webhook', 'Create'];
+  [AuditLogEvent.WebhookUpdate]: ['Webhook', 'Update'];
+  [AuditLogEvent.WebhookDelete]: ['Webhook', 'Delete'];
+  [AuditLogEvent.EmojiCreate]: ['Emoji', 'Create'];
+  [AuditLogEvent.EmojiUpdate]: ['Emoji', 'Update'];
+  [AuditLogEvent.EmojiDelete]: ['Emoji', 'Delete'];
+  [AuditLogEvent.MessageDelete]: ['Message', 'Delete'];
+  [AuditLogEvent.MessageBulkDelete]: ['Message', 'Delete'];
+  [AuditLogEvent.MessagePin]: ['Message', 'Create'];
+  [AuditLogEvent.MessageUnpin]: ['Message', 'Delete'];
+  [AuditLogEvent.IntegrationCreate]: ['Integration', 'Create'];
+  [AuditLogEvent.IntegrationUpdate]: ['Integration', 'Update'];
+  [AuditLogEvent.IntegrationDelete]: ['Integration', 'Delete'];
+  [AuditLogEvent.StageInstanceCreate]: ['StageInstance', 'Create'];
+  [AuditLogEvent.StageInstanceUpdate]: ['StageInstance', 'Update'];
+  [AuditLogEvent.StageInstanceDelete]: ['StageInstance', 'Delete'];
+  [AuditLogEvent.StickerCreate]: ['Sticker', 'Create'];
+  [AuditLogEvent.StickerUpdate]: ['Sticker', 'Update'];
+  [AuditLogEvent.StickerDelete]: ['Sticker', 'Delete'];
+  [AuditLogEvent.GuildScheduledEventCreate]: ['GuildScheduledEvent', 'Create'];
+  [AuditLogEvent.GuildScheduledEventUpdate]: ['GuildScheduledEvent', 'Update'];
+  [AuditLogEvent.GuildScheduledEventDelete]: ['GuildScheduledEvent', 'Delete'];
+  [AuditLogEvent.ThreadCreate]: ['Thread', 'Create'];
+  [AuditLogEvent.ThreadUpdate]: ['Thread', 'Update'];
+  [AuditLogEvent.ThreadDelete]: ['Thread', 'Delete'];
+  [AuditLogEvent.ApplicationCommandPermissionUpdate]: ['ApplicationCommand', 'Update'];
+  [AuditLogEvent.AutoModerationRuleCreate]: ['AutoModerationRule', 'Create'];
+  [AuditLogEvent.AutoModerationRuleUpdate]: ['AutoModerationRule', 'Update'];
+  [AuditLogEvent.AutoModerationRuleDelete]: ['AutoModerationRule', 'Delete'];
+  [AuditLogEvent.AutoModerationBlockMessage]: ['AutoModerationRule', 'Create'];
+  [AuditLogEvent.AutoModerationFlagToChannel]: ['AutoModerationRule', 'Create'];
+  [AuditLogEvent.AutoModerationUserCommunicationDisabled]: ['AutoModerationRule', 'Create'];
+}
+
+export type GuildAuditLogsActionType = GuildAuditLogsTypes[keyof GuildAuditLogsTypes][1] | 'All';
+
+export interface GuildAuditLogsEntryExtraField {
+  [AuditLogEvent.MemberPrune]: { removed: number; days: number };
+  [AuditLogEvent.MemberMove]: { channel: VoiceBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MessageDelete]: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MessageBulkDelete]: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MessagePin]: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
+  [AuditLogEvent.MessageUnpin]: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
+  [AuditLogEvent.MemberDisconnect]: { count: number };
+  [AuditLogEvent.ChannelOverwriteCreate]:
+    | Role
+    | GuildMember
+    | { id: Snowflake; name: string; type: AuditLogOptionsType.Role }
+    | { id: Snowflake; type: AuditLogOptionsType.Member };
+  [AuditLogEvent.ChannelOverwriteUpdate]:
+    | Role
+    | GuildMember
+    | { id: Snowflake; name: string; type: AuditLogOptionsType.Role }
+    | { id: Snowflake; type: AuditLogOptionsType.Member };
+  [AuditLogEvent.ChannelOverwriteDelete]:
+    | Role
+    | GuildMember
+    | { id: Snowflake; name: string; type: AuditLogOptionsType.Role }
+    | { id: Snowflake; type: AuditLogOptionsType.Member };
+  [AuditLogEvent.StageInstanceCreate]: StageChannel | { id: Snowflake };
+  [AuditLogEvent.StageInstanceDelete]: StageChannel | { id: Snowflake };
+  [AuditLogEvent.StageInstanceUpdate]: StageChannel | { id: Snowflake };
+  [AuditLogEvent.ApplicationCommandPermissionUpdate]: { applicationId: Snowflake };
+  [AuditLogEvent.AutoModerationBlockMessage]: {
+    autoModerationRuleName: string;
+    autoModerationRuleTriggerType: AuditLogRuleTriggerType;
+    channel: GuildTextBasedChannel | { id: Snowflake };
+  };
+  [AuditLogEvent.AutoModerationFlagToChannel]: {
+    autoModerationRuleName: string;
+    autoModerationRuleTriggerType: AuditLogRuleTriggerType;
+    channel: GuildTextBasedChannel | { id: Snowflake };
+  };
+  [AuditLogEvent.AutoModerationUserCommunicationDisabled]: {
+    autoModerationRuleName: string;
+    autoModerationRuleTriggerType: AuditLogRuleTriggerType;
+    channel: GuildTextBasedChannel | { id: Snowflake };
+  };
+}
+
+export interface GuildAuditLogsEntryTargetField<TActionType extends GuildAuditLogsActionType> {
+  User: User | null;
+  Guild: Guild;
+  Webhook: Webhook;
+  Invite: Invite;
+  Message: TActionType extends AuditLogEvent.MessageBulkDelete ? Guild | { id: Snowflake } : User;
+  Integration: Integration;
+  Channel: NonThreadGuildBasedChannel | { id: Snowflake; [x: string]: unknown };
+  Thread: AnyThreadChannel | { id: Snowflake; [x: string]: unknown };
+  StageInstance: StageInstance;
+  Sticker: Sticker;
+  GuildScheduledEvent: GuildScheduledEvent;
+  ApplicationCommand: ApplicationCommand | { id: Snowflake };
+  AutoModerationRule: AutoModerationRule;
+}
+
+export interface GuildAuditLogsFetchOptions<T extends GuildAuditLogsResolvable> {
+  before?: Snowflake | GuildAuditLogsEntry;
+  after?: Snowflake | GuildAuditLogsEntry;
+  limit?: number;
+  user?: UserResolvable;
+  type?: T;
+}
+
+export type GuildAuditLogsResolvable = AuditLogEvent | null;
+
+export type GuildAuditLogsTargetType = GuildAuditLogsTypes[keyof GuildAuditLogsTypes][0] | 'All' | 'Unknown';
+
+export type GuildAuditLogsTargets = {
+  [key in GuildAuditLogsTargetType]: GuildAuditLogsTargetType;
+};
+
+export type GuildBanResolvable = GuildBan | UserResolvable;
+
+export type GuildChannelResolvable = Snowflake | GuildBasedChannel;
+
+export interface AutoModerationRuleCreateOptions {
+  name: string;
+  eventType: AutoModerationRuleEventType;
+  triggerType: AutoModerationRuleTriggerType;
+  triggerMetadata?: AutoModerationTriggerMetadataOptions;
+  actions: AutoModerationActionOptions[];
+  enabled?: boolean;
+  exemptRoles?: Collection<Snowflake, Role> | RoleResolvable[];
+  exemptChannels?: Collection<Snowflake, GuildBasedChannel> | GuildChannelResolvable[];
+  reason?: string;
+}
+
+export interface AutoModerationRuleEditOptions extends Partial<Omit<AutoModerationRuleCreateOptions, 'triggerType'>> {}
+
+export interface AutoModerationTriggerMetadataOptions extends Partial<AutoModerationTriggerMetadata> {}
+
+export interface AutoModerationActionOptions {
+  type: AutoModerationActionType;
+  metadata?: AutoModerationActionMetadataOptions;
+}
+
+export interface AutoModerationActionMetadataOptions extends Partial<Omit<AutoModerationActionMetadata, 'channelId'>> {
+  channel?: GuildTextChannelResolvable | ThreadChannel;
+}
+
+export interface GuildChannelCreateOptions extends Omit<CategoryCreateChannelOptions, 'type'> {
+  parent?: CategoryChannelResolvable | null;
+  type?: Exclude<
+    ChannelType,
+    | ChannelType.DM
+    | ChannelType.GroupDM
+    | ChannelType.PublicThread
+    | ChannelType.AnnouncementThread
+    | ChannelType.PrivateThread
+  >;
+}
+
+export interface GuildChannelCloneOptions extends Omit<GuildChannelCreateOptions, 'name'> {
+  name?: string;
+}
+
+export interface GuildChannelEditOptions {
+  name?: string;
+  type?: ChannelType.GuildText | ChannelType.GuildAnnouncement;
+  position?: number;
+  topic?: string | null;
+  nsfw?: boolean;
+  bitrate?: number;
+  userLimit?: number;
+  parent?: CategoryChannelResolvable | null;
+  rateLimitPerUser?: number;
+  lockPermissions?: boolean;
+  permissionOverwrites?: readonly OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
+  defaultAutoArchiveDuration?: ThreadAutoArchiveDuration;
+  rtcRegion?: string | null;
+  videoQualityMode?: VideoQualityMode | null;
+  availableTags?: GuildForumTagData[];
+  defaultReactionEmoji?: DefaultReactionEmoji | null;
+  defaultThreadRateLimitPerUser?: number;
+  flags?: ChannelFlagsResolvable;
+  defaultSortOrder?: SortOrderType | null;
+  defaultForumLayout?: ForumLayoutType;
+  reason?: string;
+}
+
+export interface GuildChannelOverwriteOptions {
+  reason?: string;
+  type?: OverwriteType;
+}
+
+export interface GuildCreateOptions {
+  name: string;
+  icon?: BufferResolvable | Base64Resolvable | null;
+  verificationLevel?: GuildVerificationLevel;
+  defaultMessageNotifications?: GuildDefaultMessageNotifications;
+  explicitContentFilter?: GuildExplicitContentFilter;
+  roles?: PartialRoleData[];
+  channels?: PartialChannelData[];
+  afkChannelId?: Snowflake | number;
+  afkTimeout?: number;
+  systemChannelId?: Snowflake | number;
+  systemChannelFlags?: SystemChannelFlagsResolvable;
+}
+
+export interface GuildWidgetSettings {
+  enabled: boolean;
+  channel: TextChannel | NewsChannel | VoiceBasedChannel | ForumChannel | null;
+}
+
+export interface GuildEditOptions {
+  name?: string;
+  verificationLevel?: GuildVerificationLevel | null;
+  defaultMessageNotifications?: GuildDefaultMessageNotifications | null;
+  explicitContentFilter?: GuildExplicitContentFilter | null;
+  afkTimeout?: number;
+  afkChannel?: VoiceChannelResolvable | null;
+  icon?: BufferResolvable | Base64Resolvable | null;
+  owner?: GuildMemberResolvable;
+  splash?: BufferResolvable | Base64Resolvable | null;
+  discoverySplash?: BufferResolvable | Base64Resolvable | null;
+  banner?: BufferResolvable | Base64Resolvable | null;
+  systemChannel?: TextChannelResolvable | null;
+  systemChannelFlags?: SystemChannelFlagsResolvable;
+  rulesChannel?: TextChannelResolvable | null;
+  publicUpdatesChannel?: TextChannelResolvable | null;
+  safetyAlertsChannel?: TextChannelResolvable | null;
+  preferredLocale?: Locale | null;
+  features?: `${GuildFeature}`[];
+  description?: string | null;
+  premiumProgressBarEnabled?: boolean;
+  reason?: string;
+}
+
+export interface GuildEmojiCreateOptions {
+  attachment: BufferResolvable | Base64Resolvable;
+  name: string;
+  roles?: Collection<Snowflake, Role> | RoleResolvable[];
+  reason?: string;
+}
+
+export interface GuildEmojiEditOptions {
+  name?: string;
+  roles?: Collection<Snowflake, Role> | RoleResolvable[];
+  reason?: string;
+}
+
+export interface GuildStickerCreateOptions {
+  file: BufferResolvable | Stream | AttachmentPayload | JSONEncodable<AttachmentBuilder>;
+  name: string;
+  tags: string;
+  description?: string | null;
+  reason?: string;
+}
+
+export interface GuildStickerEditOptions {
+  name?: string;
+  description?: string | null;
+  tags?: string;
+  reason?: string;
+}
+
+export interface GuildMemberEditOptions {
+  nick?: string | null;
+  roles?: Collection<Snowflake, Role> | readonly RoleResolvable[];
+  mute?: boolean;
+  deaf?: boolean;
+  channel?: GuildVoiceChannelResolvable | null;
+  communicationDisabledUntil?: DateResolvable | null;
+  flags?: GuildMemberFlagsResolvable;
+  reason?: string;
+}
+
+export type GuildMemberResolvable = GuildMember | UserResolvable;
+
+export type GuildResolvable = Guild | NonThreadGuildBasedChannel | GuildMember | GuildEmoji | Invite | Role | Snowflake;
+
+export interface GuildPruneMembersOptions {
+  count?: boolean;
+  days?: number;
+  dry?: boolean;
+  reason?: string;
+  roles?: RoleResolvable[];
+}
+
+export interface GuildWidgetSettingsData {
+  enabled: boolean;
+  channel: TextChannel | NewsChannel | VoiceBasedChannel | ForumChannel | Snowflake | null;
+}
+
+export interface GuildSearchMembersOptions {
+  query: string;
+  limit?: number;
+  cache?: boolean;
+}
+
+export interface GuildListMembersOptions {
+  after?: Snowflake;
+  limit?: number;
+  cache?: boolean;
+}
+
+// TODO: use conditional types for better TS support
+export interface GuildScheduledEventCreateOptions {
+  name: string;
+  scheduledStartTime: DateResolvable;
+  scheduledEndTime?: DateResolvable;
+  privacyLevel: GuildScheduledEventPrivacyLevel;
+  entityType: GuildScheduledEventEntityType;
+  description?: string;
+  channel?: GuildVoiceChannelResolvable;
+  entityMetadata?: GuildScheduledEventEntityMetadataOptions;
+  image?: BufferResolvable | Base64Resolvable | null;
+  reason?: string;
+}
+
+export interface GuildScheduledEventEditOptions<
+  S extends GuildScheduledEventStatus,
+  T extends GuildScheduledEventSetStatusArg<S>,
+> extends Omit<Partial<GuildScheduledEventCreateOptions>, 'channel'> {
+  channel?: GuildVoiceChannelResolvable | null;
+  status?: T;
+}
+
+export interface GuildScheduledEventEntityMetadata {
+  location: string | null;
+}
+
+export interface GuildScheduledEventEntityMetadataOptions {
+  location?: string;
+}
+
+export type GuildScheduledEventManagerFetchResult<
+  T extends GuildScheduledEventResolvable | FetchGuildScheduledEventOptions | FetchGuildScheduledEventsOptions,
+> = T extends GuildScheduledEventResolvable | FetchGuildScheduledEventOptions
+  ? GuildScheduledEvent
+  : Collection<Snowflake, GuildScheduledEvent>;
+
+export type GuildScheduledEventManagerFetchSubscribersResult<T extends FetchGuildScheduledEventSubscribersOptions> =
+  T extends { withMember: true }
+    ? Collection<Snowflake, GuildScheduledEventUser<true>>
+    : Collection<Snowflake, GuildScheduledEventUser<false>>;
+
+export type GuildScheduledEventResolvable = Snowflake | GuildScheduledEvent;
+
+export type GuildScheduledEventSetStatusArg<T extends GuildScheduledEventStatus> =
+  T extends GuildScheduledEventStatus.Scheduled
+    ? GuildScheduledEventStatus.Active | GuildScheduledEventStatus.Canceled
+    : T extends GuildScheduledEventStatus.Active
+    ? GuildScheduledEventStatus.Completed
+    : never;
+
+export interface GuildScheduledEventUser<T> {
+  guildScheduledEventId: Snowflake;
+  user: User;
+  member: T extends true ? GuildMember : null;
+}
+
+export type GuildTemplateResolvable = string;
+
+export type GuildVoiceChannelResolvable = VoiceBasedChannel | Snowflake;
+
+export interface GuildOnboardingPromptOptionEmoji {
+  id: Snowflake | null;
+  name: string;
+  animated: boolean;
+}
+
+export type HexColorString = `#${string}`;
+
+export interface IntegrationAccount {
+  id: string | Snowflake;
+  name: string;
+}
+
+export type IntegrationType = 'twitch' | 'youtube' | 'discord' | 'guild_subscription';
+
+export type CollectedInteraction<Cached extends CacheType = CacheType> =
+  | StringSelectMenuInteraction<Cached>
+  | UserSelectMenuInteraction<Cached>
+  | RoleSelectMenuInteraction<Cached>
+  | MentionableSelectMenuInteraction<Cached>
+  | ChannelSelectMenuInteraction<Cached>
+  | ButtonInteraction<Cached>
+  | ModalSubmitInteraction<Cached>;
+
+export interface InteractionCollectorOptions<T extends CollectedInteraction, Cached extends CacheType = CacheType>
+  extends CollectorOptions<[T, Collection<Snowflake, T>]> {
+  channel?: TextBasedChannelResolvable;
+  componentType?: ComponentType;
+  guild?: GuildResolvable;
+  interactionType?: InteractionType;
+  max?: number;
+  maxComponents?: number;
+  maxUsers?: number;
+  message?: CacheTypeReducer<Cached, Message, APIMessage>;
+  interactionResponse?: InteractionResponse<BooleanCache<Cached>>;
+}
+
+export interface InteractionDeferReplyOptions {
+  ephemeral?: boolean;
+  fetchReply?: boolean;
+}
+
+export type InteractionDeferUpdateOptions = Omit<InteractionDeferReplyOptions, 'ephemeral'>;
+
+export interface InteractionReplyOptions extends BaseMessageOptions {
+  tts?: boolean;
+  ephemeral?: boolean;
+  fetchReply?: boolean;
+  flags?: BitFieldResolvable<
+    Extract<MessageFlagsString, 'Ephemeral' | 'SuppressEmbeds'>,
+    MessageFlags.Ephemeral | MessageFlags.SuppressEmbeds
+  >;
+}
+
+export interface InteractionUpdateOptions extends MessageEditOptions {
+  fetchReply?: boolean;
+}
+
+export interface InviteGenerationOptions {
+  permissions?: PermissionResolvable;
+  guild?: GuildResolvable;
+  disableGuildSelect?: boolean;
+  scopes: OAuth2Scopes[];
+}
+
+export type GuildInvitableChannelResolvable =
+  | TextChannel
+  | VoiceChannel
+  | NewsChannel
+  | StageChannel
+  | ForumChannel
+  | Snowflake;
+
+export interface InviteCreateOptions {
+  temporary?: boolean;
+  maxAge?: number;
+  maxUses?: number;
+  unique?: boolean;
+  reason?: string;
+  targetApplication?: ApplicationResolvable;
+  targetUser?: UserResolvable;
+  targetType?: InviteTargetType;
+}
+
+export type InviteResolvable = string;
+
+export interface LifetimeFilterOptions<K, V> {
+  excludeFromSweep?: (value: V, key: K, collection: LimitedCollection<K, V>) => boolean;
+  getComparisonTimestamp?: (value: V, key: K, collection: LimitedCollection<K, V>) => number;
+  lifetime?: number;
+}
+
+export interface MakeErrorOptions {
+  name: string;
+  message: string;
+  stack: string;
+}
+
+export type ActionRowComponentOptions =
+  | ButtonComponentData
+  | StringSelectMenuComponentData
+  | UserSelectMenuComponentData
+  | RoleSelectMenuComponentData
+  | MentionableSelectMenuComponentData
+  | ChannelSelectMenuComponentData;
+
+export type MessageActionRowComponentResolvable = MessageActionRowComponent | ActionRowComponentOptions;
+
+export interface MessageActivity {
+  partyId?: string;
+  type: MessageActivityType;
+}
+
+export interface BaseButtonComponentData extends BaseComponentData {
+  type: ComponentType.Button;
+  style: ButtonStyle;
+  disabled?: boolean;
+  emoji?: ComponentEmojiResolvable;
+  label?: string;
+}
+
+export interface LinkButtonComponentData extends BaseButtonComponentData {
+  style: ButtonStyle.Link;
+  url: string;
+}
+
+export interface InteractionButtonComponentData extends BaseButtonComponentData {
+  style: Exclude<ButtonStyle, ButtonStyle.Link>;
+  customId: string;
+}
+
+export type ButtonComponentData = InteractionButtonComponentData | LinkButtonComponentData;
+
+export interface MessageCollectorOptions extends CollectorOptions<[Message, Collection<Snowflake, Message>]> {
+  max?: number;
+  maxProcessed?: number;
+}
+
+export type MessageComponent =
+  | Component
+  | ActionRowBuilder<MessageActionRowComponentBuilder | ModalActionRowComponentBuilder>
+  | ButtonComponent
+  | StringSelectMenuComponent
+  | UserSelectMenuComponent
+  | RoleSelectMenuComponent
+  | MentionableSelectMenuComponent
+  | ChannelSelectMenuComponent;
+
+export type CollectedMessageInteraction<Cached extends CacheType = CacheType> = Exclude<
+  CollectedInteraction<Cached>,
+  ModalSubmitInteraction
+>;
+
+export type MessageComponentCollectorOptions<T extends CollectedMessageInteraction> = Omit<
+  InteractionCollectorOptions<T>,
+  'channel' | 'message' | 'guild' | 'interactionType'
+>;
+
+export type MessageChannelComponentCollectorOptions<T extends CollectedMessageInteraction> = Omit<
+  InteractionCollectorOptions<T>,
+  'channel' | 'guild' | 'interactionType'
+>;
+
+export interface MessageEvent {
+  data: WebSocket.Data;
+  type: string;
+  target: WebSocket;
+}
+
+export interface MessageInteraction {
+  id: Snowflake;
+  type: InteractionType;
+  commandName: string;
+  user: User;
+}
+
+export interface MessageMentionsHasOptions {
+  ignoreDirect?: boolean;
+  ignoreRoles?: boolean;
+  ignoreRepliedUser?: boolean;
+  ignoreEveryone?: boolean;
+}
+
+export interface MessageMentionOptions {
+  parse?: MessageMentionTypes[];
+  roles?: Snowflake[];
+  users?: Snowflake[];
+  repliedUser?: boolean;
+}
+
+export type MessageMentionTypes = 'roles' | 'users' | 'everyone';
+
+export interface BaseMessageOptions {
+  content?: string;
+  embeds?: (JSONEncodable<APIEmbed> | APIEmbed)[];
+  allowedMentions?: MessageMentionOptions;
+  files?: (
+    | BufferResolvable
+    | Stream
+    | JSONEncodable<APIAttachment>
+    | Attachment
+    | AttachmentBuilder
+    | AttachmentPayload
+  )[];
+  components?: (
+    | JSONEncodable<APIActionRowComponent<APIMessageActionRowComponent>>
+    | ActionRowData<MessageActionRowComponentData | MessageActionRowComponentBuilder>
+    | APIActionRowComponent<APIMessageActionRowComponent>
+  )[];
+}
+
+export interface MessageCreateOptions extends BaseMessageOptions {
+  tts?: boolean;
+  nonce?: string | number;
+  reply?: ReplyOptions;
+  stickers?: StickerResolvable[];
+  flags?: BitFieldResolvable<
+    Extract<MessageFlagsString, 'SuppressEmbeds' | 'SuppressNotifications'>,
+    MessageFlags.SuppressEmbeds | MessageFlags.SuppressNotifications
+  >;
+}
+
+export type GuildForumThreadMessageCreateOptions = BaseMessageOptions &
+  Pick<MessageCreateOptions, 'flags' | 'stickers'>;
+
+export interface MessageEditOptions extends Omit<BaseMessageOptions, 'content'> {
+  content?: string | null;
+  attachments?: JSONEncodable<AttachmentPayload>[];
+  flags?: BitFieldResolvable<Extract<MessageFlagsString, 'SuppressEmbeds'>, MessageFlags.SuppressEmbeds>;
+}
+
+export type MessageReactionResolvable = MessageReaction | Snowflake | string;
+
+export interface MessageReference {
+  channelId: Snowflake;
+  guildId: Snowflake | undefined;
+  messageId: Snowflake | undefined;
+}
+
+export type MessageResolvable = Message | Snowflake;
+
+export interface BaseSelectMenuComponentData extends BaseComponentData {
+  customId: string;
+  disabled?: boolean;
+  maxValues?: number;
+  minValues?: number;
+  placeholder?: string;
+}
+
+export interface StringSelectMenuComponentData extends BaseSelectMenuComponentData {
+  type: ComponentType.StringSelect;
+  options: SelectMenuComponentOptionData[];
+}
+
+export interface UserSelectMenuComponentData extends BaseSelectMenuComponentData {
+  type: ComponentType.UserSelect;
+}
+
+export interface RoleSelectMenuComponentData extends BaseSelectMenuComponentData {
+  type: ComponentType.RoleSelect;
+}
+
+export interface MentionableSelectMenuComponentData extends BaseSelectMenuComponentData {
+  type: ComponentType.MentionableSelect;
+}
+
+export interface ChannelSelectMenuComponentData extends BaseSelectMenuComponentData {
+  type: ComponentType.ChannelSelect;
+  channelTypes?: ChannelType[];
+}
+
+export interface MessageSelectOption {
+  default: boolean;
+  description: string | null;
+  emoji: APIPartialEmoji | null;
+  label: string;
+  value: string;
+}
+
+export interface SelectMenuComponentOptionData {
+  default?: boolean;
+  description?: string;
+  emoji?: ComponentEmojiResolvable;
+  label: string;
+  value: string;
+}
+
+export interface TextInputComponentData extends BaseComponentData {
+  type: ComponentType.TextInput;
+  customId: string;
+  style: TextInputStyle;
+  label: string;
+  minLength?: number;
+  maxLength?: number;
+  required?: boolean;
+  value?: string;
+  placeholder?: string;
+}
+
+export type MessageTarget =
+  | Interaction
+  | InteractionWebhook
+  | TextBasedChannel
+  | User
+  | GuildMember
+  | Webhook
+  | WebhookClient
+  | Message
+  | MessageManager;
+
+export interface MultipleShardRespawnOptions {
+  shardDelay?: number;
+  respawnDelay?: number;
+  timeout?: number;
+}
+
+export interface MultipleShardSpawnOptions {
+  amount?: number | 'auto';
+  delay?: number;
+  timeout?: number;
+}
+
+export interface OverwriteData {
+  allow?: PermissionResolvable;
+  deny?: PermissionResolvable;
+  id: GuildMemberResolvable | RoleResolvable;
+  type?: OverwriteType;
+}
+
+export type OverwriteResolvable = PermissionOverwrites | OverwriteData;
+
+export type PermissionFlags = Record<keyof typeof PermissionFlagsBits, bigint>;
+
+export type PermissionOverwriteOptions = Partial<Record<keyof typeof PermissionFlagsBits, boolean | null>>;
+
+export type PermissionResolvable = BitFieldResolvable<keyof typeof PermissionFlagsBits, bigint>;
+
+export type PermissionOverwriteResolvable = UserResolvable | RoleResolvable | PermissionOverwrites;
+
+export type RecursiveArray<T> = ReadonlyArray<T | RecursiveArray<T>>;
+
+export type RecursiveReadonlyArray<T> = ReadonlyArray<T | RecursiveReadonlyArray<T>>;
+
+export interface PartialRecipient {
+  username: string;
+}
+
+export interface PresenceData {
+  status?: PresenceStatusData;
+  afk?: boolean;
+  activities?: ActivitiesOptions[];
+  shardId?: number | number[];
+}
+
+export type PresenceResolvable = Presence | UserResolvable | Snowflake;
+
+export interface PartialChannelData {
+  id?: Snowflake | number;
+  parentId?: Snowflake | number;
+  type?: ChannelType.GuildText | ChannelType.GuildVoice | ChannelType.GuildCategory;
+  name: string;
+  topic?: string | null;
+  nsfw?: boolean;
+  bitrate?: number;
+  userLimit?: number;
+  rtcRegion?: string | null;
+  videoQualityMode?: VideoQualityMode;
+  permissionOverwrites?: PartialOverwriteData[];
+  rateLimitPerUser?: number;
+}
+
+export type Partialize<
+  T extends AllowedPartial,
+  N extends keyof T | null = null,
+  M extends keyof T | null = null,
+  E extends keyof T | '' = '',
+> = {
+  readonly client: Client<true>;
+  id: Snowflake;
+  partial: true;
+} & {
+  [K in keyof Omit<T, 'client' | 'id' | 'partial' | E>]: K extends N ? null : K extends M ? T[K] | null : T[K];
+};
+
+export interface PartialDMChannel extends Partialize<DMChannel, null, null, 'lastMessageId'> {
+  lastMessageId: undefined;
+}
+
+export interface PartialGuildMember extends Partialize<GuildMember, 'joinedAt' | 'joinedTimestamp' | 'pending'> {}
+
+export interface PartialMessage
+  extends Partialize<Message, 'type' | 'system' | 'pinned' | 'tts', 'content' | 'cleanContent' | 'author'> {}
+
+export interface PartialMessageReaction extends Partialize<MessageReaction, 'count'> {}
+
+export interface PartialThreadMember extends Partialize<ThreadMember, 'flags' | 'joinedAt' | 'joinedTimestamp'> {}
+
+export interface PartialOverwriteData {
+  id: Snowflake | number;
+  type?: OverwriteType;
+  allow?: PermissionResolvable;
+  deny?: PermissionResolvable;
+}
+
+export interface PartialRoleData extends RoleData {
+  id?: Snowflake | number;
+}
+
+export enum Partials {
+  User,
+  Channel,
+  GuildMember,
+  Message,
+  Reaction,
+  GuildScheduledEvent,
+  ThreadMember,
+}
+
+export interface PartialUser extends Partialize<User, 'username' | 'tag' | 'discriminator'> {}
+
+export type PresenceStatusData = ClientPresenceStatus | 'invisible';
+
+export type PresenceStatus = PresenceStatusData | 'offline';
+
+export interface ReactionCollectorOptions extends CollectorOptions<[MessageReaction, User]> {
+  max?: number;
+  maxEmojis?: number;
+  maxUsers?: number;
+}
+
+export interface ReplyOptions {
+  messageReference: MessageResolvable;
+  failIfNotExists?: boolean;
+}
+
+export interface MessageReplyOptions extends Omit<MessageCreateOptions, 'reply'> {
+  failIfNotExists?: boolean;
+}
+
+export interface ResolvedOverwriteOptions {
+  allow: PermissionsBitField;
+  deny: PermissionsBitField;
+}
+
+export interface RoleData {
+  name?: string;
+  color?: ColorResolvable;
+  hoist?: boolean;
+  position?: number;
+  permissions?: PermissionResolvable;
+  mentionable?: boolean;
+  icon?: BufferResolvable | Base64Resolvable | EmojiResolvable | null;
+  unicodeEmoji?: string | null;
+}
+
+export type RoleMention = '@everyone' | `<@&${Snowflake}>`;
+
+export interface RolePosition {
+  role: RoleResolvable;
+  position: number;
+}
+
+export type RoleResolvable = Role | Snowflake;
+
+export interface RoleSubscriptionData {
+  roleSubscriptionListingId: Snowflake;
+  tierName: string;
+  totalMonthsSubscribed: number;
+  isRenewal: boolean;
+}
+
+export interface RoleTagData {
+  botId?: Snowflake;
+  integrationId?: Snowflake;
+  premiumSubscriberRole?: true;
+  subscriptionListingId?: Snowflake;
+  availableForPurchase?: true;
+  guildConnections?: true;
+}
+
+export interface SetChannelPositionOptions {
+  relative?: boolean;
+  reason?: string;
+}
+
+export interface SetParentOptions {
+  lockPermissions?: boolean;
+  reason?: string;
+}
+
+export interface SetRolePositionOptions {
+  relative?: boolean;
+  reason?: string;
+}
+
+export type ShardingManagerMode = 'process' | 'worker';
+
+export interface ShardingManagerOptions {
+  totalShards?: number | 'auto';
+  shardList?: number[] | 'auto';
+  mode?: ShardingManagerMode;
+  respawn?: boolean;
+  silent?: boolean;
+  shardArgs?: string[];
+  token?: string;
+  execArgv?: string[];
+}
+
+export { Snowflake };
+
+export type StageInstanceResolvable = StageInstance | Snowflake;
+
+export interface StartThreadOptions {
+  name: string;
+  autoArchiveDuration?: ThreadAutoArchiveDuration;
+  reason?: string;
+  rateLimitPerUser?: number;
+}
+
+export type ClientStatus = number;
+
+export type StickerResolvable = Sticker | Snowflake;
+
+export type SystemChannelFlagsResolvable = BitFieldResolvable<SystemChannelFlagsString, number>;
+
+export type StageChannelResolvable = StageChannel | Snowflake;
+
+export interface StageInstanceEditOptions {
+  topic?: string;
+  privacyLevel?: StageInstancePrivacyLevel;
+}
+
+export type SweeperKey = keyof SweeperDefinitions;
+
+export type CollectionSweepFilter<K, V> = (value: V, key: K, collection: Collection<K, V>) => boolean;
+
+export interface SweepOptions<K, V> {
+  interval: number;
+  filter: GlobalSweepFilter<K, V>;
+}
+
+export interface LifetimeSweepOptions {
+  interval: number;
+  lifetime: number;
+  filter?: never;
+}
+
+export interface SweeperDefinitions {
+  applicationCommands: [Snowflake, ApplicationCommand];
+  autoModerationRules: [Snowflake, AutoModerationRule];
+  bans: [Snowflake, GuildBan];
+  emojis: [Snowflake, GuildEmoji];
+  invites: [string, Invite, true];
+  guildMembers: [Snowflake, GuildMember];
+  messages: [Snowflake, Message, true];
+  presences: [Snowflake, Presence];
+  reactions: [string | Snowflake, MessageReaction];
+  stageInstances: [Snowflake, StageInstance];
+  stickers: [Snowflake, Sticker];
+  threadMembers: [Snowflake, ThreadMember];
+  threads: [Snowflake, AnyThreadChannel, true];
+  users: [Snowflake, User];
+  voiceStates: [Snowflake, VoiceState];
+}
+
+export type SweeperOptions = {
+  [K in keyof SweeperDefinitions]?: SweeperDefinitions[K][2] extends true
+    ? SweepOptions<SweeperDefinitions[K][0], SweeperDefinitions[K][1]> | LifetimeSweepOptions
+    : SweepOptions<SweeperDefinitions[K][0], SweeperDefinitions[K][1]>;
+};
+
+export interface LimitedCollectionOptions<K, V> {
+  maxSize?: number;
+  keepOverLimit?: (value: V, key: K, collection: LimitedCollection<K, V>) => boolean;
+}
+
+export type Channel =
+  | CategoryChannel
+  | DMChannel
+  | PartialDMChannel
+  | PartialGroupDMChannel
+  | NewsChannel
+  | StageChannel
+  | TextChannel
+  | AnyThreadChannel
+  | VoiceChannel
+  | ForumChannel;
+
+export type TextBasedChannel = Exclude<
+  Extract<Channel, { type: TextChannelType }>,
+  PartialGroupDMChannel | ForumChannel
+>;
+
+export type TextBasedChannelTypes = TextBasedChannel['type'];
+
+export type GuildTextBasedChannelTypes = Exclude<TextBasedChannelTypes, ChannelType.DM>;
+
+export type VoiceBasedChannel = Extract<Channel, { bitrate: number }>;
+
+export type GuildBasedChannel = Extract<Channel, { guild: Guild }>;
+
+export type CategoryChildChannel = Exclude<Extract<Channel, { parent: CategoryChannel | null }>, CategoryChannel>;
+
+export type NonThreadGuildBasedChannel = Exclude<GuildBasedChannel, AnyThreadChannel>;
+
+export type GuildTextBasedChannel = Extract<GuildBasedChannel, TextBasedChannel>;
+
+export type TextChannelResolvable = Snowflake | TextChannel;
+
+export type TextBasedChannelResolvable = Snowflake | TextBasedChannel;
+
+export type ThreadChannelResolvable = AnyThreadChannel | Snowflake;
+
+export type ThreadChannelType = ChannelType.AnnouncementThread | ChannelType.PublicThread | ChannelType.PrivateThread;
+
+export interface GuildTextThreadCreateOptions<AllowedThreadType> extends StartThreadOptions {
+  startMessage?: MessageResolvable;
+  type?: AllowedThreadType;
+  invitable?: AllowedThreadType extends ChannelType.PrivateThread ? boolean : never;
+}
+
+export interface GuildForumThreadCreateOptions extends StartThreadOptions {
+  message: GuildForumThreadMessageCreateOptions | MessagePayload;
+  appliedTags?: Snowflake[];
+}
+
+export interface ThreadEditOptions {
+  name?: string;
+  archived?: boolean;
+  autoArchiveDuration?: ThreadAutoArchiveDuration;
+  rateLimitPerUser?: number;
+  locked?: boolean;
+  invitable?: boolean;
+  appliedTags?: Snowflake[];
+  flags?: ChannelFlagsResolvable;
+  reason?: string;
+}
+
+export type ThreadMemberResolvable = ThreadMember | UserResolvable;
+
+export type UserMention = `<@${Snowflake}>`;
+
+export type UserResolvable = User | Snowflake | Message | GuildMember | ThreadMember;
+
+export interface Vanity {
+  code: string | null;
+  uses: number;
+}
+
+export type VoiceBasedChannelTypes = VoiceBasedChannel['type'];
+
+export type VoiceChannelResolvable = Snowflake | VoiceChannel;
+
+export interface VoiceStateEditOptions {
+  requestToSpeak?: boolean;
+  suppressed?: boolean;
+}
+
+export type WebhookClientData = WebhookClientDataIdWithToken | WebhookClientDataURL;
+
+export interface WebhookClientDataIdWithToken {
+  id: Snowflake;
+  token: string;
+}
+
+export interface WebhookClientDataURL {
+  url: string;
+}
+
+export type WebhookClientOptions = Pick<ClientOptions, 'allowedMentions' | 'rest'>;
+
+export interface WebhookDeleteOptions {
+  token?: string;
+  reason?: string;
+}
+
+export interface WebhookEditOptions {
+  name?: string;
+  avatar?: BufferResolvable | null;
+  channel?: GuildTextChannelResolvable | VoiceChannel | ForumChannel | StageChannel;
+  reason?: string;
+}
+
+export interface WebhookMessageEditOptions extends Omit<MessageEditOptions, 'flags'> {
+  threadId?: Snowflake;
+}
+
+export interface InteractionEditReplyOptions extends WebhookMessageEditOptions {
+  message?: MessageResolvable | '@original';
+}
+
+export interface WebhookFetchMessageOptions {
+  threadId?: Snowflake;
+}
+
+export interface WebhookMessageCreateOptions extends Omit<MessageCreateOptions, 'nonce' | 'reply' | 'stickers'> {
+  username?: string;
+  avatarURL?: string;
+  threadId?: Snowflake;
+  threadName?: string;
+}
+
+export interface WebSocketOptions {
+  large_threshold?: number;
+  version?: number;
+  buildStrategy?(manager: WSWebSocketManager): IShardingStrategy;
+  buildIdentifyThrottler?(manager: WSWebSocketManager): Awaitable<IIdentifyThrottler>;
+}
+
+export interface WidgetActivity {
+  name: string;
+}
+
+export interface WidgetChannel {
+  id: Snowflake;
+  name: string;
+  position: number;
+}
+
+export interface WelcomeChannelData {
+  description: string;
+  channel: TextChannel | NewsChannel | ForumChannel | Snowflake;
+  emoji?: EmojiIdentifierResolvable;
+}
+
+export interface WelcomeScreenEditOptions {
+  enabled?: boolean;
+  description?: string;
+  welcomeChannels?: WelcomeChannelData[];
+}
+
+export interface ClientApplicationInstallParams {
+  scopes: OAuth2Scopes[];
+  permissions: Readonly<PermissionsBitField>;
+}
+
+export type Serialized<T> = T extends symbol | bigint | (() => any)
+  ? never
+  : T extends number | string | boolean | undefined
+  ? T
+  : T extends { toJSON(): infer R }
+  ? R
+  : T extends ReadonlyArray<infer V>
+  ? Serialized<V>[]
+  : T extends ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+  ? {}
+  : { [K in keyof T]: Serialized<T[K]> };
+
+//#endregion
+
+//#region Voice
+
+/**
+ * @internal Use `DiscordGatewayAdapterLibraryMethods` from `@discordjs/voice` instead.
+ */
+export interface InternalDiscordGatewayAdapterLibraryMethods {
+  onVoiceServerUpdate(data: GatewayVoiceServerUpdateDispatchData): void;
+  onVoiceStateUpdate(data: GatewayVoiceStateUpdateDispatchData): void;
+  destroy(): void;
+}
+
+/**
+ * @internal Use `DiscordGatewayAdapterImplementerMethods` from `@discordjs/voice` instead.
+ */
+export interface InternalDiscordGatewayAdapterImplementerMethods {
+  sendPayload(payload: unknown): boolean;
+  destroy(): void;
+}
+
+/**
+ * @internal Use `DiscordGatewayAdapterCreator` from `@discordjs/voice` instead.
+ */
+export type InternalDiscordGatewayAdapterCreator = (
+  methods: InternalDiscordGatewayAdapterLibraryMethods,
+) => InternalDiscordGatewayAdapterImplementerMethods;
+
+//#endregion
+
+// External
+export * from 'discord-api-types/v10';
+export * from '@discordjs/builders';
+export * from '@discordjs/formatters';
+export * from '@discordjs/rest';
+export * from '@discordjs/util';
+export * from '@discordjs/ws';