discord.js-selfbot-v13/typings/index.d.ts

A unofficial discord.js fork for creating selfbots [Based on discord.js v13]

import {
  blockQuote,
  bold,
  channelMention,
  codeBlock,
  ContextMenuCommandBuilder,
  formatEmoji,
  hideLinkEmbed,
  hyperlink,
  inlineCode,
  italic,
  quote,
  roleMention,
  SlashCommandBuilder,
  spoiler,
  strikethrough,
  time,
  TimestampStyles,
  TimestampStylesString,
  underscore,
  userMention,
} from '@discordjs/builders';
import { Collection } from '@discordjs/collection';
import {
  APIActionRowComponent,
  APIApplicationCommandInteractionData,
  APIApplicationCommandOption,
  APIApplicationCommandPermission,
  APIAuditLogChange,
  APIButtonComponent,
  APIEmbed,
  APIEmoji,
  APIInteractionDataResolvedChannel,
  APIInteractionDataResolvedGuildMember,
  APIInteractionGuildMember,
  APIMessage,
  APIMessageActionRowComponent,
  APIMessageComponent,
  APIModalActionRowComponent,
  APIOverwrite,
  APIPartialChannel,
  APIPartialEmoji,
  APIPartialGuild,
  APIRole,
  APISelectMenuComponent,
  APITemplateSerializedSourceGuild,
  APIUser,
  GatewayVoiceServerUpdateDispatchData,
  GatewayVoiceStateUpdateDispatchData,
  MessageActivityType,
  RESTPostAPIApplicationCommandsJSONBody,
  Snowflake,
  LocalizationMap,
  LocaleString,
  APIGuildMember,
  APIChannel,
  TeamMemberRole,
  APIPoll,
  APIPollAnswer,
  GuildScheduledEventRecurrenceRuleWeekday,
  GuildScheduledEventRecurrenceRuleMonth,
  GuildScheduledEventRecurrenceRuleFrequency,
  APIChatInputApplicationCommandInteractionData,
  APIContextMenuInteractionData,
  ReactionType,
  VoiceChannelEffectSendAnimationType,
  GatewayVoiceChannelEffectSendDispatchData,
} from 'discord-api-types/v10';
import { ChildProcess, ChildProcessWithoutNullStreams } from 'node:child_process';
import { EventEmitter } from 'node:events';
import { AgentOptions } from 'node:https';
import { Response, ProxyAgent } from 'undici';
import { Readable, Writable, Stream } from 'node:stream';
import { MessagePort, Worker } from 'node:worker_threads';
import { authenticator } from 'otplib';
import { CookieJar } from 'tough-cookie';
import { RtpPacket } from 'werift-rtp';
import * as WebSocket from 'ws';
import {
  ActivityTypes,
  ApplicationCommandOptionTypes,
  ApplicationCommandPermissionTypes,
  ApplicationCommandTypes,
  AutoModerationActionTypes,
  AutoModerationRuleEventTypes,
  AutoModerationRuleKeywordPresetTypes,
  AutoModerationRuleTriggerTypes,
  ChannelTypes,
  DefaultMessageNotificationLevels,
  ExplicitContentFilterLevels,
  InteractionResponseTypes,
  InteractionTypes,
  InviteTargetTypes,
  MembershipStates,
  MessageButtonStyles,
  MessageComponentTypes,
  MessageComponentInteractables,
  MessageTypes,
  MFALevels,
  NSFWLevels,
  OverwriteTypes,
  PremiumTiers,
  PrivacyLevels,
  StickerFormatTypes,
  StickerTypes,
  TextInputStyles,
  VerificationLevels,
  WebhookTypes,
  GuildScheduledEventEntityTypes,
  GuildScheduledEventStatuses,
  GuildScheduledEventPrivacyLevels,
  VideoQualityModes,
  SortOrderTypes,
  ForumLayoutTypes,
  ApplicationRoleConnectionMetadataTypes,
  RelationshipTypes,
  SelectMenuComponentTypes,
  InviteTypes,
  PollLayoutTypes,
  ReactionTypes,
  MessageReferenceTypes,
  SeparatorSpacingSizes,
  ApplicationType,
} from './enums';
import {
  APIApplicationRoleConnectionMetadata,
  APIAutoModerationRule,
  GatewayAutoModerationActionExecutionDispatchData,
  RawActivityData,
  RawAnonymousGuildData,
  RawApplicationCommandData,
  RawApplicationData,
  RawBaseGuildData,
  RawChannelData,
  RawDMChannelData,
  RawEmojiData,
  RawGuildAuditLogData,
  RawGuildAuditLogEntryData,
  RawGuildBanData,
  RawGuildChannelData,
  RawGuildData,
  RawGuildEmojiData,
  RawGuildMemberData,
  RawGuildPreviewData,
  RawGuildScheduledEventData,
  RawGuildTemplateData,
  RawIntegrationApplicationData,
  RawIntegrationData,
  RawInteractionData,
  RawInviteData,
  RawInviteGuildData,
  RawInviteStageInstance,
  RawMessageAttachmentData,
  RawMessageButtonInteractionData,
  RawMessageComponentInteractionData,
  RawMessageData,
  RawMessagePayloadData,
  RawMessageReactionData,
  RawMessageSelectMenuInteractionData,
  RawModalSubmitInteractionData,
  RawOAuth2GuildData,
  RawPartialGroupDMChannelData,
  RawPartialMessageData,
  RawPermissionOverwriteData,
  RawPresenceData,
  RawReactionEmojiData,
  RawRichPresenceAssets,
  RawRoleData,
  RawStageInstanceData,
  RawStickerData,
  RawStickerPackData,
  RawTeamData,
  RawTeamMemberData,
  RawTextInputComponentData,
  RawThreadChannelData,
  RawThreadMemberData,
  RawTypingData,
  RawUserData,
  RawVoiceRegionData,
  RawVoiceStateData,
  RawWebhookData,
  RawWelcomeChannelData,
  RawWelcomeScreenData,
  RawWidgetData,
  RawWidgetMemberData,
  APIUnfurledMediaItem,
  APIContainerComponent,
  APIFileComponent,
  APISectionComponent,
  APISeparatorComponent,
  APIThumbnailComponent,
  APITextDisplayComponent,
  APIMediaGalleryComponent,
  APIMediaGalleryItem,
} from './rawDataTypes';
import { Socket } from 'node:dgram';

//#region Classes

// RPC by aiko-chan-ai
export interface RichButton {
  name: string;
  url: string;
}

export class RichPresence extends Activity {
  public constructor(client: Client, data?: object);
  public metadata: RichPresenceMetadata;
  public setAssetsLargeImage(image?: string): this;
  public setAssetsLargeText(text?: string): this;
  public setAssetsSmallImage(image?: string): this;
  public setAssetsSmallText(text?: string): this;
  public setName(name?: string): this;
  public setURL(url?: string): this;
  public setType(type?: ActivityType): this;
  public setApplicationId(id?: Snowflake): this;
  public setDetails(details?: string): this;
  public setState(state?: string): this;
  public setParty(party?: { max: number; current: number; id?: string }): this;
  public setStartTimestamp(timestamp: Date | number | null): this;
  public setEndTimestamp(timestamp: Date | number | null): this;
  public setButtons(...button: RichButton[]): this;
  public addButton(name: string, url: string): this;
  public setJoinSecret(join?: string): this;
  public setPlatform(platform?: ActivityPlatform): this;
  public static getExternal(client: Client, applicationId: Snowflake, ...images: string[]): Promise<ExternalAssets[]>;
}

export class DiscordAuthWebsocket extends EventEmitter {
  constructor();
  public token: string;
  public readonly user: {
    id: Snowflake;
    username: string;
    discriminator: number;
    avatar: string;
  };
  public readonly exprire: Date;
  public readonly AuthURL: string;
  public connect(client?: Client): Promise<void>;
  public destroy(): void;
  public generateQR(): void;
  public on(event: 'ready', listener: (client: this) => void): this;
  public on(event: 'finish', listener: (token: string) => void): this;
  public on(event: 'cancel' | 'pending', listener: (user: RawUserData) => void): this;
  public on(event: 'closed', listener: () => void): this;
  public on(event: string, listener: (...args: any[]) => Awaitable<void>): this;
}

export interface ExternalAssets {
  url: string;
  external_asset_path: string;
}

export interface RichPresenceMetadata {
  album_id?: string;
  artist_ids?: string[];
  context_uri?: string;
  button_urls?: string[];
}

export class SpotifyRPC extends RichPresence {
  public constructor(client: Client, data?: object);
  public setSongId(id: string): this;
  public addArtistId(id: string): this;
  public setArtistIds(...ids: string[]): this;
  public setAlbumId(id: string): this;
}

export class CustomStatus extends Activity {
  public constructor(client: Client, data?: object);
  public setEmoji(emoji?: EmojiIdentifierResolvable): this;
  public setState(state: string): this;
}

export class Activity {
  public constructor(presence: Presence, data?: RawActivityData);
  public readonly presence: Presence;
  public applicationId: Snowflake | null;
  public assets: RichPresenceAssets;
  public buttons: string[];
  public readonly createdAt: Date;
  public createdTimestamp: number;
  public details: string | null;
  public emoji: EmojiIdentifierResolvable | null;
  public flags: Readonly<ActivityFlags>;
  public id: string;
  public name: string;
  public party: {
    id: string | null;
    size: [number, number];
  } | null;
  public platform: ActivityPlatform | null;
  public sessionId: string | null;
  public state: string | null;
  public syncId: string | null;
  public timestamps: {
    start: number | null;
    end: number | null;
  } | null;
  public type: ActivityType;
  public url: string | null;
  public equals(activity: Activity): boolean;
  public toJSON(): ActivityOptions;
  public toString(): string;
}

export class ActivityFlags extends BitField<ActivityFlagsString> {
  public static FLAGS: Record<ActivityFlagsString, number>;
  public static resolve(bit?: BitFieldResolvable<ActivityFlagsString, number>): number;
}

export class PurchasedFlags extends BitField<PurchasedFlagsString> {
  public static FLAGS: Record<PurchasedFlagsString, number>;
  public static resolve(bit?: BitFieldResolvable<PurchasedFlagsString, number>): number;
}

export class PremiumUsageFlags extends BitField<PremiumUsageFlagsString> {
  public static FLAGS: Record<PremiumUsageFlagsString, number>;
  public static resolve(bit?: BitFieldResolvable<PremiumUsageFlagsString, number>): number;
}

export class InviteFlags extends BitField<InviteFlagsString> {
  public static FLAGS: Record<InviteFlagsString, number>;
  public static resolve(bit?: BitFieldResolvable<InviteFlagsString, number>): number;
}

export abstract class AnonymousGuild extends BaseGuild {
  protected constructor(client: Client, data: RawAnonymousGuildData, immediatePatch?: boolean);
  public banner: string | null;
  public description: string | null;
  public nsfwLevel: NSFWLevel;
  public premiumSubscriptionCount: number | null;
  public splash: string | null;
  public vanityURLCode: string | null;
  public verificationLevel: VerificationLevel;
  public bannerURL(options?: StaticImageURLOptions): string | null;
  public splashURL(options?: StaticImageURLOptions): string | null;
}

export abstract class Application extends Base {
  protected constructor(client: Client, data: RawApplicationData);
  public readonly createdAt: Date;
  public readonly createdTimestamp: number;
  public description: string | null;
  public icon: string | null;
  public id: Snowflake;
  public name: string | null;
  public termsOfServiceURL: string | null;
  public privacyPolicyURL: string | null;
  public verifyKey: string | null;
  public roleConnectionsVerificationURL: string | null;
  public approximateGuildCount: number | null;
  /** @deprecated */
  public botPublic: boolean | null;
  /** @deprecated */
  public botRequireCodeGrant: boolean | null;
  public commands: ApplicationCommandManager;
  public cover: string | null;
  public flags: Readonly<ApplicationFlags>;
  public guildId: Snowflake | null;
  public readonly guild: Guild | null;
  public tags: string[];
  public installParams: ClientApplicationInstallParams | null;
  public customInstallURL: string | null;
  public owner: User | Team | null;
  public readonly partial: boolean;
  public rpcOrigins: string[];
  public splash: string | null;
  public type: ApplicationType | null;
  public primarySkuId: Snowflake | null;
  public eulaId: Snowflake | null;
  public slug: string | null;
  public aliases: string[];
  public executables: { os: string; name: string; is_launcher: boolean }[] | null;
  public thirdPartySkus: { id: Snowflake | null; sku: string | null; distributor: string }[] | null;
  public hook: boolean | null;
  public overlay: boolean | null;
  public overlayMethods: number | null;
  public overlayWarn: boolean | null;
  public overlayCompatibilityHook: boolean | null;
  public bot: PartialUser | null;
  public developers: { id: Snowflake; name: string }[] | null;
  public publishers: { id: Snowflake; name: string }[] | null;
  public redirectUris: string[] | null;
  public deeplinkUri: string | null;
  public integrationPublic: boolean | null;
  public integrationRequireCodeGrant: boolean | null;
  public botDisabled: boolean | null;
  public botQuarantined: boolean | null;
  public approximateUserInstallCount: number | null;
  public approximateUserAuthorizationCount: number | null;
  public internalGuildRestriction: number | null;
  public interactionsEndpointUrl: string | null;
  public interactionsVersion: number | null;
  public interactionsEventTypes: string[] | null;
  public eventWebhooksStatus: number | null;
  public eventWebhooksUrl: string | null;
  public eventWebhooksTypes: string[] | null;
  public explicitContentFilter: number | null;
  public integrationTypesConfig: Record<
    number,
    { oauth2_install_params: ClientApplicationInstallParams | null }
  > | null;
  public isVerified: boolean | null;
  public verificationState: number | null;
  public storeApplicationState: number | null;
  public rpcApplicationState: number | null;
  public creatorMonetizationState: number | null;
  public isDiscoverable: boolean | null;
  public discoverabilityState: number | null;
  public discoveryEligibilityFlags: number | null;
  public isMonetized: boolean | null;
  public storefrontAvailable: boolean | null;
  public monetizationState: number | null;
  public monetizationEligibilityFlags: number | null;
  public maxParticipants: number | null;
  public fetch(): Promise<Application>;
  public fetchRoleConnectionMetadataRecords(): Promise<ApplicationRoleConnectionMetadata[]>;
  public coverURL(options?: StaticImageURLOptions): string | null;
  /** @deprecated This method is deprecated as it is unsupported and will be removed in the next major version. */
  public fetchAssets(): Promise<ApplicationAsset[]>;
  public iconURL(options?: StaticImageURLOptions): string | null;
  public toJSON(): unknown;
  public toString(): string | null;
}

export class ApplicationCommand<PermissionsFetchType = {}> extends Base {
  private constructor(client: Client, data: RawApplicationCommandData, guild?: Guild, guildId?: Snowflake);
  public applicationId: Snowflake;
  public readonly createdAt: Date;
  public readonly createdTimestamp: number;
  /** @deprecated Use {@link defaultMemberPermissions} and {@link dmPermission} instead. */
  public defaultPermission: boolean;
  public defaultMemberPermissions: Readonly<Permissions> | 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 readonly 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,
    PermissionsFetchType,
    Guild | null,
    Snowflake
  >;
  public type: ApplicationCommandType;
  public version: Snowflake;
  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>>;
  /** @deprecated Use {@link setDefaultMemberPermissions} and {@link setDMPermission} instead. */
  public setDefaultPermission(defaultPermission?: boolean): 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: ApplicationRoleConnectionMetadataTypes;
}

export type ApplicationResolvable = Application | Activity | Snowflake;

export type AutoModerationRuleResolvable = AutoModerationRule | Snowflake;

export class ApplicationFlags extends BitField<ApplicationFlagsString> {
  public static FLAGS: Record<ApplicationFlagsString, number>;
  public static resolve(bit?: BitFieldResolvable<ApplicationFlagsString, number>): number;
}

export abstract class Base {
  public constructor(client: Client);
  public readonly client: Client;
  public toJSON(...props: Record<string, boolean | string>[]): unknown;
  public valueOf(): string;
}

export class RESTManager {
  private constructor(client: Client);
  public readonly client: Client;
  public handlers: Collection<string, unknown>;
  public versioned: true;
  public cookieJar: CookieJar;
  public fetch: typeof globalThis.fetch;
  public getAuth(): string;
  public readonly api: unknown;
  public readonly cdn: unknown;
}

export class BaseClient extends EventEmitter {
  public constructor(options?: ClientOptions | WebhookClientOptions);
  public readonly api: RESTManager['api'];
  public rest: RESTManager;
  private decrementMaxListeners(): void;
  private incrementMaxListeners(): void;

  public on<K extends keyof BaseClientEvents>(
    event: K,
    listener: (...args: BaseClientEvents[K]) => Awaitable<void>,
  ): this;
  public on<S extends string | symbol>(
    event: Exclude<S, keyof BaseClientEvents>,
    listener: (...args: any[]) => Awaitable<void>,
  ): this;

  public once<K extends keyof BaseClientEvents>(
    event: K,
    listener: (...args: BaseClientEvents[K]) => Awaitable<void>,
  ): this;
  public once<S extends string | symbol>(
    event: Exclude<S, keyof BaseClientEvents>,
    listener: (...args: any[]) => Awaitable<void>,
  ): this;

  public emit<K extends keyof BaseClientEvents>(event: K, ...args: BaseClientEvents[K]): boolean;
  public emit<S extends string | symbol>(event: Exclude<S, keyof BaseClientEvents>, ...args: unknown[]): boolean;

  public off<K extends keyof BaseClientEvents>(
    event: K,
    listener: (...args: BaseClientEvents[K]) => Awaitable<void>,
  ): this;
  public off<S extends string | symbol>(
    event: Exclude<S, keyof BaseClientEvents>,
    listener: (...args: any[]) => Awaitable<void>,
  ): this;

  public removeAllListeners<K extends keyof BaseClientEvents>(event?: K): this;
  public removeAllListeners<S extends string | symbol>(event?: Exclude<S, keyof BaseClientEvents>): this;

  public options: ClientOptions | WebhookClientOptions;
  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 interface InteractionResponseFields<Cached extends CacheType = CacheType> {
  deferred: boolean;
  ephemeral: boolean | null;
  replied: boolean;
  webhook: InteractionWebhook;
  reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<GuildCacheMessage<Cached>>;
  reply(options: string | MessagePayload | InteractionReplyOptions): Promise<void>;
  deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
  editReply(options: string | MessagePayload | InteractionEditReplyOptions): Promise<GuildCacheMessage<Cached>>;
  deferReply(options: InteractionDeferReplyOptions & { fetchReply: true }): Promise<GuildCacheMessage<Cached>>;
  deferReply(options?: InteractionDeferReplyOptions): Promise<void>;
  fetchReply(message?: MessageResolvable | '@original'): Promise<GuildCacheMessage<Cached>>;
  followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<GuildCacheMessage<Cached>>;
}

export abstract class BaseCommandInteraction<Cached extends CacheType = CacheType> extends Interaction<Cached> {
  public readonly command: ApplicationCommand | ApplicationCommand<{ guild: GuildResolvable }> | null;
  public options: Omit<
    CommandInteractionOptionResolver<Cached>,
    | 'getMessage'
    | 'getFocused'
    | 'getMentionable'
    | 'getRole'
    | 'getNumber'
    | 'getInteger'
    | 'getString'
    | 'getChannel'
    | 'getBoolean'
    | 'getSubcommandGroup'
    | 'getSubcommand'
    | 'getAttachment'
  >;
  public channelId: Snowflake;
  public commandId: Snowflake;
  public commandName: string;
  public deferred: boolean;
  public ephemeral: boolean | null;
  public replied: boolean;
  public webhook: InteractionWebhook;
  public awaitModalSubmit(
    options: AwaitModalSubmitOptions<ModalSubmitInteraction>,
  ): Promise<ModalSubmitInteraction<Cached>>;
  public inGuild(): this is BaseCommandInteraction<'raw' | 'cached'>;
  public inCachedGuild(): this is BaseCommandInteraction<'cached'>;
  public inRawGuild(): this is BaseCommandInteraction<'raw'>;
  public deferReply(options: InteractionDeferReplyOptions & { fetchReply: true }): Promise<GuildCacheMessage<Cached>>;
  public deferReply(options?: InteractionDeferReplyOptions): Promise<void>;
  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
  public editReply(options: string | MessagePayload | InteractionEditReplyOptions): Promise<GuildCacheMessage<Cached>>;
  public fetchReply(message?: MessageResolvable | '@original'): Promise<GuildCacheMessage<Cached>>;
  public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<GuildCacheMessage<Cached>>;
  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<GuildCacheMessage<Cached>>;
  public reply(options: string | MessagePayload | InteractionReplyOptions): Promise<void>;
  public showModal(modal: Modal | ModalOptions): Promise<void>;
  private transformOption(
    option: APIApplicationCommandOption,
    resolved: Extract<
      APIApplicationCommandInteractionData,
      APIChatInputApplicationCommandInteractionData | APIContextMenuInteractionData
    >['resolved'],
  ): CommandInteractionOption<Cached>;
  private transformResolved(
    resolved: Extract<
      APIApplicationCommandInteractionData,
      APIChatInputApplicationCommandInteractionData | APIContextMenuInteractionData
    >['resolved'],
  ): CommandInteractionResolvedData<Cached>;
}

export abstract class BaseGuild extends Base {
  protected constructor(client: Client, data: RawBaseGuildData);
  public readonly createdAt: Date;
  public readonly createdTimestamp: number;
  public features: GuildFeatures[];
  public icon: string | null;
  public id: Snowflake;
  public name: string;
  public readonly nameAcronym: string;
  public readonly partnered: boolean;
  public readonly verified: boolean;
  public fetch(): Promise<Guild>;
  public iconURL(options?: ImageURLOptions): string | null;
  public toString(): string;
}

export class BaseGuildEmoji extends Emoji {
  protected constructor(client: Client, data: RawGuildEmojiData, guild: Guild | GuildPreview);
  public available: boolean | null;
  public readonly createdAt: Date;
  public readonly createdTimestamp: number;
  public guild: Guild | GuildPreview;
  public id: Snowflake;
  public managed: boolean | null;
  public requiresColons: boolean | null;
}

export class BaseGuildTextChannel extends TextBasedChannelMixin(GuildChannel) {
  protected constructor(guild: Guild, data?: RawGuildChannelData, client?: Client, immediatePatch?: boolean);
  public defaultAutoArchiveDuration?: ThreadAutoArchiveDuration;
  public defaultThreadRateLimitPerUser: number | null;
  public rateLimitPerUser: number | null;
  public nsfw: boolean;
  public threads: GuildTextThreadManager<AllowedThreadTypeForTextChannel | AllowedThreadTypeForNewsChannel>;
  public topic: string | null;
  public createInvite(options?: CreateInviteOptions): Promise<Invite>;
  public fetchInvites(cache?: boolean): Promise<Collection<string, Invite>>;
  public setDefaultAutoArchiveDuration(
    defaultAutoArchiveDuration: ThreadAutoArchiveDuration | 'MAX',
    reason?: string,
  ): Promise<this>;
  public setTopic(topic: string | null, reason?: string): Promise<this>;
  public setType(type: Pick<typeof ChannelTypes, 'GUILD_TEXT'>, reason?: string): Promise<TextChannel>;
  public setType(type: Pick<typeof ChannelTypes, 'GUILD_NEWS'>, reason?: string): Promise<NewsChannel>;
}

export class BaseGuildVoiceChannel extends TextBasedChannelMixin(GuildChannel, ['lastPinTimestamp', 'lastPinAt']) {
  public constructor(guild: Guild, data?: RawGuildChannelData);
  public readonly members: Collection<Snowflake, GuildMember>;
  public readonly full: boolean;
  public readonly joinable: boolean;
  public bitrate: number;
  public nsfw: boolean;
  public rtcRegion: string | null;
  public rateLimitPerUser: number | null;
  public userLimit: number;
  public videoQualityMode: VideoQualityMode | null;
  public status?: string;
  public createInvite(options?: CreateInviteOptions): Promise<Invite>;
  public setRTCRegion(rtcRegion: string | null, reason?: string): Promise<this>;
  public fetchInvites(cache?: boolean): Promise<Collection<string, Invite>>;
  public setBitrate(bitrate: number, reason?: string): Promise<VoiceChannel>;
  public setUserLimit(userLimit: number, reason?: string): Promise<VoiceChannel>;
  public setVideoQualityMode(videoQualityMode: VideoQualityMode | number, reason?: string): Promise<VoiceChannel>;
}

export class BaseMessageComponent {
  protected constructor(data?: BaseMessageComponent | BaseMessageComponentOptions);
  public type: MessageComponentType | null;
  public readonly id: number;
  public data: MessageComponentOptions;
  private static create(data: MessageComponentOptions, client?: Client | WebhookClient): MessageComponent | undefined;
  private static resolveType(type: MessageComponentTypeResolvable): MessageComponentType;
}

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: Record<string, 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, data: RawMessageButtonInteractionData);
  public readonly component: CacheTypeReducer<
    Cached,
    MessageButton,
    APIButtonComponent,
    MessageButton | APIButtonComponent,
    MessageButton | APIButtonComponent
  >;
  public componentType: 'BUTTON';
  public inGuild(): this is ButtonInteraction<'raw' | 'cached'>;
  public inCachedGuild(): this is ButtonInteraction<'cached'>;
  public inRawGuild(): this is ButtonInteraction<'raw'>;
}

export type KeyedEnum<K, T> = {
  [Key in keyof K]: T | string;
};

export type EnumValueMapped<E extends KeyedEnum<T, number>, T extends Partial<Record<keyof E, unknown>>> = T & {
  [Key in keyof T as E[Key]]: T[Key];
};

export type MappedChannelCategoryTypes = EnumValueMapped<
  typeof ChannelTypes,
  {
    GUILD_NEWS: NewsChannel;
    GUILD_VOICE: VoiceChannel;
    GUILD_TEXT: TextChannel;
    GUILD_STORE: StoreChannel;
    GUILD_STAGE_VOICE: StageChannel;
    GUILD_FORUM: ForumChannel;
    GUILD_MEDIA: MediaChannel;
  }
>;

export type CategoryChannelTypes = ExcludeEnum<
  typeof ChannelTypes,
  | 'DM'
  | 'GROUP_DM'
  | 'UNKNOWN'
  | 'GUILD_PUBLIC_THREAD'
  | 'GUILD_NEWS_THREAD'
  | 'GUILD_PRIVATE_THREAD'
  | 'GUILD_CATEGORY'
  | 'GUILD_DIRECTORY'
>;

export class CategoryChannel extends GuildChannel {
  public readonly children: Collection<Snowflake, Exclude<NonThreadGuildBasedChannel, CategoryChannel>>;
  public static parent: null;
  public parentId: null;
  public type: 'GUILD_CATEGORY';

  public createChannel<T extends Exclude<CategoryChannelTypes, 'GUILD_STORE' | ChannelTypes.GUILD_STORE>>(
    name: string,
    options: CategoryCreateChannelOptions & { type: T },
  ): Promise<MappedChannelCategoryTypes[T]>;
  /** @deprecated See [Self-serve Game Selling Deprecation](https://support-dev.discord.com/hc/en-us/articles/6309018858647) for more information */
  public createChannel(
    name: string,
    options: CategoryCreateChannelOptions & { type: 'GUILD_STORE' | ChannelTypes.GUILD_STORE },
  ): Promise<StoreChannel>;
  public createChannel(name: string, options?: CategoryCreateChannelOptions): Promise<TextChannel>;
}

export type CategoryChannelResolvable = Snowflake | CategoryChannel;

export abstract class Channel extends Base {
  public constructor(client: Client, data?: RawChannelData, immediatePatch?: boolean);
  public readonly createdAt: Date | null;
  public readonly createdTimestamp: number | null;
  /** @deprecated This will be removed in the next major version, see https://github.com/discordjs/discord.js/issues/7091 */
  public deleted: boolean;
  public id: Snowflake;
  public readonly partial: false;
  public type: keyof typeof ChannelTypes;
  public flags: Readonly<ChannelFlags> | null;
  public delete(): Promise<this>;
  public fetch(force?: boolean): Promise<this>;
  public isText(): this is TextBasedChannel;
  public isVoice(): this is BaseGuildVoiceChannel;
  public isThread(): this is ThreadChannel;
  public isDirectory(): this is DirectoryChannel;
  public isThreadOnly(): this is ThreadOnlyChannel;
  public toString(): ChannelMention;
}

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;
  public authenticator: typeof authenticator;
  private presence: ClientPresence;
  private _eval(script: string): unknown;
  private _validateOptions(options: ClientOptions): void;
  public channels: ChannelManager;
  public readonly emojis: BaseGuildEmojiManager;
  public guilds: GuildManager;
  public options: ClientOptions;
  public readyAt: If<Ready, Date>;
  public readonly readyTimestamp: If<Ready, number>;
  public sweepers: Sweepers;
  public shard: ShardClientUtil | null;
  public token: If<Ready, string, string | null>;
  public uptime: If<Ready, number>;
  public user: If<Ready, ClientUser>;
  public users: UserManager;
  public voice: ClientVoiceManager;
  public ws: WebSocketManager;
  public notes: UserNoteManager;
  public relationships: RelationshipManager;
  public voiceStates: VoiceStateManager;
  public sessions: SessionManager;
  public presences: PresenceManager;
  public billing: BillingManager;
  public settings: ClientUserSettingManager;
  public readonly sessionId: If<Ready, string, undefined>;
  public destroy(): 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 refreshAttachmentURL(...urls: string[]): Promise<{ original: string; refreshed: string }[]>;
  public sleep(timeout: number): Promise<void>;
  public login(token?: string): Promise<string>;
  /** @deprecated This method will not be updated until I find the most convenient way to implement MFA. */
  public passLogin(email: string, password: string): Promise<string | null>;
  public QRLogin(): Promise<void>;
  public logout(): Promise<void>;
  public isReady(): this is Client<true>;
  /** @deprecated Use {@link Sweepers#sweepMessages} instead */
  public sweepMessages(lifetime?: number): number;
  public toJSON(): unknown;
  public acceptInvite(
    invite: InviteResolvable,
    options?: AcceptInviteOptions,
  ): Promise<Guild | DMChannel | GroupDMChannel>;
  public redeemNitro(nitro: string, channel?: TextChannelResolvable, paymentSourceId?: Snowflake): Promise<any>;
  public authorizeURL(urlOAuth2: string, options?: OAuth2AuthorizeOptions): Promise<{ location: string }>;
  public installUserApps(applicationId: Snowflake): Promise<void>;
  public deauthorize(id: Snowflake, type?: 'application' | 'token'): Promise<void>;
  public authorizedApplications(): Promise<
    Collection<
      Snowflake,
      {
        application: Application;
        scopes: string[];
        authorizedApplicationId: Snowflake;
        deauthorize: () => Promise<void>;
      }
    >
  >;

  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 interface AcceptInviteOptions {
  bypassOnboarding: boolean;
  bypassVerify: boolean;
}

export type OAuth2AuthorizeOptions = {
  guild_id?: Snowflake;
  permissions?: string;
  authorize?: boolean;
  code?: string;
  webhook_channel_id?: Snowflake;
} & Record<string, unknown>;

export class ClientPresence extends Presence {
  private constructor(client: Client, data: RawPresenceData);
  private _parse(data: PresenceData): RawPresenceData;

  public set(presence: PresenceData): ClientPresence;
}

export class ClientUser extends User {
  public mfaEnabled: boolean;
  public readonly presence: ClientPresence;
  public verified: boolean;
  public edit(data: ClientUserEditData): Promise<this>;
  public setActivity(options?: ActivityOptions | RichPresence | SpotifyRPC | CustomStatus): 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, password: string): Promise<this>;
  public purchasedFlags: Readonly<PurchasedFlags>;
  public premiumUsageFlags: Readonly<PremiumUsageFlags>;
  public phone: string | null;
  public nsfwAllowed?: boolean;
  public email: string | null;
  public bio?: string;
  public pronouns?: string;
  public premiumType: number;
  public setBanner(banner: BufferResolvable | Base64Resolvable | null): Promise<this>;
  public setHypeSquad(
    hypesquad: 0 | 1 | 2 | 3 | 'LEAVE' | 'HOUSE_BRAVERY' | 'HOUSE_BRILLIANCE' | 'HOUSE_BALANCE',
  ): Promise<void>;
  public setAccentColor(color: ColorResolvable): Promise<this>;
  public setAboutMe(bio: string | null): Promise<this>;
  public createFriendInvite(): Promise<Invite>;
  public getAllFriendInvites(): Promise<Collection<string, Invite>>;
  public revokeAllFriendInvites(): Promise<void>;
  public setSamsungActivity(packageName: string, type: 'START' | 'UPDATE' | 'STOP'): Promise<this>;
  public stopRinging(channel: ChannelResolvable): Promise<void>;
  public fetchBurstCredit(): Promise<number>;
  public setPronouns(pronouns?: string | null): Promise<this>;
  public setGlobalName(globalName?: string | null): Promise<this>;
}

export class Options extends null {
  private constructor();
  public static defaultMakeCacheSettings: CacheWithLimitsOptions;
  public static 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>;
  public connection: VoiceConnection | null;

  public joinChannel(
    channel: VoiceBasedChannel | DMChannel | GroupDMChannel | Snowflake,
    config?: JoinChannelConfig,
  ): Promise<VoiceConnection>;
}

export interface JoinChannelConfig {
  selfMute?: boolean;
  selfDeaf?: boolean;
  selfVideo?: boolean;
  videoCodec?: VideoCodec;
}

export type VideoCodec = 'VP8' | 'H264';

export class VolumeInterface extends EventEmitter {
  constructor(options?: { volume?: number });
  public readonly volume: number;
  public readonly volumeDecibels: number;
  public readonly volumeEditable: boolean;
  public readonly volumeLogarithmic: number;
  public setVolume(volume: number): void;
  public setVolumeDecibels(db: number): void;
  public setVolumeLogarithmic(value: number): void;

  public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;

  public once(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
}

export function VolumeMixin<T>(base: Constructable<T>): Constructable<T & VolumeInterface>;

export type StreamType = 'unknown' | 'converted' | 'opus' | 'ogg/opus' | 'webm/opus';

export interface StreamOptions {
  type?: StreamType;
  seek?: number;
  volume?: number | boolean;
  plp?: number;
  fec?: boolean;
  bitrate?: number | 'auto';
  highWaterMark?: number;
}
export interface VideoOptions {
  seek?: number;
  highWaterMark?: number;
  fps?: number;
  hwAccel?: boolean;
  presetH26x?: 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow';
  inputFFmpegArgs?: string[];
  outputFFmpegArgs?: string[];
  bitrate?: number | 'auto';
}

export class BaseDispatcher extends Writable {
  constructor(
    player: object,
    highWaterMark?: number,
    payloadType?: number,
    extensionEnabled?: boolean,
    streams?: object,
  );
  public readonly paused: boolean;
  public pausedSince: number | null;
  public readonly pausedTime: number;
  public player: object;
  public readonly streamTime: number;
  public readonly totalStreamTime: number;
  public count: number;
  public sequence: number;
  public timestamp: number;
  public payloadType: number;
  public extensionEnabled: boolean;

  public pause(silence?: boolean): void;
  public resume(): void;

  public on(event: 'close' | 'drain' | 'finish' | 'start', listener: () => void): this;
  public on(event: 'debug', listener: (info: string) => void): this;
  public on(event: 'error', listener: (err: Error) => void): this;
  public on(event: 'pipe' | 'unpipe', listener: (src: Readable) => void): this;
  public on(event: 'speaking', listener: (speaking: boolean) => void): this;
  public on(event: string, listener: (...args: any[]) => void): this;

  public once(event: 'close' | 'drain' | 'finish' | 'start', listener: () => void): this;
  public once(event: 'debug', listener: (info: string) => void): this;
  public once(event: 'error', listener: (err: Error) => void): this;
  public once(event: 'pipe' | 'unpipe', listener: (src: Readable) => void): this;
  public once(event: 'speaking', listener: (speaking: boolean) => void): this;
  public once(event: string, listener: (...args: any[]) => void): this;
}

export class AudioDispatcher extends VolumeMixin(BaseDispatcher) {
  constructor(player: object, options?: StreamOptions, streams?: object);
  public readonly bitrateEditable: boolean;

  public getTypeDispatcher(): 'audio';

  public setBitrate(value: number | 'auto'): boolean;
  public setFEC(enabled: boolean): boolean;
  public setPLP(value: number): boolean;

  public setSyncVideoDispatcher(otherDispatcher: VideoDispatcher): void;

  public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
  public on(event: string, listener: (...args: any[]) => void): this;

  public once(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
  public once(event: string, listener: (...args: any[]) => void): this;
}

export class VideoDispatcher extends BaseDispatcher {
  constructor(player: object, options?: StreamOptions, streams?: object, fps?: number);

  public mtu: number;
  public fps: number;

  public getTypeDispatcher(): 'video';

  public setFPSSource(value: number): void;
}

export class VoiceConnection extends EventEmitter {
  constructor(voiceManager: ClientVoiceManager, channel: VoiceChannel);
  private authentication: object;
  private sockets: object;
  private ssrcMap: Map<number, boolean>;
  private _speaking: Map<Snowflake, Readonly<Speaking>>;
  private _disconnect(): void;
  private authenticate(): void;
  private authenticateFailed(reason: string): void;
  private checkAuthenticated(): void;
  private cleanup(): void;
  private connect(): void;
  private onReady(data: object): void;
  private onSessionDescription(mode: string, secret: string): void;
  private onSpeaking(data: object): void;
  private reconnect(token: string, endpoint: string): void;
  public sendVoiceStateUpdate(options: {
    self_video?: boolean;
    self_deaf?: boolean;
    self_mute?: boolean;
    guild_id?: Snowflake | null;
    channel_id?: Snowflake | null;
  }): Promise<Shard>;
  private setSessionId(sessionId: string): void;
  private setTokenAndEndpoint(token: string, endpoint: string): void;
  private updateChannel(channel: VoiceChannel): void;

  public channel: VoiceChannel;
  public readonly client: Client;
  public readonly dispatcher: AudioDispatcher;
  public readonly videoDispatcher?: VideoDispatcher;
  public player: object;
  public receiver: VoiceReceiver;
  public speaking: Readonly<Speaking>;
  public videoStatus: boolean;
  public status: VoiceStatus;
  public readonly voice: VoiceState | null;
  public voiceManager: ClientVoiceManager;
  public videoCodec: VideoCodec;
  public streamConnection: StreamConnection | null;
  public streamWatchConnection: Collection<Snowflake, StreamConnectionReadonly>;
  public disconnect(): void;
  public playAudio(input: Readable | string, options?: StreamOptions): AudioDispatcher;
  public playVideo(input: Readable | string, options?: VideoOptions): VideoDispatcher;
  public setSpeaking(value: BitFieldResolvable<SpeakingString, number>): void;
  public setVideoStatus(value: boolean): void;
  public setVideoCodec(value: VideoCodec): this;

  public on(event: 'authenticated' | 'closing' | 'newSession' | 'ready' | 'reconnecting', listener: () => void): this;
  public on(event: 'debug', listener: (message: string) => void): this;
  public on(event: 'error' | 'failed' | 'disconnect', listener: (error: Error) => void): this;
  public on(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
  public on(event: 'warn', listener: (warning: string | Error) => void): this;
  public on(event: 'streamUpdate', listener: (oldState: StreamState, newState: StreamState) => void): this;
  public on(event: string, listener: (...args: any[]) => void): this;

  public once(event: 'authenticated' | 'closing' | 'newSession' | 'ready' | 'reconnecting', listener: () => void): this;
  public once(event: 'debug', listener: (message: string) => void): this;
  public once(event: 'error' | 'failed' | 'disconnect', listener: (error: Error) => void): this;
  public once(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
  public once(event: 'warn', listener: (warning: string | Error) => void): this;
  public once(event: 'streamUpdate', listener: (oldState: StreamState, newState: StreamState) => void): this;
  public once(event: string, listener: (...args: any[]) => void): this;

  public createStreamConnection(): Promise<StreamConnection>;
  public joinStreamConnection(user: UserResolvable): Promise<StreamConnectionReadonly>;
}

export interface StreamState {
  isPaused: boolean;
  region: string | null;
  viewerIds: Snowflake[];
}

export class StreamConnection extends VoiceConnection {
  public createStreamConnection(): Promise<this>;
  public readonly voiceConnection: VoiceConnection;
  public serverId: Snowflake;
  public isPaused: boolean;
  public region: string | null;
  public streamConnection: this;
  public viewerIds: Snowflake[];
  public sendSignalScreenshare(): void;
  public sendScreenshareState(isPause: boolean): void;
  private sendStopScreenshare(): void;
  public readonly streamKey: string;
}

export class StreamConnectionReadonly extends VoiceConnection {
  public joinStreamConnection(): Promise<this>;
  public readonly voiceConnection: VoiceConnection;
  public serverId: Snowflake;
  public isPaused: boolean;
  public region: string | null;
  public userId: Snowflake;
  public streamConnection: null;
  public viewerIds: Snowflake[];
  public sendSignalScreenshare(): void;
  private sendStopScreenshare(): void;
  public readonly streamKey: string;
  /** @deprecated removed */
  public override playAudio(): AudioDispatcher;
  /** @deprecated removed */
  public override playVideo(): VideoDispatcher;
}

export class Recorder<Ready extends boolean = boolean, T = any> extends EventEmitter {
  constructor(receiver: T, options: { ffmpegArgs: string[]; channels: number; frameDuration: number });
  private promise: Promise<void>;
  public readonly receiver: T;
  public portUdpH264: number;
  public portUdpOpus: number;
  public ready: Ready;
  public stream: If<Ready, ChildProcessWithoutNullStreams>;
  public socket: Socket;
  public output: Writable | string;
  public userId: Snowflake;
  public feed(payload: RtpPacket | BufferResolvable): void;
  public on(event: 'ready' | 'closed', listener: (recorder: Recorder<true, T>) => void): this;
  public once(event: 'ready' | 'closed', listener: (recorder: Recorder<true, T>) => void): this;
  public destroy(): void;
}

export class VoiceReceiver extends EventEmitter {
  constructor(connection: VoiceConnection);
  public createStream(
    user: UserResolvable,
    options?: { mode?: 'opus' | 'pcm'; end?: 'silence' | 'manual'; paddingSilence?: boolean },
  ): Readable;
  public createVideoStream(user: UserResolvable, output: Writable | string): Recorder<false, any>;

  public on(event: 'debug', listener: (error: Error | string) => void): this;
  public on(
    event: 'receiverData',
    listener: (
      ssrcData: {
        userId: Snowflake;
        hasVideo: boolean;
      },
      packet: RtpPacket,
    ) => void,
  ): this;
  public on(event: string, listener: (...args: any[]) => void): this;

  public once(event: 'debug', listener: (error: Error | string) => void): this;
  public once(
    event: 'receiverData',
    listener: (
      ssrcData: {
        userId: Snowflake;
        hasVideo: boolean;
      },
      packet: RtpPacket,
    ) => void,
  ): this;
  public once(event: string, listener: (...args: any[]) => void): this;
}

export { Collection } from '@discordjs/collection';

export interface CollectorEventTypes<K, V, F extends unknown[] = []> {
  collect: [V, ...F];
  dispose: [V, ...F];
  end: [collected: Collection<K, V>, reason: strin