@wolfstar/http-framework 5.0.0-next-20260919094537 → 5.0.0

package/dist/esm/index.d.ts

@@ -1,6 +1,2322 @@
-import { $ as MessageComponentButtonInteraction, A as ClientEventName, At as applicationCommandRegistry, B as PartialMessage, Bt as extractTopLevelOptions, C as IIdParser, Ct as AsyncDiscordResult, D as ClientEventAutocompleteContext, Dt as CommandRegistry, E as HotModuleReloader, Et as NonPingInteraction, F as InteractionHandler, Ft as AutocompleteInteractionArguments, G as UserContextMenuCommandInteraction, Gt as RestrictGuildIds, H as UpdateResponseResult, Ht as transformInteraction, I as Command, It as ExtractedOptions, J as MessageComponentUserSelectInteraction, Jt as RegisterSubcommandGroup, K as ModalSubmitInteraction, Kt as restrictedGuildIdRegistry, L as CommandRouter, Lt as InteractionArguments, M as Events, Mt as CommandStore, N as MappedClientEvents, Nt as CommandStoreRouter, O as ClientEventCommandContext, Ot as ApplicationCommandRegistry, P as PluginHook, Pt as ArgumentTypes, Q as MessageComponentChannelSelectInteraction, R as makeInteraction, Rt as MakeArguments, S as preLoad, St as AddFiles, T as HMROptions, Tt as DiscordResult, U as Interaction, Ut as transformMessageInteraction, V as UpdateResponseOptions, Vt as transformAutocompleteInteraction, W as Interactions, Wt as transformUserInteraction, X as MessageComponentRoleSelectInteraction, Xt as RegisterMessageCommand, Y as MessageComponentStringSelectInteraction, Yt as RegisterSubcommand, Z as MessageComponentMentionableSelectInteraction, Zt as RegisterCommand, _ as Plugin, _t as UpdateOptions, a as LoadOptions, at as AutocompleteInteraction, b as preGenericsInitialization, bt as InGuild, c as ListenerStore, ct as DeferResponseData, d as AsyncPluginHooks, dt as FollowupOptions, et as MessageComponentInteraction, f as HttpFrameworkPluginAsyncHook, ft as MessageResponseData, g as SyncPluginHooks, gt as UpdateData, h as PluginManager, ht as ModalResponseOptions, i as ListenOptions, it as CommandInteraction, j as ClientEvents, jt as ApplicationCommandRegistryEntry, k as ClientEventInteractionHandlerContext, kt as RequestAuthPrefix, l as Listener, lt as DeferResponseOptions, m as HttpFrameworkPluginHookEntry, mt as ModalResponseData, n as ClientLoggerOptions, nt as ChatInputCommandInteraction, o as ILogger, ot as AutocompleteResponseData, p as HttpFrameworkPluginHook, pt as MessageResponseOptions, q as MessageContextMenuCommandInteraction, qt as RegisterUserCommand, r as ClientOptions, rt as BaseCommandInteractionType, s as LogLevel, st as AutocompleteResponseOptions, t as Client, tt as MessageComponentInteractionType, u as InteractionHandlerStore, ut as DeferUpdateResult, v as postInitialization, vt as BaseInteraction, w as IdParserRead, wt as DiscordError, x as preInitialization, xt as AbortError, y as postListen, yt as BaseInteractionType, z as Message, zt as TransformedArguments } from "./Client-Mni9tJr6.js";
-import { AliasPiece, AliasPieceOptions, AliasStore, LoaderError, LoaderPieceContext, LoaderPieceContext as LoaderPieceContext$1, LoaderStrategy, MissingExportsError, Piece, PieceContext, PieceOptions, PieceOptions as PieceOptions$1, Store, StoreOptions, StoreRegistry, StoreRegistryEntries, container } from "@sapphire/pieces";
-import { APIApplicationCommandSubcommandGroupOption, APIApplicationCommandSubcommandOption, ApplicationCommandOptionType, PermissionFlagsBits } from "discord-api-types/v10";
+import { AliasPiece, AliasPieceOptions, AliasStore, Container, LoaderError, LoaderPieceContext, LoaderPieceContext as LoaderPieceContext$1, LoaderStrategy, MissingExportsError, Piece, Piece as Piece$1, PieceContext, PieceOptions, PieceOptions as PieceOptions$1, Store, Store as Store$1, StoreOptions, StoreRegistry, StoreRegistryEntries, container } from "@sapphire/pieces";
+import { DiscordAPIError, HTTPError, REST, RESTOptions, RawFile, RequestData } from "@discordjs/rest";
+import { Awaitable, NonNullObject } from "@sapphire/utilities";
+import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
+import { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandAutocompleteResponse, APIApplicationCommandInteraction, APIApplicationCommandInteractionDataBasicOption, APIApplicationCommandInteractionDataOption, APIApplicationCommandInteractionDataSubcommandGroupOption, APIApplicationCommandInteractionDataSubcommandOption, APIApplicationCommandSubcommandGroupOption, APIApplicationCommandSubcommandOption, APIAttachment, APIBaseInteraction, APIChannel, APIChatInputApplicationCommandInteraction, APIChatInputApplicationCommandInteractionData, APIContextMenuInteractionData, APIGuild, APIInteraction, APIInteractionDataResolved, APIInteractionDataResolvedChannel, APIInteractionDataResolvedGuildMember, APIInteractionResponseChannelMessageWithSource, APIInteractionResponseDeferredChannelMessageWithSource, APIInteractionResponseDeferredMessageUpdate, APIInteractionResponseUpdateMessage, APIMessage, APIMessageApplicationCommandInteraction, APIMessageApplicationCommandInteractionData, APIMessageChannelSelectInteractionData, APIMessageComponentButtonInteraction, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageMentionableSelectInteractionData, APIMessageRoleSelectInteractionData, APIMessageStringSelectInteractionData, APIMessageUserSelectInteractionData, APIModalInteractionResponse, APIModalSubmitInteraction, APIPingInteraction, APIPrimaryEntryPointCommandInteraction, APIRole, APIUser, APIUserApplicationCommandInteraction, APIUserApplicationCommandInteractionData, ApplicationCommandOptionType, ApplicationCommandType, InteractionType, PermissionFlagsBits, RESTPatchAPIInteractionOriginalResponseJSONBody, RESTPatchAPIInteractionOriginalResponseResult, RESTPostAPIApplicationCommandsJSONBody, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, RESTPostAPIInteractionFollowupJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody, RESTPutAPIApplicationCommandsResult, RESTPutAPIApplicationGuildCommandsResult, Snowflake } from "discord-api-types/v10";
+import { IncomingMessage, Server, ServerOptions, ServerResponse } from "node:http";
+import { Result } from "@sapphire/result";
+import { Collection } from "@discordjs/collection";
+import { ContextMenuCommandBuilder, ContextMenuCommandType, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from "@discordjs/builders";
+import { JSONEncodable } from "@discordjs/util";
+import { webcrypto } from "node:crypto";
+import { ListenOptions as ListenOptions$1 } from "node:net";
+import { ChokidarOptions } from "chokidar";
+//#region src/lib/utils/internals.d.ts
+type Void = void;
+//#endregion
+//#region src/lib/interactions/resolvers/ChatInputCommandResolver.d.ts
+/**
+ * The command resolver for chat input commands.
+ * @internal
+ */
+declare class ChatInputCommandResolver implements JSONEncodable<ChatInputCommandResolver.ResolvedCommand> {
+  #private;
+  /**
+   * Sets the command data for the ChatInputCommandResolver.
+   *
+   * @param data - The command data to set.
+   * @returns The instance of ChatInputCommandResolver.
+   */
+  setCommand(data: ChatInputCommandResolver.CommandData): this;
+  /**
+   * Adds a subcommand group to the ChatInputCommandResolver.
+   *
+   * @param data - The data of the subcommand group.
+   * @param method - The method associated with the subcommand group (optional).
+   * @returns The updated ChatInputCommandResolver instance.
+   */
+  addSubcommandGroup(data: ChatInputCommandResolver.SubcommandGroupData, method?: string | null): this;
+  /**
+   * Adds a subcommand to the ChatInputCommandResolver.
+   *
+   * @param data - The data of the subcommand.
+   * @param method - The method of the subcommand (optional).
+   * @param groupName - The group name of the subcommand (optional).
+   * @returns The updated ChatInputCommandResolver instance.
+   */
+  addSubcommand(data: ChatInputCommandResolver.SubcommandData, method?: string | null, groupName?: string | null): this;
+  /**
+   * Converts the ChatInputCommandResolver instance to a JSON representation.
+   *
+   * @returns The JSON representation of the ChatInputCommandResolver instance.
+   */
+  toJSON(): ChatInputCommandResolver.ResolvedCommand;
+}
+declare namespace ChatInputCommandResolver {
+  type CommandDataResolvable = Omit<ResolvedCommand, 'type'> | JSONEncodable<ResolvedCommand>;
+  type CommandData = CommandDataResolvable | ((builder: SlashCommandBuilder) => CommandDataResolvable | Void);
+  type SubcommandGroupDataResolvable = Omit<ResolvedSubcommandGroup, 'type'> | JSONEncodable<ResolvedSubcommandGroup>;
+  type SubcommandGroupData = SubcommandGroupDataResolvable | ((builder: SlashCommandSubcommandGroupBuilder) => SubcommandGroupDataResolvable | Void);
+  type SubcommandDataResolvable = Omit<ResolvedSubcommand, 'type'> | JSONEncodable<ResolvedSubcommand>;
+  type SubcommandData = SubcommandDataResolvable | ((builder: SlashCommandSubcommandBuilder) => SubcommandDataResolvable | Void);
+  type ResolvedCommand = RESTPostAPIChatInputApplicationCommandsJSONBody;
+  type ResolvedSubcommandGroup = APIApplicationCommandSubcommandGroupOption;
+  type ResolvedSubcommand = APIApplicationCommandSubcommandOption;
+}
+//#endregion
+//#region src/lib/interactions/decorators/RegisterCommand.d.ts
+/**
+ * Registers a command for the chat input.
+ *
+ * @template Options - The options type for the command.
+ * @param data - The command data.
+ * @example
+ * ```typescript
+ * import { Command, RegisterCommand } from '@wolfstar/http-framework';
+ *
+ * (at)RegisterCommand({
+ * 	name: 'ping',
+ * 	description: 'A simple ping pong command'
+ * })
+ * export class UserCommand extends Command {
+ * 	public async run(interaction: Command.ChatInputInteraction) {
+ * 		return interaction.reply('Pong!');
+ * 	}
+ * }
+ * ```
+ */
+export declare function RegisterCommand<Options extends Command.Options = Command.Options>(data: ChatInputCommandResolver.CommandData): (target: typeof Command<Options>) => void;
+//#endregion
+//#region src/lib/interactions/resolvers/ContextMenuCommandResolver.d.ts
+/**
+ * The command resolver for context menu commands.
+ * @internal
+ */
+declare class ContextMenuCommandResolver implements JSONEncodable<ContextMenuCommandResolver.ResolvedCommand> {
+  #private;
+  /**
+   * Sets the command data, type, and method for the context menu command resolver.
+   *
+   * @param data - The command data.
+   * @param type - The command type.
+   * @param method - The command method (optional).
+   * @returns The updated context menu command resolver.
+   */
+  setCommand(data: ContextMenuCommandResolver.CommandData, type: ContextMenuCommandType, method?: string | null): this;
+  /**
+   * Converts the {@linkcode ContextMenuCommandResolver} instance to a JSON representation.
+   *
+   * @returns The JSON representation of the {@linkcode ContextMenuCommandResolver} instance.
+   */
+  toJSON(): ContextMenuCommandResolver.ResolvedCommand;
+}
+declare namespace ContextMenuCommandResolver {
+  type CommandDataResolvable = Omit<RESTPostAPIContextMenuApplicationCommandsJSONBody, 'type'> | JSONEncodable<RESTPostAPIContextMenuApplicationCommandsJSONBody>;
+  type CommandData = CommandDataResolvable | ((builder: ContextMenuCommandBuilder) => CommandDataResolvable | Void);
+  type ResolvedCommand = RESTPostAPIContextMenuApplicationCommandsJSONBody;
+}
+//#endregion
+//#region src/lib/interactions/decorators/RegisterMessageCommand.d.ts
+/**
+ * Registers a message command.
+ *
+ * @template Options - The options type for the command.
+ * @param data - The command to register.
+ * @returns A method decorator function, does not override the method.
+ * @example
+ * ```typescript
+ * export class UserCommand extends Command {
+ * 	(at)RegisterMessageCommand(createData())
+ * 	public run(interaction: Command.MessageInteraction, data: TransformedArguments.Message) {
+ * 		// ...
+ * 	}
+ * }
+ * ```
+ */
+export declare function RegisterMessageCommand<Options extends Command.Options = Command.Options>(data: ContextMenuCommandResolver.CommandData): (target: Command<Options>, method: string) => void;
+//#endregion
+//#region src/lib/interactions/decorators/RegisterSubcommand.d.ts
+/**
+ * Registers a subcommand for a chat input command.
+ *
+ * @remarks This decorator must be used in conjunction with {@link RegisterSubcommand}.
+ * @param data - The subcommand data.
+ * @param subCommandGroupName - Optional name of the subcommand group.
+ * @returns A decorator function that adds the subcommand to the target command.
+ * @example
+ * ```typescript
+ * import { Command, RegisterCommand, RegisterSubcommand, RegisterSubcommandGroup } from '@wolfstar/http-framework';
+ *
+ * (at)RegisterCommand({
+ * 	name: 'ping',
+ * 	description: 'A simple ping pong command'
+ * })
+ * export class UserCommand extends Command {
+ * 	(at)RegisterSubcommand({
+ * 		name: 'subcommand',
+ * 		description: 'A simple subcommand'
+ * 	})
+ * 	public async run(interaction: Command.ChatInputInteraction) {
+ * 		return interaction.reply('Pong!');
+ * 	}
+ * }
+ * ```
+ */
+export declare function RegisterSubcommand<Options extends Command.Options = Command.Options>(data: ChatInputCommandResolver.SubcommandData, subCommandGroupName?: string | null): (target: Command<Options>, method: string) => void;
+//#endregion
+//#region src/lib/interactions/decorators/RegisterSubcommandGroup.d.ts
+/**
+ * Registers a subcommand group for a chat input command.
+ *
+ * @remarks This decorator must be used in conjunction with {@link RegisterSubcommand}.
+ * @template Options - The options type for the command.
+ * @param data - The subcommand group data.
+ * @example
+ * ```typescript
+ * import { Command, RegisterCommand, RegisterSubcommand, RegisterSubcommandGroup } from '@wolfstar/http-framework';
+ *
+ * (at)RegisterCommand({
+ * 	name: 'ping',
+ * 	description: 'A simple ping pong command'
+ * })
+ * export class UserCommand extends Command {
+ * 	(at)RegisterSubcommandGroup({
+ * 		name: 'subcommand-group',
+ * 		description: 'A simple subcommand group'
+ * 	})
+ * 	(at)RegisterSubcommand(
+ * 		{ name: 'subcommand', description: 'A simple subcommand' },
+ * 		'subcommand-group'
+ * 	)
+ * 	public async run(interaction: Command.ChatInputInteraction) {
+ * 		return interaction.reply('Pong!');
+ * 	}
+ * }
+ * ```
+ */
+export declare function RegisterSubcommandGroup<Options extends Command.Options = Command.Options>(data: ChatInputCommandResolver.SubcommandGroupData): (target: Command<Options>, method: string) => void;
+//#endregion
+//#region src/lib/interactions/decorators/RegisterUserCommand.d.ts
+/**
+ * Registers a user command.
+ *
+ * @template Options - The options type for the command.
+ * @param data - The command to register.
+ * @returns A method decorator function, does not override the method.
+ * @example
+ * ```typescript
+ * export class UserCommand extends Command {
+ * 	(at)RegisterUserCommand(createData())
+ * 	public run(interaction: Command.UserInteraction, data: TransformedArguments.User) {
+ * 		// ...
+ * 	}
+ * }
+ * ```
+ */
+export declare function RegisterUserCommand<Options extends Command.Options = Command.Options>(data: ContextMenuCommandResolver.CommandData): (target: Command<Options>, method: string) => void;
+//#endregion
+//#region src/lib/interactions/decorators/RestrictGuildIds.d.ts
+export declare const restrictedGuildIdRegistry: Collection<typeof Command<Command.Options>, readonly string[]>;
+/**
+ * Decorator that restricts the guild IDs for a command.
+ *
+ * @param guildIds An array of guild IDs to restrict the command to.
+ * @returns A decorator function.
+ * @example
+ * ```typescript
+ * import { Command, RegisterCommand, RestrictGuildIds } from '@wolfstar/http-framework';
+ *
+ * (at)RegisterCommand({
+ * 	name: 'ping',
+ * 	description: 'A simple ping pong command'
+ * })
+ * (at)RestrictGuildIds(['123456789012345678', '123456789012345679'])
+ * export class UserCommand extends Command {
+ * 	public async run(interaction: Command.ChatInputInteraction) {
+ * 		return interaction.reply('Pong!');
+ * 	}
+ * }
+ * ```
+ */
+export declare function RestrictGuildIds<Options extends Command.Options = Command.Options>(guildIds: readonly string[]): (target: typeof Command<Options>) => void;
+//#endregion
+//#region src/lib/interactions/resolvers/InteractionOptions.d.ts
+export declare function transformInteraction<T extends NonNullObject>(resolved: APIInteractionDataResolved, options: readonly APIApplicationCommandInteractionDataOption[]): InteractionArguments<T>;
+export type InteractionArguments<T extends NonNullObject> = T & {
+  /**
+   * The name of the subcommand that was used by the user, if any.
+   */
+  subCommand: string | null;
+  /**
+   * The name of the subcommand group that was used by the user, if any.
+   */
+  subCommandGroup: string | null;
+};
+export declare function transformAutocompleteInteraction<T extends NonNullObject>(resolved: APIInteractionDataResolved, options: readonly APIApplicationCommandInteractionDataOption[]): AutocompleteInteractionArguments<T>;
+export type AutocompleteInteractionArguments<T extends NonNullObject> = InteractionArguments<T> & {
+  /**
+   * The name of the argument that is focused, if any.
+   */
+  focused: keyof T | null;
+};
+export declare function extractTopLevelOptions(options: readonly APIApplicationCommandInteractionDataOption[]): ExtractedOptions;
+export interface ExtractedOptions {
+  subCommandGroup: APIApplicationCommandInteractionDataSubcommandGroupOption | null;
+  subCommand: APIApplicationCommandInteractionDataSubcommandOption | null;
+  options: readonly APIApplicationCommandInteractionDataBasicOption[];
+}
+export declare function transformUserInteraction(data: APIUserApplicationCommandInteractionData): TransformedArguments.User;
+export declare function transformMessageInteraction(data: APIMessageApplicationCommandInteractionData): TransformedArguments.Message;
+export declare namespace TransformedArguments {
+  interface BasePartial {
+    id: string;
+  }
+  interface Message extends BasePartial {
+    message: APIMessage;
+  }
+  interface User extends BasePartial {
+    user: APIUser;
+    member: APIInteractionDataResolvedGuildMember | null;
+  }
+  type Channel = APIInteractionDataResolvedChannel;
+  type Role = APIRole;
+  type Attachment = APIAttachment;
+  type Mentionable = (BasePartial & User) | (BasePartial & {
+    channel: Channel;
+  }) | (BasePartial & {
+    role: Role;
+  }) | BasePartial;
+  type Any = User | Channel | Role | Mentionable | number | string | boolean | Attachment | PartialAny;
+  interface PartialUser extends Omit<User, 'user'> {
+    user: User['user'] | null;
+  }
+  type PartialAttachment = BasePartial;
+  type PartialChannel = BasePartial;
+  type PartialRole = BasePartial;
+  type PartialAny = PartialUser | PartialChannel | PartialRole | PartialAttachment;
+}
+/**
+ * A map of the argument types to their respective resolved values.
+ */
+export interface ArgumentTypes {
+  [ApplicationCommandOptionType.Attachment]: TransformedArguments.Attachment;
+  [ApplicationCommandOptionType.Boolean]: boolean;
+  [ApplicationCommandOptionType.Channel]: TransformedArguments.Channel;
+  [ApplicationCommandOptionType.Integer]: number;
+  [ApplicationCommandOptionType.Mentionable]: TransformedArguments.Mentionable;
+  [ApplicationCommandOptionType.Number]: number;
+  [ApplicationCommandOptionType.Role]: TransformedArguments.Role;
+  [ApplicationCommandOptionType.String]: string;
+  [ApplicationCommandOptionType.User]: TransformedArguments.User;
+  attachment: this[ApplicationCommandOptionType.Attachment];
+  boolean: this[ApplicationCommandOptionType.Boolean];
+  channel: this[ApplicationCommandOptionType.Channel];
+  integer: this[ApplicationCommandOptionType.Integer];
+  mentionable: this[ApplicationCommandOptionType.Mentionable];
+  number: this[ApplicationCommandOptionType.Number];
+  role: this[ApplicationCommandOptionType.Role];
+  string: this[ApplicationCommandOptionType.String];
+  user: this[ApplicationCommandOptionType.User];
+}
+/**
+ * Convenience type for creating arguments out of strings.
+ *
+ * @example
+ * ```typescript
+ * // Using named string:
+ * type Options = MakeArguments<{
+ * 	name: 'string';
+ * 	file: 'attachment';
+ * }>;
+ *
+ * // ➥ type Options = {
+ * //    	name: string;
+ * //    	attachment: APIAttachment;
+ * //    };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using named string:
+ * type Options = MakeArguments<{
+ * 	name: ApplicationCommandOptionType.String;
+ * 	file: ApplicationCommandOptionType.Attachment;
+ * }>;
+ *
+ * // ➥ type Options = {
+ * //    	name: string;
+ * //    	attachment: APIAttachment;
+ * //    };
+ * ```
+ */
+export type MakeArguments<T extends Record<string, keyof ArgumentTypes>> = { [K in keyof T]: ArgumentTypes[T[K]]; };
+//#endregion
+//#region src/lib/structures/CommandStoreRouter.d.ts
+/**
+ * Represents a router for mapping commands to chat inputs and context menus.
+ *
+ * @since 2.0.0
+ */
+export declare class CommandStoreRouter {
+  #private;
+  /**
+   * Gets the command associated with the given interaction.
+   *
+   * @since 2.0.0
+   * @param interaction - The interaction object.
+   * @returns The command associated with the interaction, or null if not found.
+   */
+  get(interaction: APIApplicationCommandInteraction): Command<import("@sapphire/pieces").PieceOptions> | null;
+  /**
+   * Gets the chat input command with the specified name.
+   *
+   * @since 2.0.0
+   * @param name - The name of the chat input command.
+   * @returns The chat input command with the specified name, or null if not found.
+   */
+  getChatInput(name: string): Command | null;
+  /**
+   * Gets the context menu command with the specified name.
+   *
+   * @since 2.0.0
+   * @param name - The name of the context menu command.
+   * @returns The context menu command with the specified name, or null if not found.
+   */
+  getContextMenu(name: string): Command | null;
+  /**
+   * Adds a chat input mapping.
+   *
+   * @since 2.0.0
+   * @param name - The name of the mapping.
+   * @param command - The command to be mapped.
+   * @internal
+   */
+  addChatInputMapping(name: string, command: Command): void;
+  /**
+   * Adds a context menu mapping.
+   *
+   * @since 2.0.0
+   * @param name - The name of the mapping.
+   * @param command - The command to be mapped.
+   * @internal
+   */
+  addContextMenuMapping(name: string, command: Command): void;
+  /**
+   * Removes a chat input mapping.
+   *
+   * @since 2.0.0
+   * @param name - The name of the mapping to be removed.
+   * @returns True if the mapping was successfully removed, false otherwise.
+   * @internal
+   */
+  removeChatInputMapping(name: string): boolean;
+  /**
+   * Removes a context menu mapping.
+   *
+   * @since 2.0.0
+   * @param name - The name of the mapping to be removed.
+   * @returns True if the mapping was successfully removed, false otherwise.
+   * @internal
+   */
+  removeContextMenuMapping(name: string): boolean;
+}
+//#endregion
+//#region src/lib/structures/CommandStore.d.ts
+export declare class CommandStore extends Store$1<Command, 'commands'> {
+  #private;
+  /**
+   * The router instance for handling commands in the CommandStore.
+   *
+   * @since 2.0.0
+   */
+  router: CommandStoreRouter;
+  constructor();
+  /**
+   * Runs an application command.
+   *
+   * @since 1.0.0
+   * @param response - The server response object.
+   * @param interaction - The API application command interaction object.
+   * @returns A promise that resolves to the server response.
+   */
+  runApplicationCommand(response: ServerResponse, interaction: Exclude<APIApplicationCommandInteraction, APIPrimaryEntryPointCommandInteraction>): Promise<ServerResponse>;
+  /**
+   * Runs the application command autocomplete.
+   *
+   * @since 1.0.0
+   * @param response - The server response object.
+   * @param interaction - The API application command autocomplete interaction object.
+   * @returns A promise that resolves to the server response.
+   */
+  runApplicationCommandAutocomplete(response: ServerResponse, interaction: APIApplicationCommandAutocompleteInteraction): Promise<ServerResponse>;
+}
+//#endregion
+//#region src/lib/interactions/shared/ApplicationCommandRegistryEntry.d.ts
+/**
+ * Represents an entry in the application command registry.
+ *
+ * This class provides methods to manage and manipulate application command data.
+ *
+ * @since 2.0.0
+ */
+export declare class ApplicationCommandRegistryEntry implements JSONEncodable<ApplicationCommandRegistryEntry.Command[]> {
+  #private;
+  /**
+   * Retrieves the loaded global ID of the {@linkcode ApplicationCommandRegistryEntry}.
+   *
+   * @since 2.0.0
+   * @returns The loaded global ID of the {@linkcode ApplicationCommandRegistryEntry}, or `null` if it's not set.
+   */
+  getGlobalId(): Snowflake | null;
+  /**
+   * Sets the loaded global ID for the {@linkcode ApplicationCommandRegistryEntry}.
+   *
+   * @since 2.0.0
+   * @param value - The Snowflake value to set as the global ID.
+   * @returns The updated {@linkcode ApplicationCommandRegistryEntry} instance.
+   */
+  setGlobalId(value: Snowflake): this;
+  /**
+   * Retrieves the loaded guild ID associated with the given guild ID.
+   *
+   * @since 2.0.0
+   * @param guildId The guild ID to retrieve.
+   * @returns The associated guild ID, or null if not found.
+   */
+  getGuildId(guildId: Snowflake): Snowflake | null;
+  /**
+   * Sets the loaded guild ID for the registry entry.
+   *
+   * @since 2.0.0
+   * @param guildId - The guild ID to set.
+   * @param value - The value to associate with the guild ID.
+   * @returns The updated registry entry.
+   */
+  setGuildId(guildId: Snowflake, value: Snowflake): this;
+  /**
+   * Gets the chat input command resolver.
+   *
+   * @since 2.0.0
+   * @returns The chat input command resolver or `null` if not set.
+   */
+  get chatInput(): ChatInputCommandResolver | null;
+  /**
+   * Gets the context menu commands associated with this registry entry.
+   *
+   * @since 2.0.0
+   * @returns An array of {@linkcode ContextMenuCommandResolver} objects representing the context menu commands.
+   */
+  get contextMenu(): ContextMenuCommandResolver[];
+  /**
+   * Converts the {@linkcode ApplicationCommandRegistryEntry} to a JSON representation.
+   *
+   * @since 2.0.0
+   * @returns An array of Command objects in JSON format.
+   */
+  toJSON(): ApplicationCommandRegistryEntry.Command[];
+  /**
+   * Creates a chat input command resolver.
+   * If the resolver has already been created, it returns the existing instance.
+   *
+   * @since 2.0.0
+   * @returns The chat input command resolver.
+   * @internal
+   */
+  makeChatInput(): ChatInputCommandResolver;
+  /**
+   * Creates a context menu command resolver and adds it to the context menu.
+   *
+   * @since 2.0.0
+   * @returns The created context menu command resolver.
+   * @internal
+   */
+  makeContextMenu(): ContextMenuCommandResolver;
+}
+export declare namespace ApplicationCommandRegistryEntry {
+  type Command = Exclude<RESTPostAPIApplicationCommandsJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody>;
+}
+//#endregion
+//#region src/lib/interactions/shared/ApplicationCommandRegistry.d.ts
+export type RequestAuthPrefix = RequestData['authPrefix'];
+/**
+ * Represents a registry for application commands.
+ *
+ * @remarks This registry is globally available through {@linkcode container.applicationCommandRegistry}.
+ * @since 2.0.0
+ */
+export declare class ApplicationCommandRegistry implements JSONEncodable<ApplicationCommandRegistryEntry.Command[]> {
+  #private;
+  get store(): CommandStore;
+  /**
+   * Sets up the application command registry with the provided options.
+   *
+   * @since 2.0.0
+   * @param options - The setup options for the application command registry.
+   * @returns The updated instance of the application command registry.
+   */
+  setup(options: Readonly<ApplicationCommandRegistry.SetupOptions>): this;
+  /**
+   * Retrieves the {@linkcode ApplicationCommandRegistryEntry} associated with the specified command class.
+   *
+   * @since 2.0.0
+   * @template Options - The options type of the command class.
+   * @param target - The command class to retrieve the entry for.
+   * @returns The {@linkcode ApplicationCommandRegistryEntry} associated with the command class, or null if not found.
+   */
+  get<Options extends Command.Options>(target: typeof Command<Options>): ApplicationCommandRegistryEntry | null;
+  /**
+   * Deletes a command from the registry.
+   *
+   * @since 2.0.0
+   * @template Options - The options type for the command.
+   * @param target - The command to delete.
+   * @returns True if the command was successfully deleted, false otherwise.
+   */
+  delete<Options extends Command.Options>(target: typeof Command<Options>): boolean;
+  /**
+   * Retrieves or creates an {@linkcode ApplicationCommandRegistryEntry} for the specified command class.
+   *
+   * @since 2.0.0
+   * @template Options - The options type for the command.
+   * @param target - The command class to ensure registration for.
+   * @returns The application command registry entry for the command.
+   */
+  ensure<Options extends Command.Options>(target: typeof Command<Options>): ApplicationCommandRegistryEntry;
+  /**
+   * Converts the {@linkcode ApplicationCommandRegistryEntry} objects to an array of command objects in JSON format.
+   *
+   * @since 2.0.0
+   * @returns An array of Command objects in JSON format.
+   */
+  toJSON(): ApplicationCommandRegistryEntry.Command[];
+  /**
+   * Loads the commands from the specified base user directory.
+   *
+   * @since 2.0.0
+   * @param baseUserDirectory - The base user directory to load the commands from, define it as `null` to not register
+   * a path for the file system loader.
+   * @returns A promise that resolves when all the commands are loaded.
+   */
+  loadCommands(baseUserDirectory?: string | URL | null): Promise<void>;
+  /**
+   * Retrieves the loaded chat input commands from the application command registry.
+   *
+   * @since 2.0.0
+   * @returns A collection of chat input commands.
+   */
+  getLoadedChatInputCommands(): Collection<string, ApplicationCommandRegistryEntry>;
+  /**
+   * Retrieves the loaded context menu commands.
+   *
+   * @since 2.0.0
+   * @returns A collection of context menu commands.
+   */
+  getLoadedContextMenuCommands(): Collection<string, ApplicationCommandRegistryEntry>;
+  /**
+   * Retrieves the loaded global commands from the application command registry.
+   *
+   * @since 2.0.0
+   * @returns An array of loaded global commands.
+   */
+  getLoadedGlobalCommands(): ApplicationCommandRegistryEntry.Command[];
+  /**
+   * Retrieves the loaded guild commands from the application command registry.
+   *
+   * @since 2.0.0
+   * @returns A collection of guild commands, where the key is the guild ID and the value is an array of commands.
+   */
+  getLoadedGuildCommands(): Collection<Snowflake, ApplicationCommandRegistryEntry.Command[]>;
+  /**
+   * Registers all the non guild-restricted commands globally.
+   *
+   * @since 2.0.0
+   * @returns The raw result from registering the commands globally.
+   */
+  pushGlobalCommands(): Promise<RESTPutAPIApplicationCommandsResult>;
+  /**
+   * Registers all the non guild-restricted commands in a single guild.
+   *
+   * @since 2.0.0
+   * @param guildId The guild to register the commands at.
+   * @returns The raw result from registering the commands in the specified guild.
+   */
+  pushGlobalCommandsInGuild(guildId: Snowflake): Promise<RESTPutAPIApplicationGuildCommandsResult>;
+  /**
+   * Registers all the commands including guild-restricted ones in a single guild.
+   *
+   * @param guildId The guild to register the commands at.
+   * @returns The raw result from registering the commands in the specified guild.
+   */
+  pushAllCommandsInGuild(guildId: Snowflake): Promise<RESTPutAPIApplicationGuildCommandsResult>;
+  /**
+   * Registers all the guild-restricted commands in their respective guilds.
+   *
+   * @returns The settled promises from all the guild command registrations.
+   */
+  pushGuildRestrictedCommands(): Promise<PromiseSettledResult<RESTPutAPIApplicationGuildCommandsResult>[]>;
+  private get clientId();
+}
+export declare namespace ApplicationCommandRegistry {
+  interface SetupOptions {
+    rest: REST;
+    clientId: Snowflake;
+    authPrefix?: RequestAuthPrefix;
+  }
+}
+export declare const applicationCommandRegistry: ApplicationCommandRegistry;
+//#endregion
+//#region src/lib/interactions/shared/CommandRegistry.d.ts
+/**
+ * A per-command registry passed to {@linkcode Command.registerApplicationCommands}, allowing commands to be
+ * registered imperatively, without relying on decorators.
+ *
+ * @remarks This is the decorator-free equivalent of {@link RegisterCommand}, {@link RegisterSubcommand},
+ * {@link RegisterSubcommandGroup}, {@link RegisterMessageCommand}, {@link RegisterUserCommand}, and
+ * {@link RestrictGuildIds}; both approaches can be used interchangeably as they share the same underlying
+ * {@linkcode ApplicationCommandRegistryEntry}.
+ * @since 3.1.0
+ */
+export declare class CommandRegistry<Options extends Command.Options = Command.Options> {
+  #private;
+  constructor(target: typeof Command<Options>);
+  /**
+   * Registers the chat input (slash) command for this command.
+   *
+   * @since 3.1.0
+   * @param data - The command data.
+   * @returns This registry, for chaining.
+   * @example
+   * ```typescript
+   * public override registerApplicationCommands(registry: Command.Registry) {
+   * 	registry.registerChatInputCommand((builder) =>
+   * 		builder.setName('ping').setDescription('A simple ping pong command')
+   * 	);
+   * }
+   * ```
+   */
+  registerChatInputCommand(data: ChatInputCommandResolver.CommandData): this;
+  /**
+   * Registers a subcommand for the chat input command of this command.
+   *
+   * @since 3.1.0
+   * @param data - The subcommand data.
+   * @param method - The name of the method that handles this subcommand.
+   * @param groupName - The name of the subcommand group this subcommand belongs to, if any.
+   * @returns This registry, for chaining.
+   */
+  registerSubcommand(data: ChatInputCommandResolver.SubcommandData, method: string, groupName?: string | null): this;
+  /**
+   * Registers a subcommand group for the chat input command of this command.
+   *
+   * @since 3.1.0
+   * @param data - The subcommand group data.
+   * @param method - The name of the method that handles this subcommand group, if any.
+   * @returns This registry, for chaining.
+   */
+  registerSubcommandGroup(data: ChatInputCommandResolver.SubcommandGroupData, method?: string | null): this;
+  /**
+   * Registers a context menu command for this command.
+   *
+   * @since 3.1.0
+   * @param data - The command data.
+   * @param type - The type of context menu command to register.
+   * @param method - The name of the method that handles this context menu command, if any.
+   * @returns This registry, for chaining.
+   */
+  registerContextMenuCommand(data: ContextMenuCommandResolver.CommandData, type: ApplicationCommandType.Message | ApplicationCommandType.User, method?: string | null): this;
+  /**
+   * Registers a "Message" context menu command for this command.
+   *
+   * @since 3.1.0
+   * @param data - The command data.
+   * @param method - The name of the method that handles this context menu command, if any.
+   * @returns This registry, for chaining.
+   */
+  registerMessageCommand(data: ContextMenuCommandResolver.CommandData, method?: string | null): this;
+  /**
+   * Registers a "User" context menu command for this command.
+   *
+   * @since 3.1.0
+   * @param data - The command data.
+   * @param method - The name of the method that handles this context menu command, if any.
+   * @returns This registry, for chaining.
+   */
+  registerUserCommand(data: ContextMenuCommandResolver.CommandData, method?: string | null): this;
+  /**
+   * Restricts this command to the given guild IDs, so it is only registered there instead of globally.
+   *
+   * @since 3.1.0
+   * @param guildIds - The guild IDs to restrict this command to.
+   * @returns This registry, for chaining.
+   */
+  setGuildIds(guildIds: readonly string[]): this;
+}
+//#endregion
+//#region src/lib/interactions/utils/util-types.d.ts
+type DiscordResult<T> = Result<T, DiscordError>;
+type AsyncDiscordResult<T> = Promise<DiscordResult<T>>;
+type AddFiles<T> = T & {
+  files?: RawFile[];
+};
+type AbortError = Error & {
+  name: 'AbortError';
+};
+type DiscordError = HTTPError | DiscordAPIError | AbortError;
+type NonPingInteraction = Exclude<APIInteraction, APIPingInteraction>;
+//#endregion
+//#region src/lib/interactions/structures/common/symbols.d.ts
+declare const Data: unique symbol;
+declare const Response$1: unique symbol;
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/BaseInteraction.d.ts
+export type BaseInteractionType = Exclude<APIInteraction, APIPingInteraction>;
+export declare abstract class BaseInteraction<T extends BaseInteractionType = BaseInteractionType> {
+  protected readonly [Data]: T;
+  protected readonly [Response$1]: ServerResponse;
+  constructor(response: ServerResponse, data: T);
+  get replied(): boolean;
+  /**
+   * The ID of the interaction.
+   */
+  get id(): T['id'];
+  /**
+   * The type of the interaction.
+   */
+  get type(): T['type'];
+  /**
+   * Bitwise set of permissions the app or bot has within the channel the interaction was sent from.
+   */
+  get app_permissions(): T['app_permissions'];
+  /**
+   * Bitwise set of permissions the app or bot has within the channel the interaction was sent from.
+   *
+   * @seealso {@link app_permissions} for the raw data.
+   */
+  get applicationPermissions(): bigint | undefined;
+  /**
+   * The ID of the application the interaction is for.
+   */
+  get application_id(): T['application_id'];
+  /**
+   * The ID of the application the interaction is for.
+   *
+   * @seealso {@link application_id} for the raw data.
+   */
+  get applicationId(): T['application_id'];
+  /**
+   * Mapping of installation contexts that the interaction was authorized for
+   * to related user or guild IDs.
+   */
+  get authorizing_integration_owners(): T['authorizing_integration_owners'];
+  /**
+   * Mapping of installation contexts that the interaction was authorized for
+   * to related user or guild IDs.
+   *
+   * @seealso {@link authorizing_integration_owners} for the raw data.
+   */
+  get authorizingIntegrationOwners(): T['authorizing_integration_owners'];
+  /**
+   * The channel of the interaction.
+   */
+  get channel(): T['channel'];
+  /**
+   * The channel the interaction was sent from.
+   * @deprecated Use {@link channel}.id instead.
+   */
+  get channel_id(): T['channel_id'];
+  /**
+   * The channel the interaction was sent from.
+   * @deprecated Use {@link channel}.id instead.
+   *
+   * @seealso {@link channel_id} for the raw data.
+   */
+  get channelId(): T['channel_id'];
+  /**
+   * Context where the interaction was triggered from.
+   */
+  get context(): T['context'];
+  /**
+   * The command data payload.
+   */
+  get data(): T['data'];
+  /**
+   * For monetized apps, any entitlements for the invoking user, representing
+   * access to premium SKUs.
+   */
+  get entitlements(): T['entitlements'];
+  /**
+   * The guild the interaction was sent from.
+   */
+  get guild_id(): T['guild_id'];
+  /**
+   * The guild the interaction was sent from.
+   *
+   * @seealso {@link guild_id} for the raw data.
+   */
+  get guildId(): T['guild_id'];
+  /**
+   * The guild's preferred locale, if invoked in a guild.
+   */
+  get guild_locale(): T['guild_locale'];
+  /**
+   * The guild's preferred locale, if invoked in a guild.
+   *
+   * @seealso {@link guild_locale} for the raw data.
+   */
+  get guildLocale(): T['guild_locale'];
+  /**
+   * The selected language of the invoking user.
+   */
+  get locale(): T['locale'];
+  /**
+   * Guild member data for the invoking user, including permissions.
+   *
+   * **This is only sent when an interaction is invoked in a guild**.
+   */
+  get member(): T['member'];
+  /**
+   * A continuation token for responding to the interaction.
+   */
+  get token(): T['token'];
+  /**
+   * User object for the invoking user.
+   */
+  get user(): import("discord-api-types/v10").APIUser;
+  /**
+   * Read-only property, always `1`.
+   */
+  get version(): T['version'];
+  /**
+   * Determines whether or not the interaction was sent from a guild.
+   * @returns The casted interaction type.
+   */
+  inGuild(): this is InGuild<this>;
+  /**
+   * Fetches the channel the interaction was sent from.
+   * @returns The fetched channel.
+   * @remarks **This requires REST to have a token.**
+   * @seealso {@link channel}.
+   */
+  fetchChannel(): Promise<Result.Err<Error> | DiscordResult<APIChannel>>;
+  /**
+   * Fetches the channel the interaction was sent from.
+   * @returns The fetched channel.
+   * @remarks **This requires REST to have a token.**
+   */
+  fetchGuild(): Promise<Result.Err<Error> | DiscordResult<APIGuild>>;
+  protected _sendReply(data: NonNullObject): Promise<void>;
+}
+export type InGuild<T extends BaseInteraction> = T & {
+  get guild_id(): NonNullable<T['guild_id']>;
+  get guildId(): NonNullable<T['guildId']>;
+  get guild_locale(): NonNullable<T['guild_locale']>;
+  get guildLocale(): NonNullable<T['guildLocale']>;
+  get member(): NonNullable<T['member']>;
+};
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/common.d.ts
+export type AutocompleteResponseData = APIApplicationCommandAutocompleteResponse;
+export type AutocompleteResponseOptions = AutocompleteResponseData['data'];
+export type MessageResponseData = APIInteractionResponseChannelMessageWithSource;
+export type MessageResponseOptions = MessageResponseData['data'];
+export type DeferResponseData = APIInteractionResponseDeferredChannelMessageWithSource;
+export type DeferResponseOptions = DeferResponseData['data'];
+export type ModalResponseData = APIModalInteractionResponse;
+export type ModalResponseOptions = ModalResponseData['data'];
+export type FollowupOptions = AddFiles<RESTPostAPIInteractionFollowupJSONBody>;
+export type DeferUpdateResult = APIInteractionResponseDeferredMessageUpdate;
+export type UpdateData = APIInteractionResponseUpdateMessage;
+export type UpdateOptions = UpdateData['data'];
+//#endregion
+//#region src/lib/interactions/structures/interactions/AutocompleteInteraction.d.ts
+declare class AutocompleteInteraction$1 extends BaseInteraction<AutocompleteInteraction$1.Type> {
+  /**
+   * Responds to the interaction with an autocomplete result.
+   * @param data The data to be sent.
+   */
+  reply(data: AutocompleteResponseOptions): Promise<void>;
+  /**
+   * Responds to the interaction with an empty autocomplete result.
+   */
+  replyEmpty(): Promise<void>;
+}
+declare namespace AutocompleteInteraction$1 {
+  type Type = APIApplicationCommandAutocompleteInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/CommandInteraction.d.ts
+export type BaseCommandInteractionType = APIChatInputApplicationCommandInteraction | APIUserApplicationCommandInteraction | APIMessageApplicationCommandInteraction;
+export declare class CommandInteraction<T extends BaseCommandInteractionType> extends BaseInteraction<T> {
+  /**
+   * Responds to the interaction with a message.
+   * @param data The data to be sent.
+   */
+  reply(data: MessageResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * ACK an interaction and edit a response later. The user sees a loading state.
+   * @param data The data to be sent, if any.
+   */
+  defer(data?: DeferResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * Responds to the interaction with a popup modal.
+   * @param data The data to be sent.
+   */
+  showModal(data: ModalResponseOptions): Promise<void>;
+  /**
+   * Sends a follow-up message.
+   * @param data The data to be sent.
+   */
+  followup({ files, ...body }: FollowupOptions): AsyncDiscordResult<Message<this>>;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/ChatInputCommandInteraction.d.ts
+export declare class ChatInputCommandInteraction extends CommandInteraction<ChatInputCommandInteraction.Type> {}
+export declare namespace ChatInputCommandInteraction {
+  type Type = APIChatInputApplicationCommandInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/MessageComponentInteraction.d.ts
+export type MessageComponentInteractionType = APIMessageComponentButtonInteraction | APIMessageComponentSelectMenuInteraction;
+export declare abstract class MessageComponentInteraction<T extends MessageComponentInteractionType> extends BaseInteraction<T> {
+  /**
+   * The message the interaction was attached to.
+   */
+  get message(): import("discord-api-types/v10").APIMessage;
+  /**
+   * ACK a button interaction and update it to a loading state.
+   */
+  deferUpdate(): Promise<PartialMessage<this>>;
+  /**
+   * ACK an interaction and edit a response later. The user sees a loading state.
+   * @param data The data to be sent, if any.
+   */
+  update(data?: UpdateOptions): Promise<PartialMessage<this>>;
+  /**
+   * Responds to the interaction with a message.
+   * @param data The data to be sent.
+   */
+  reply(data: MessageResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * ACK an interaction and edit a response later. The user sees a loading state.
+   * @param data The data to be sent, if any.
+   */
+  defer(data?: DeferResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * Responds to the interaction with a popup modal.
+   * @param data The data to be sent.
+   */
+  showModal(data: ModalResponseOptions): Promise<void>;
+  /**
+   * Sends a follow-up message.
+   * @param data The data to be sent.
+   */
+  followup({ files, ...body }: FollowupOptions): AsyncDiscordResult<Message<this>>;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentButtonInteraction.d.ts
+export declare class MessageComponentButtonInteraction extends MessageComponentInteraction<MessageComponentButtonInteraction.Type> {}
+export declare namespace MessageComponentButtonInteraction {
+  type Type = APIMessageComponentButtonInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentChannelSelectInteraction.d.ts
+export declare class MessageComponentChannelSelectInteraction extends MessageComponentInteraction<MessageComponentChannelSelectInteraction.Type> {
+  /**
+   * Gets the IDs of the selected channels.
+   */
+  get ids(): Snowflake[];
+  /**
+   * Creates a collection with all the selected channels.
+   *
+   * @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.values}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+   */
+  get channels(): Collection<Snowflake, MessageComponentChannelSelectInteraction.Value>;
+  /**
+   * Returns an iterator of the selected channel IDs.
+   *
+   * @seealso {@link MessageComponentChannelSelectInteraction.ids}.
+   */
+  keys(): IterableIterator<Snowflake>;
+  /**
+   * Returns an iterator of the selected channels.
+   *
+   * @seealso {@link MessageComponentChannelSelectInteraction.channels}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+   */
+  values(): IterableIterator<MessageComponentChannelSelectInteraction.Value>;
+  /**
+   * Returns an iterator of [ID, Channel] pairs.
+   *
+   * @seealso {@link MessageComponentChannelSelectInteraction.channels}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.values}.
+   */
+  entries(): IterableIterator<[Snowflake, MessageComponentChannelSelectInteraction.Value]>;
+}
+export declare namespace MessageComponentChannelSelectInteraction {
+  type Base = APIBaseInteraction<InteractionType.MessageComponent, APIMessageChannelSelectInteractionData>;
+  export type Type = Base & Required<Pick<Base, 'channel' | 'channel_id' | 'data' | 'app_permissions' | 'message'>>;
+  export type Value = TransformedArguments.Channel;
+  export {};
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentMentionableSelectInteraction.d.ts
+export declare class MessageComponentMentionableSelectInteraction extends MessageComponentInteraction<MessageComponentMentionableSelectInteraction.Type> {
+  /**
+   * Gets the IDs of the selected users and roles.
+   */
+  get ids(): Snowflake[];
+  /**
+   * Creates a collection with all the selected users.
+   *
+   * @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.entries}.
+   */
+  get users(): Collection<Snowflake, MessageComponentMentionableSelectInteraction.ValueUser>;
+  /**
+   * Creates a collection with all the selected roles.
+   *
+   * @note The collection will always be empty if the interaction came from direct messages.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.entries}.
+   */
+  get roles(): Collection<Snowflake, APIRole>;
+  /**
+   * Creates a collection with all the selected users, members, and roles.
+   *
+   * @note The collection will always be empty if the interaction came from direct messages.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.entries}.
+   */
+  get mentionables(): Collection<Snowflake, MessageComponentMentionableSelectInteraction.Value>;
+  /**
+   * Returns an iterator of the selected users and roles IDs.
+   *
+   * @seealso {@link MessageComponentMentionableSelectInteraction.ids}.
+   */
+  keys(): IterableIterator<Snowflake>;
+  /**
+   * Returns an iterator of the selected users, members, and roles.
+   *
+   * @seealso {@link MessageComponentMentionableSelectInteraction.users}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.roles}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.entries}.
+   */
+  values(): IterableIterator<MessageComponentMentionableSelectInteraction.Value>;
+  /**
+   * Returns an iterator of [ID, Mentionable] pairs.
+   *
+   * @seealso {@link MessageComponentMentionableSelectInteraction.users}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.roles}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+   * @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+   */
+  entries(): IterableIterator<[Snowflake, MessageComponentMentionableSelectInteraction.Value]>;
+}
+export declare namespace MessageComponentMentionableSelectInteraction {
+  type Base = APIBaseInteraction<InteractionType.MessageComponent, APIMessageMentionableSelectInteractionData>;
+  export type Type = Base & Required<Pick<Base, 'channel' | 'channel_id' | 'data' | 'app_permissions' | 'message'>>;
+  export type Value = ValueUser | {
+    id: string;
+    role: TransformedArguments.Role;
+  } | {
+    id: string;
+  };
+  export type ValueUser = {
+    id: string;
+  } & TransformedArguments.User;
+  export {};
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentRoleSelectInteraction.d.ts
+export declare class MessageComponentRoleSelectInteraction extends MessageComponentInteraction<MessageComponentRoleSelectInteraction.Type> {
+  /**
+   * Gets the IDs of the selected roles.
+   */
+  get ids(): Snowflake[];
+  /**
+   * Creates a collection with all the selected roles.
+   *
+   * @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.values}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.entries}.
+   */
+  get roles(): Collection<Snowflake, MessageComponentRoleSelectInteraction.Value>;
+  /**
+   * Returns an iterator of the selected role IDs.
+   *
+   * @seealso {@link MessageComponentRoleSelectInteraction.ids}.
+   */
+  keys(): IterableIterator<Snowflake>;
+  /**
+   * Returns an iterator of the selected channels.
+   *
+   * @seealso {@link MessageComponentRoleSelectInteraction.roles}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.entries}.
+   */
+  values(): IterableIterator<MessageComponentRoleSelectInteraction.Value>;
+  /**
+   * Returns an iterator of [ID, Role] pairs.
+   *
+   * @seealso {@link MessageComponentRoleSelectInteraction.roles}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+   * @seealso {@link MessageComponentRoleSelectInteraction.values}.
+   */
+  entries(): IterableIterator<[Snowflake, MessageComponentRoleSelectInteraction.Value]>;
+}
+export declare namespace MessageComponentRoleSelectInteraction {
+  type Base = APIBaseInteraction<InteractionType.MessageComponent, APIMessageRoleSelectInteractionData>;
+  export type Type = Base & Required<Pick<Base, 'channel' | 'channel_id' | 'data' | 'app_permissions' | 'message'>>;
+  export type Value = TransformedArguments.Role;
+  export {};
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentStringSelectInteraction.d.ts
+export declare class MessageComponentStringSelectInteraction extends MessageComponentInteraction<MessageComponentStringSelectInteraction.Type> {
+  get values(): string[];
+}
+export declare namespace MessageComponentStringSelectInteraction {
+  type Base = APIBaseInteraction<InteractionType.MessageComponent, APIMessageStringSelectInteractionData>;
+  export type Type = Base & Required<Pick<Base, 'channel' | 'channel_id' | 'data' | 'app_permissions' | 'message'>>;
+  export {};
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentUserSelectInteraction.d.ts
+export declare class MessageComponentUserSelectInteraction extends MessageComponentInteraction<MessageComponentUserSelectInteraction.Type> {
+  /**
+   * Gets the IDs of the selected users.
+   */
+  get ids(): Snowflake[];
+  /**
+   * Creates a collection with all the selected users.
+   *
+   * @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.values}.
+   * @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+   */
+  get users(): Collection<Snowflake, MessageComponentUserSelectInteraction.Value>;
+  /**
+   * Returns an iterator of the selected user IDs.
+   *
+   * @seealso {@link MessageComponentUserSelectInteraction.ids}.
+   */
+  keys(): IterableIterator<Snowflake>;
+  /**
+   * Returns an iterator of the selected users.
+   *
+   * @seealso {@link MessageComponentUserSelectInteraction.users}.
+   * @seealso {@link MessageComponentUserSelectInteraction.keys}.
+   * @seealso {@link MessageComponentUserSelectInteraction.entries}.
+   */
+  values(): IterableIterator<MessageComponentUserSelectInteraction.Value>;
+  /**
+   * Returns an iterator of [ID, User] pairs.
+   *
+   * @seealso {@link MessageComponentUserSelectInteraction.channels}.
+   * @seealso {@link MessageComponentUserSelectInteraction.keys}.
+   * @seealso {@link MessageComponentUserSelectInteraction.values}.
+   */
+  entries(): IterableIterator<[Snowflake, MessageComponentUserSelectInteraction.Value]>;
+}
+export declare namespace MessageComponentUserSelectInteraction {
+  type Base = APIBaseInteraction<InteractionType.MessageComponent, APIMessageUserSelectInteractionData>;
+  export type Type = Base & Required<Pick<Base, 'channel' | 'channel_id' | 'data' | 'app_permissions' | 'message'>>;
+  export type Value = TransformedArguments.User;
+  export {};
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageContextMenuCommandInteraction.d.ts
+export declare class MessageContextMenuCommandInteraction extends CommandInteraction<MessageContextMenuCommandInteraction.Type> {}
+export declare namespace MessageContextMenuCommandInteraction {
+  type Type = APIMessageApplicationCommandInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/ModalSubmitInteraction.d.ts
+export declare class ModalSubmitInteraction extends BaseInteraction<ModalSubmitInteraction.Type> {
+  /**
+   * The message the interaction was attached to, if any.
+   */
+  get message(): import("discord-api-types/v10").APIMessage | undefined;
+  /**
+   * ACK a button interaction and update it to a loading state.
+   */
+  deferUpdate(): Promise<PartialMessage<this>>;
+  /**
+   * ACK an interaction and edit a response later. The user sees a loading state.
+   * @param data The data to be sent, if any.
+   */
+  update(data?: UpdateOptions): Promise<PartialMessage<this>>;
+  /**
+   * Responds to the interaction with a message.
+   * @param data The data to be sent.
+   */
+  reply(data: MessageResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * ACK an interaction and edit a response later. The user sees a loading state.
+   * @param data The data to be sent, if any.
+   */
+  defer(data?: DeferResponseOptions): Promise<PartialMessage<this>>;
+  /**
+   * Sends a follow-up message.
+   * @param data The data to be sent.
+   */
+  followup({ files, ...body }: FollowupOptions): AsyncDiscordResult<Message<this>>;
+}
+export declare namespace ModalSubmitInteraction {
+  type Type = APIModalSubmitInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/UserContextMenuCommandInteraction.d.ts
+export declare class UserContextMenuCommandInteraction extends CommandInteraction<UserContextMenuCommandInteraction.Type> {}
+export declare namespace UserContextMenuCommandInteraction {
+  type Type = APIUserApplicationCommandInteraction;
+}
+//#endregion
+//#region src/lib/interactions/structures/interactions/index.d.ts
+export declare namespace Interactions {
+  type Autocomplete = AutocompleteInteraction$1;
+  type ChatInputCommand = ChatInputCommandInteraction;
+  type MessageContextMenuCommand = MessageContextMenuCommandInteraction;
+  type UserContextMenuCommand = UserContextMenuCommandInteraction;
+  type MessageComponentButton = MessageComponentButtonInteraction;
+  type MessageComponentChannelSelect = MessageComponentChannelSelectInteraction;
+  type MessageComponentMentionableSelect = MessageComponentMentionableSelectInteraction;
+  type MessageComponentRoleSelect = MessageComponentRoleSelectInteraction;
+  type MessageComponentStringSelect = MessageComponentStringSelectInteraction;
+  type MessageComponentUserSelect = MessageComponentUserSelectInteraction;
+  type MessageComponentSelectMenu = MessageComponentChannelSelect | MessageComponentMentionableSelect | MessageComponentRoleSelect | MessageComponentStringSelect | MessageComponentUserSelect;
+  type ModalSubmit = ModalSubmitInteraction;
+  type MessageComponent = MessageComponentButton | MessageComponentSelectMenu | ModalSubmit;
+  type ContextMenuCommand = MessageContextMenuCommand | UserContextMenuCommand;
+  type ApplicationCommand = ChatInputCommand | ContextMenuCommand;
+  type Any = Autocomplete | ChatInputCommand | MessageContextMenuCommand | UserContextMenuCommand | MessageComponentButton | MessageComponentSelectMenu | ModalSubmit;
+}
+type Interaction$1 = Interactions.Any;
+//#endregion
+//#region src/lib/interactions/structures/Message.d.ts
+export declare class PartialMessage<I extends BaseInteraction = BaseInteraction> {
+  readonly interaction: I;
+  constructor(interaction: I);
+  /**
+   * The ID of the message.
+   */
+  get id(): string;
+  /**
+   * The thread, if the message started one.
+   */
+  get thread(): APIChannel | undefined;
+  /**
+   * Retrieves the message from Discord, returns a clone of the instance.
+   */
+  get(): AsyncDiscordResult<Message>;
+  /**
+   * Updates the message, returns a clone of the instance.
+   * @param data The data to be sent.
+   */
+  update({ files, ...body }: UpdateResponseOptions): AsyncDiscordResult<Message>;
+  /**
+   * Deletes the message.
+   */
+  delete(): AsyncDiscordResult<this>;
+}
+export type UpdateResponseResult = RESTPatchAPIInteractionOriginalResponseResult;
+export type UpdateResponseOptions = AddFiles<RESTPatchAPIInteractionOriginalResponseJSONBody>;
+export declare class Message<I extends BaseInteraction = BaseInteraction> extends PartialMessage<I> {
+  private readonly [Data];
+  constructor(interaction: I, data: APIMessage);
+  /**
+   * The ID of the message.
+   *
+   * @raw
+   */
+  get id(): string;
+  /**
+   * The ID of the channel the message is from.
+   *
+   * @raw
+   * @seealso {@link channelId} for the camelCase property.
+   */
+  get channel_id(): APIMessage['channel_id'];
+  /**
+   * The ID of the channel the message is from.
+   */
+  get channelId(): APIMessage['channel_id'];
+  /**
+   * The author of this message (only a valid user in the case where the message is generated by a user or bot user)
+   *
+   * If the message is generated by a webhook, the author object corresponds to the webhook's id,
+   * username, and avatar. You can tell if a message is generated by a webhook by checking for the {@link webhookId} property
+   *
+   * @raw
+   * @seealso {@link https://discord.com/developers/docs/resources/user#user-object}
+   */
+  get author(): APIMessage['author'];
+  /**
+   * The contents of the message.
+   *
+   * @raw
+   */
+  get content(): APIMessage['content'];
+  /**
+   * The timestamp the message was sent at.
+   *
+   * @raw
+   * @seealso {@link createdTimestamp} for the parsed timestamp.
+   * @seealso {@link createdAt} for the Date instance created from the parsed timestamp.
+   */
+  get timestamp(): APIMessage['timestamp'];
+  /**
+   * The timestamp the message was sent at.
+   *
+   * @seealso {@link timestamp} for the raw data.
+   */
+  get createdTimestamp(): number;
+  /**
+   * The {@link Date} version of {@link createdTimestamp}.
+   */
+  get createdAt(): Date;
+  /**
+   * The timestamp the message was edited at, `null` if it was never edited.
+   *
+   * @raw
+   * @seealso {@link editedTimestamp} for the parsed timestamp.
+   * @seealso {@link editedAt} for the Date instance created from the parsed timestamp.
+   */
+  get edited_timestamp(): APIMessage['edited_timestamp'];
+  /**
+   * The timestamp the message was edited at, `null` if it was never edited.
+   */
+  get editedTimestamp(): number | null;
+  /**
+   * The {@link Date} version of {@link editedTimestamp}.
+   */
+  get editedAt(): Date | null;
+  /**
+   * Whether or not the message is a TTS message.
+   *
+   * @raw
+   */
+  get tts(): APIMessage['tts'];
+  /**
+   * Whether or not the message mentioned everyone.
+   *
+   * @raw
+   * @seealso {@link mention_everyone} for the camelCase property.
+   */
+  get mention_everyone(): APIMessage['mention_everyone'];
+  /**
+   * Whether or not the message mentioned everyone.
+   *
+   * @seealso {@link mention_everyone} for the raw data.
+   */
+  get mentionEveryone(): APIMessage['mention_everyone'];
+  /**
+   * The users specifically mentioned in the message.
+   *
+   * @raw
+   * @seealso {@link https://discord.com/developers/docs/resources/user#user-object}
+   */
+  get mentions(): APIMessage['mentions'];
+  /**
+   * The roles specifically mentioned in the message.
+   *
+   * @raw
+   * @seealso {@link https://discord.com/developers/docs/topics/permissions#role-object}
+   */
+  get mention_roles(): APIMessage['mention_roles'];
+  /**
+   * The roles specifically mentioned in the message.
+   *
+   * @seealso {@link https://discord.com/developers/docs/topics/permissions#role-object}
+   * @seealso {@link mention_roles} for the raw data.
+   */
+  get mentionRoles(): APIMessage['mention_roles'];
+  /**
+   * The channels specifically mentioned in this message.
+   *
+   * Not all channel mentions in a message will appear in {@link mentionChannels}:
+   * - Only textual channels that are visible to everyone in a lurkable guild will ever be included.
+   * - Only crossposted messages (via Channel Following) currently include {@link mentionChannels} at all.
+   *
+   * @raw
+   * @seealso {@link mentionChannels} for the camelCase property with an empty array default.
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#channel-mention-object}
+   */
+  get mention_channels(): APIMessage['mention_channels'];
+  /**
+   * The channels specifically mentioned in this message.
+   *
+   * Not all channel mentions in a message will appear in {@link mentionChannels}:
+   * - Only textual channels that are visible to everyone in a lurkable guild will ever be included.
+   * - Only crossposted messages (via Channel Following) currently include {@link mentionChannels} at all.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#channel-mention-object}
+   */
+  get mentionChannels(): APIMessage['mention_channels'];
+  /**
+   * A nonce that can be used for optimistic message sending (up to 25 characters).
+   *
+   * @raw
+   */
+  get nonce(): APIMessage['nonce'];
+  /**
+   * Whether or not the message is pinned.
+   *
+   * @raw
+   */
+  get pinned(): APIMessage['pinned'];
+  /**
+   * The attached files.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#attachment-object}
+   */
+  get attachments(): APIMessage['attachments'];
+  /**
+   * The embedded content.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#embed-object}
+   */
+  get embeds(): APIMessage['embeds'];
+  /**
+   * The reactions the message has.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#reaction-object}
+   */
+  get reactions(): APIMessage['reactions'];
+  /**
+   * The webhook ID.
+   */
+  get webhook_id(): APIMessage['webhook_id'];
+  /**
+   * The webhook ID.
+   *
+   * @seealso {@link webhook_id} for the raw data.
+   */
+  get webhookId(): string | null;
+  /**
+   * The message's type.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#message-object-message-types}
+   */
+  get type(): import("discord-api-types/v10").MessageType;
+  /**
+   * The thread, if the message started one.
+   */
+  get thread(): APIChannel | undefined;
+  /**
+   * The message flags combined as a bitfield.
+   *
+   * @seealso {@link https://discord.com/developers/docs/resources/channel#message-object-message-flags}
+   * @seealso {@link https://en.wikipedia.org/wiki/Bit_field}
+   */
+  get flags(): import("discord-api-types/v10").MessageFlags | undefined;
+  /**
+   * The message's components, such as buttons, action rows, or other interactive components.
+   */
+  get components(): import("discord-api-types/v10").APIMessageTopLevelComponent[];
+  /**
+   * The stickers the message contains, if any.
+   */
+  get sticker_items(): import("discord-api-types/v10").APIStickerItem[] | undefined;
+  /**
+   * The stickers the message contains, if any.
+   *
+   * @seealso {@link sticker_items} for the raw data.
+   */
+  get stickerItems(): import("discord-api-types/v10").APIStickerItem[];
+}
+//#endregion
+//#region src/lib/interactions/utils/util.d.ts
+export declare function makeInteraction<T extends BaseInteractionType>(response: ServerResponse, interaction: T): TransformRaw<T>;
+type TransformRaw<T extends BaseInteractionType> = T extends AutocompleteInteraction$1.Type ? AutocompleteInteraction$1 : T extends ChatInputCommandInteraction.Type ? ChatInputCommandInteraction : T extends UserContextMenuCommandInteraction.Type ? UserContextMenuCommandInteraction : T extends MessageContextMenuCommandInteraction.Type ? MessageContextMenuCommandInteraction : T extends MessageComponentButtonInteraction.Type ? MessageComponentButtonInteraction : T extends MessageComponentChannelSelectInteraction.Type ? MessageComponentChannelSelectInteraction : T extends MessageComponentMentionableSelectInteraction.Type ? MessageComponentMentionableSelectInteraction : T extends MessageComponentRoleSelectInteraction.Type ? MessageComponentRoleSelectInteraction : T extends MessageComponentStringSelectInteraction.Type ? MessageComponentStringSelectInteraction : T extends MessageComponentUserSelectInteraction.Type ? MessageComponentUserSelectInteraction : T extends ModalSubmitInteraction.Type ? ModalSubmitInteraction : never;
+//#endregion
+//#region src/lib/interactions/router/CommandRouter.d.ts
+/**
+ * Represents a command router that handles routing of interactions for a specific command.
+ *
+ * @since 2.0.0
+ * @template Options - The options type for the command.
+ */
+export declare class CommandRouter<Options extends Command.Options = Command.Options> {
+  #private;
+  constructor(command: Command<Options>);
+  /**
+   * The name of the registered chat input command for this command, if any.
+   *
+   * @since 2.0.0
+   */
+  get chatInputName(): string | null;
+  /**
+   * The names of the registered context menu commands for this command, if any.
+   *
+   * @since 2.0.0
+   */
+  get contextMenuNames(): string[];
+  /**
+   * Routes a chat input interaction based on the provided data.
+   *
+   * @since 2.0.0
+   * @param data - The data of the chat input interaction.
+   * @returns The mapped command name or `null` if no mapping is found.
+   */
+  routeChatInputInteraction(data: APIChatInputApplicationCommandInteractionData): string | null;
+  /**
+   * Routes a context menu interaction based on the provided data.
+   *
+   * @since 2.0.0
+   * @param data - The data for the context menu interaction.
+   * @returns The result of the context menu interaction, or null if no result is found.
+   */
+  routeContextMenuInteraction(data: APIContextMenuInteractionData): string | null;
+}
+//#endregion
+//#region src/lib/structures/Command.d.ts
+export declare abstract class Command<Options extends Command.Options = Command.Options> extends Piece$1<Options, 'commands'> {
+  /**
+   * The router for the command.
+   * @since 2.0.0
+   */
+  readonly router: CommandRouter<Options>;
+  constructor(context: Command.LoaderContext, options?: Options);
+  /**
+   * Gets the registry for this command.
+   *
+   * @returns The registry for this command, or `null` if it is not registered.
+   */
+  get registry(): ApplicationCommandRegistryEntry | null;
+  /**
+   * Registers this command's application commands imperatively, without relying on decorators.
+   *
+   * @remarks This is invoked once, synchronously, from the base {@linkcode Command} constructor, right before this
+   * command's router is built, and therefore before any subclass field initializers or subclass constructor body have
+   * run. Because of this it must be declared as a method (not a class-field arrow function, which would not yet be
+   * assigned at this point and would be silently skipped) and it must not read subclass instance state, which is still
+   * uninitialized; it should register commands using only the provided `registry`. This matches the static, class-level
+   * nature of the decorators: it is the decorator-free equivalent of {@link RegisterCommand} and its siblings, and a
+   * command should use either this method or the decorators, not both.
+   * @since 3.1.0
+   * @param registry - The registry to register this command's application commands with.
+   * @example
+   * ```typescript
+   * import { Command } from '@wolfstar/http-framework';
+   *
+   * export class UserCommand extends Command {
+   * 	public override registerApplicationCommands(registry: Command.Registry) {
+   * 		registry.registerChatInputCommand((builder) =>
+   * 			builder.setName('ping').setDescription('Runs a network connection test with me')
+   * 		);
+   * 	}
+   *
+   * 	public override chatInputRun(interaction: Command.ChatInputInteraction) {
+   * 		return interaction.reply({ content: 'Pong!' });
+   * 	}
+   * }
+   * ```
+   */
+  registerApplicationCommands?(registry: Command.Registry): unknown;
+  /**
+   * Responds to the chat input command for this command
+   *
+   * @param interaction - The interaction to be handled.
+   * @param args - The parsed arguments for this autocomplete interaction.
+   */
+  chatInputRun(interaction: Command.ApplicationCommandInteraction, args: NonNullObject): Awaitable<unknown>;
+  /**
+   * Responds to an auto completable option for this command
+   *
+   * @param interaction - The interaction to be handled.
+   * @param args - The parsed arguments for this autocomplete interaction.
+   * @returns The response to the autocomplete interaction.
+   */
+  autocompleteRun(interaction: Command.AutocompleteInteraction, args: Command.AutocompleteArguments<any>): Awaitable<unknown>;
+}
+export declare namespace Command {
+  type AutocompleteInteraction = Interactions.Autocomplete;
+  type AutocompleteArguments<T extends object> = AutocompleteInteractionArguments<T>;
+  type ChatInputInteraction = Interactions.ChatInputCommand;
+  type UserInteraction = Interactions.UserContextMenuCommand;
+  type MessageInteraction = Interactions.MessageContextMenuCommand;
+  type ContextMenuInteraction = Interactions.ContextMenuCommand;
+  type ApplicationCommandInteraction = Interactions.ApplicationCommand;
+  type Interaction = ChatInputInteraction | AutocompleteInteraction | UserInteraction | MessageInteraction;
+  type InteractionData = Interaction['data'];
+  type Registry = CommandRegistry;
+  /** @deprecated Use {@linkcode LoaderContext} instead. */
+  type Context = LoaderContext;
+  type LoaderContext = Piece$1.LoaderContext<'commands'>;
+  type JSON = Piece$1.JSON;
+  type LocationJSON = Piece$1.LocationJSON;
+  type Options = Piece$1.Options;
+}
+//#endregion
+//#region src/lib/structures/InteractionHandler.d.ts
+export declare abstract class InteractionHandler<Options extends InteractionHandler.Options = InteractionHandler.Options> extends Piece$1<Options, 'interaction-handlers'> {
+  constructor(context: InteractionHandler.LoaderContext, options?: Options);
+  abstract run(interaction: InteractionHandler.Interaction, customIdValue: unknown): Awaited<unknown>;
+}
+export declare namespace InteractionHandler {
+  type ButtonInteraction = Interactions.MessageComponentButton;
+  type SelectMenuInteraction = Interactions.MessageComponentSelectMenu;
+  type ModalInteraction = Interactions.ModalSubmit;
+  type MessageComponentInteraction = Interactions.MessageComponent;
+  type ContextMenuInteraction = Interactions.ContextMenuCommand;
+  type ApplicationCommandInteraction = Interactions.ApplicationCommand;
+  type Interaction = Interactions.MessageComponent;
+  type InteractionData = Interaction['data'];
+  /** @deprecated Use {@linkcode LoaderContext} instead. */
+  type Context = LoaderContext;
+  type LoaderContext = Piece$1.LoaderContext<'interaction-handlers'>;
+  type JSON = Piece$1.JSON;
+  type LocationJSON = Piece$1.LocationJSON;
+  type Options = Piece$1.Options;
+}
+//#endregion
+//#region src/lib/types/Enums.d.ts
+export declare enum PluginHook {
+  PreGenericsInitialization = "preGenericsInitialization",
+  PreInitialization = "preInitialization",
+  PostInitialization = "postInitialization",
+  PreLoad = "preLoad",
+  PostListen = "postListen"
+}
+//#endregion
+//#region src/lib/ClientEvents.d.ts
+export interface ClientEventCommandContext {
+  command: Command;
+  interaction: APIApplicationCommandInteraction;
+  response: ServerResponse;
+}
+export interface ClientEventAutocompleteContext {
+  command: Command;
+  interaction: APIApplicationCommandAutocompleteInteraction;
+  response: ServerResponse;
+}
+export interface ClientEventInteractionHandlerContext {
+  handler: InteractionHandler;
+  interaction: APIMessageComponentInteraction | APIModalSubmitInteraction;
+  response: ServerResponse;
+}
+/**
+ * The name of every event emitted by the {@link Client}, mirroring the keys of {@link ClientEvents}.
+ *
+ * @remarks
+ * Each member's value is the plain event name, so they are interchangeable with the string literals
+ * accepted by `Client#on`, `Client#emit`, and {@link Listener.Options.event}.
+ *
+ * @example
+ * ```typescript
+ * client.on(Events.CommandError, (error, context) => console.error(context.command.name, error));
+ * ```
+ *
+ * @since 3.4.0
+ */
+export declare enum Events {
+  Error = "error",
+  PluginLoaded = "pluginLoaded",
+  CommandNameMissing = "commandNameMissing",
+  CommandNameUnknown = "commandNameUnknown",
+  CommandMethodUnknown = "commandMethodUnknown",
+  CommandRun = "commandRun",
+  CommandSuccess = "commandSuccess",
+  CommandError = "commandError",
+  CommandFinish = "commandFinish",
+  AutocompleteRun = "autocompleteRun",
+  AutocompleteSuccess = "autocompleteSuccess",
+  AutocompleteError = "autocompleteError",
+  AutocompleteFinish = "autocompleteFinish",
+  InteractionHandlerNameInvalid = "interactionHandlerNameInvalid",
+  InteractionHandlerNameUnknown = "interactionHandlerNameUnknown",
+  InteractionHandlerRun = "interactionHandlerRun",
+  InteractionHandlerSuccess = "interactionHandlerSuccess",
+  InteractionHandlerError = "interactionHandlerError",
+  InteractionHandlerFinish = "interactionHandlerFinish",
+  HmrStart = "hmrStart",
+  HmrStop = "hmrStop",
+  HmrPiecesLoaded = "hmrPiecesLoaded",
+  HmrPieceReloaded = "hmrPieceReloaded",
+  HmrPieceUnloaded = "hmrPieceUnloaded",
+  HmrError = "hmrError"
+}
+export interface ClientEvents {
+  error: [error: unknown];
+  /**
+   * Emitted after a plugin hook runs, providing the hook's {@link PluginHook} and the plugin's name
+   * (or `undefined` when the registering plugin did not provide one).
+   *
+   * @remarks
+   * The `PreGenericsInitialization`, `PreInitialization`, and `PostInitialization` hooks run
+   * synchronously inside the `Client` constructor, so their emissions fire before `new Client()`
+   * returns. A listener attached afterwards cannot observe them (not even one added by a subclass,
+   * whose constructor body only runs after `super()` has already executed those hooks), so only the
+   * `PreLoad` (during `Client#load`) and `PostListen` (during `Client#listen`) emissions are
+   * observable. To react to the constructor-phase hooks, use the plugin hooks themselves.
+   */
+  pluginLoaded: [hook: PluginHook, name: string | undefined];
+  commandNameMissing: [interaction: APIApplicationCommandAutocompleteInteraction, response: ServerResponse];
+  commandNameUnknown: [interaction: APIApplicationCommandInteraction | APIApplicationCommandAutocompleteInteraction, response: ServerResponse];
+  commandMethodUnknown: [context: ClientEventCommandContext];
+  commandRun: [context: ClientEventCommandContext];
+  commandSuccess: [context: ClientEventCommandContext, value: unknown];
+  commandError: [error: unknown, context: ClientEventCommandContext];
+  commandFinish: [context: ClientEventCommandContext];
+  autocompleteRun: [context: ClientEventAutocompleteContext];
+  autocompleteSuccess: [context: ClientEventAutocompleteContext, value: unknown];
+  autocompleteError: [error: unknown, context: ClientEventAutocompleteContext];
+  autocompleteFinish: [context: ClientEventAutocompleteContext];
+  interactionHandlerNameInvalid: [interaction: APIMessageComponentInteraction | APIModalSubmitInteraction, response: ServerResponse];
+  interactionHandlerNameUnknown: [interaction: APIMessageComponentInteraction | APIModalSubmitInteraction, response: ServerResponse];
+  interactionHandlerRun: [context: ClientEventInteractionHandlerContext];
+  interactionHandlerSuccess: [context: ClientEventInteractionHandlerContext, value: unknown];
+  interactionHandlerError: [error: unknown, context: ClientEventInteractionHandlerContext];
+  interactionHandlerFinish: [context: ClientEventInteractionHandlerContext];
+  /**
+   * Emitted when the Hot Module Reloader starts watching, with the list of watched store paths.
+   *
+   * @since 3.3.0
+   */
+  hmrStart: [paths: string[]];
+  /**
+   * Emitted when the Hot Module Reloader stops watching and all of its watchers have been closed.
+   *
+   * @since 3.3.0
+   */
+  hmrStop: [];
+  /**
+   * Emitted when the Hot Module Reloader loads the pieces of a newly created file.
+   *
+   * @since 3.3.0
+   */
+  hmrPiecesLoaded: [pieces: Piece$1[], path: string];
+  /**
+   * Emitted when the Hot Module Reloader reloads an already loaded piece after its file changed.
+   *
+   * @since 3.3.0
+   */
+  hmrPieceReloaded: [piece: Piece$1, path: string];
+  /**
+   * Emitted when the Hot Module Reloader unloads a piece after its file was deleted.
+   *
+   * @since 3.3.0
+   */
+  hmrPieceUnloaded: [piece: Piece$1, path: string];
+  /**
+   * Emitted when the Hot Module Reloader fails to load, reload, or unload the pieces of a file. The error is not
+   * rethrown: saving the file again retries the operation.
+   *
+   * @since 3.3.0
+   */
+  hmrError: [error: unknown, path: string];
+}
+/**
+ * The name of any of the events emitted by the {@link Client}, either as a plain string literal or as an
+ * {@link Events} member.
+ *
+ * @since 3.4.0
+ */
+export type ClientEventName = keyof ClientEvents;
+export type MappedClientEvents = { [K in keyof ClientEvents]: ClientEvents[K]; };
+//#endregion
+//#region src/lib/hmr/HotModuleReloader.d.ts
+/**
+ * Hot Module Reloading for every {@link Store} registered in {@link container.stores}.
+ *
+ * @remarks The reloader watches each store's registered paths and reacts to file system events by loading, reloading,
+ * and unloading the affected pieces in place, without restarting the process. It is a development-only utility: watching
+ * the file system in production adds overhead and reloads code that is not supposed to change, which is why it is
+ * opt-in.
+ * @since 3.3.0
+ * @example
+ * ```typescript
+ * const client = new Client({ hmr: { enabled: process.env.NODE_ENV !== 'production' } });
+ * await client.load();
+ * ```
+ */
+export declare class HotModuleReloader {
+  #private;
+  /**
+   * The options this reloader was constructed with.
+   *
+   * @since 3.3.0
+   */
+  readonly options: HotModuleReloader.Options;
+  constructor(options?: HotModuleReloader.Options);
+  /**
+   * Whether the reloader is currently watching for changes.
+   *
+   * @since 3.3.0
+   */
+  get running(): boolean;
+  /**
+   * The paths currently being watched, one entry per store path.
+   *
+   * @since 3.3.0
+   */
+  get paths(): readonly string[];
+  /**
+   * Starts watching every path registered in every store.
+   *
+   * @remarks This is a no-op when {@link HotModuleReloader.Options.enabled} is `false`, when the reloader is already
+   * running, or when no store has registered paths. `chokidar` is imported lazily, so applications that never enable
+   * HMR do not pay for loading it.
+   * @since 3.3.0
+   * @returns This instance, for chaining.
+   */
+  start(): Promise<this>;
+  /**
+   * Stops watching for changes and closes every watcher.
+   *
+   * @remarks Calling this on a reloader that is not running is a no-op. Already loaded pieces are left untouched.
+   * @since 3.3.0
+   */
+  stop(): Promise<void>;
+  /**
+   * Handles a file being added to, or modified in, one of the store's paths, reloading the piece it defines when it is
+   * already loaded, and loading it otherwise.
+   *
+   * @since 3.3.0
+   * @param store - The store the path belongs to.
+   * @param path - The full path of the file that changed.
+   */
+  protected handlePieceUpdate(store: Store$1<Piece$1>, path: string): Promise<void>;
+  /**
+   * Handles a file being removed from one of the store's paths, unloading the piece it defined.
+   *
+   * @since 3.3.0
+   * @param store - The store the path belongs to.
+   * @param path - The full path of the file that was deleted.
+   */
+  protected handlePieceDelete(store: Store$1<Piece$1>, path: string): Promise<void>;
+  /**
+   * Handles an error thrown while (re)loading or unloading a piece.
+   *
+   * @remarks Errors are never rethrown: a broken file must not take the process down, the user is expected to fix it
+   * and save again, which triggers a new reload.
+   * @since 3.3.0
+   * @param error - The error that was thrown.
+   * @param path - The full path of the file that was being processed.
+   */
+  protected handleError(error: unknown, path: string): void;
+}
+export interface HMROptions extends ChokidarOptions {
+  /**
+   * Whether Hot Module Reloading is enabled.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Whether the reloader should refrain from writing to the console. Events are always emitted on the
+   * {@link Client} regardless of this option.
+   *
+   * @default false
+   */
+  silent?: boolean;
+}
+export declare namespace HotModuleReloader {
+  type Options = HMROptions;
+}
+//#endregion
+//#region src/lib/components/IIdParser.d.ts
+export interface IIdParser {
+  run(customId: string): IdParserRead | null;
+}
+export interface IdParserRead {
+  name: string;
+  content: unknown;
+}
+//#endregion
+//#region src/lib/plugins/symbols.d.ts
+export declare const preGenericsInitialization: unique symbol;
+export declare const preInitialization: unique symbol;
+export declare const postInitialization: unique symbol;
+export declare const preLoad: unique symbol;
+export declare const postListen: unique symbol;
+//#endregion
+//#region src/lib/plugins/Plugin.d.ts
+/**
+ * The base class for all plugins. Plugins hook into the {@link Client}'s lifecycle by defining static
+ * methods keyed by the plugin symbols. Use {@link PluginManager.use} (via `Client.use`) to register a plugin.
+ *
+ * @since 2.4.0
+ */
+export declare abstract class Plugin {
+  static [preGenericsInitialization]?: (this: Client, options: ClientOptions) => void;
+  static [preInitialization]?: (this: Client, options: ClientOptions) => void;
+  static [postInitialization]?: (this: Client, options: ClientOptions) => void;
+  static [preLoad]?: (this: Client, options: ClientOptions) => Awaitable<void>;
+  static [postListen]?: (this: Client, options: ClientOptions) => Awaitable<void>;
+}
+//#endregion
+//#region src/lib/plugins/PluginManager.d.ts
+export type AsyncPluginHooks = PluginHook.PreLoad | PluginHook.PostListen;
+export interface HttpFrameworkPluginAsyncHook {
+  (this: Client, options: ClientOptions): Awaitable<unknown>;
+}
+export type SyncPluginHooks = Exclude<PluginHook, AsyncPluginHooks>;
+export interface HttpFrameworkPluginHook {
+  (this: Client, options: ClientOptions): unknown;
+}
+export interface HttpFrameworkPluginHookEntry<T = HttpFrameworkPluginHook | HttpFrameworkPluginAsyncHook> {
+  hook: T;
+  type: PluginHook;
+  name?: string;
+}
+export declare class PluginManager {
+  readonly registry: Set<HttpFrameworkPluginHookEntry<HttpFrameworkPluginAsyncHook | HttpFrameworkPluginHook>>;
+  registerHook(hook: HttpFrameworkPluginHook, type: SyncPluginHooks, name?: string): this;
+  registerHook(hook: HttpFrameworkPluginAsyncHook, type: AsyncPluginHooks, name?: string): this;
+  registerPreGenericsInitializationHook(hook: HttpFrameworkPluginHook, name?: string): this;
+  registerPreInitializationHook(hook: HttpFrameworkPluginHook, name?: string): this;
+  registerPostInitializationHook(hook: HttpFrameworkPluginHook, name?: string): this;
+  registerPreLoadHook(hook: HttpFrameworkPluginAsyncHook, name?: string): this;
+  registerPostListenHook(hook: HttpFrameworkPluginAsyncHook, name?: string): this;
+  use(plugin: typeof Plugin): this;
+  values(): Generator<HttpFrameworkPluginHookEntry, void, unknown>;
+  values(hook: SyncPluginHooks): Generator<HttpFrameworkPluginHookEntry<HttpFrameworkPluginHook>, void, unknown>;
+  values(hook: AsyncPluginHooks): Generator<HttpFrameworkPluginHookEntry<HttpFrameworkPluginAsyncHook>, void, unknown>;
+}
+//#endregion
+//#region src/lib/structures/InteractionHandlerStore.d.ts
+export declare class InteractionHandlerStore extends Store$1<InteractionHandler, 'interaction-handlers'> {
+  constructor();
+  runHandler(response: ServerResponse, interaction: APIMessageComponentInteraction | APIModalSubmitInteraction): Promise<ServerResponse>;
+}
+//#endregion
+//#region src/lib/structures/Listener.d.ts
+export declare abstract class Listener<Options extends Listener.Options = Listener.Options> extends Piece$1<Options, 'listeners'> {
+  emitter: Listener.Emitter;
+  event: string;
+  protected _listener: (...args: readonly any[]) => unknown;
+  constructor(context: Listener.LoaderContext, options: Options);
+  abstract run(...args: readonly any[]): Awaitable<unknown>;
+}
+export declare namespace Listener {
+  /** @deprecated Use {@linkcode LoaderContext} instead. */
+  type Context = LoaderContext;
+  type LoaderContext = Piece$1.LoaderContext<'listeners'>;
+  type JSON = Piece$1.JSON;
+  type LocationJSON = Piece$1.LocationJSON;
+  interface Options extends Piece$1.Options {
+    emitter: Emitter | { [K in keyof Container]: Container[K] extends Emitter ? K : never; }[keyof Container];
+    event?: string;
+  }
+  interface Emitter {
+    on(eventName: string, listener: (...args: any[]) => void): this;
+    once(eventName: string, listener: (...args: any[]) => void): this;
+    off(eventName: string, listener: (...args: any[]) => void): this;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    emit(eventName: string, ...args: any[]): boolean;
+  }
+}
+//#endregion
+//#region src/lib/structures/ListenerStore.d.ts
+export declare class ListenerStore extends Store$1<Listener, 'listeners'> {
+  constructor();
+}
+//#endregion
+//#region src/lib/utils/logger/ILogger.d.ts
+/**
+ * The available log levels, ordered from the most verbose to the least. A {@link ILogger} only writes the entries
+ * whose level is greater than or equal to its configured one, which makes {@link LogLevel.None} a way to silence
+ * every entry.
+ *
+ * @since 3.4.0
+ */
+export declare enum LogLevel {
+  /**
+   * The lowest level, used for very fine-grained information such as per-interaction traces.
+   */
+  Trace = 10,
+  /**
+   * The level used for information that is useful while developing, but noisy in production.
+   */
+  Debug = 20,
+  /**
+   * The default level, used for lifecycle information such as the HTTP server starting.
+   */
+  Info = 30,
+  /**
+   * The level used for recoverable issues that should be looked at.
+   */
+  Warn = 40,
+  /**
+   * The level used for errors that were handled but interrupted an operation.
+   */
+  Error = 50,
+  /**
+   * The level used for errors the process cannot recover from.
+   */
+  Fatal = 60,
+  /**
+   * A level no entry can reach, silencing the logger entirely.
+   */
+  None = 100
+}
+/**
+ * The contract every logger must fulfill to be usable as `container.logger`.
+ *
+ * The framework ships a minimal {@link Logger} that writes to the console, and expects richer implementations
+ * (file transports, structured output, and alike) to be provided by a plugin through
+ * {@link ClientLoggerOptions.instance}.
+ *
+ * @since 3.4.0
+ */
+export interface ILogger {
+  /**
+   * Whether or not the logger writes entries at the given level.
+   * @param level The level to check for.
+   */
+  has(level: LogLevel): boolean;
+  /**
+   * Writes the values at {@link LogLevel.Trace} level.
+   * @param values The values to log.
+   */
+  trace(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at {@link LogLevel.Debug} level.
+   * @param values The values to log.
+   */
+  debug(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at {@link LogLevel.Info} level.
+   * @param values The values to log.
+   */
+  info(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at {@link LogLevel.Warn} level.
+   * @param values The values to log.
+   */
+  warn(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at {@link LogLevel.Error} level.
+   * @param values The values to log.
+   */
+  error(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at {@link LogLevel.Fatal} level.
+   * @param values The values to log.
+   */
+  fatal(...values: readonly unknown[]): void;
+  /**
+   * Writes the values at the given level, skipping them when {@link ILogger.has} returns `false`.
+   * @param level The level to write the values at.
+   * @param values The values to log.
+   */
+  write(level: LogLevel, ...values: readonly unknown[]): void;
+}
+//#endregion
+//#region src/lib/utils/security.d.ts
+type Key = webcrypto.CryptoKey;
+//#endregion
+//#region src/lib/Client.d.ts
+export declare class Client extends AsyncEventEmitter<MappedClientEvents> {
+  #private;
+  server: Server;
+  /**
+   * The Hot Module Reloader, set by {@link Client#load} when {@link ClientOptions.hmr} is enabled, and `null`
+   * otherwise.
+   *
+   * @since 3.3.0
+   */
+  hmr: HotModuleReloader | null;
+  /**
+   * The logger the client and the framework internals write to. It defaults to a {@link Logger} writing to the
+   * console, and can be replaced with any {@link ILogger} through {@link ClientLoggerOptions.instance}, which is
+   * how a logger plugin swaps the built-in implementation for a richer one.
+   *
+   * @since 3.4.0
+   */
+  readonly logger: ILogger;
+  readonly id: string;
+  readonly options: ClientOptions;
+  readonly bodySizeLimit: number;
+  readonly httpReplyOnError: boolean;
+  constructor(options?: ClientOptions);
+  /**
+   * The plugin manager, holding every registered plugin hook.
+   *
+   * @since 2.4.0
+   */
+  static readonly plugins: PluginManager;
+  /**
+   * Registers a plugin onto the {@link Client}, applying all of its hooks.
+   *
+   * @since 2.4.0
+   * @param plugin The plugin to register.
+   */
+  static use(plugin: typeof Plugin): typeof Client;
+  /**
+   * Gets the application command registry.
+   *
+   * @since 2.0.0
+   * @returns The application command registry.
+   */
+  get registry(): ApplicationCommandRegistry;
+  /**
+   * Loads all the commands.
+   * @param options The load options.
+   */
+  load(options?: LoadOptions): Promise<void>;
+  /**
+   * Starts the HTTP server, listening for HTTP interactions.
+   * @param options The listen options.
+   */
+  listen({ serverOptions, postPath, port, address, ...listenOptions }: ListenOptions): Promise<void>;
+  /**
+   * Handles a single Web `Request`/`Response` interaction — the exact same signature verification, routing and
+   * replies `listen()`'s `node:http` server runs, `handleRawHttpMessage` called exactly the way it calls it on
+   * every request — without binding a port. This is `node:http`'s replacement whenever something else (Nitro, a
+   * Worker, `Bun.serve`) owns the actual listener instead of `Client`: build a `Request` from whatever that
+   * transport gives you and hand it here.
+   *
+   * The Discord public key given at construction is imported once and reused across every call, the same lifetime
+   * `listen()` gives its own signing key.
+   * @param request The interaction request.
+   * @param options The fetch options.
+   */
+  fetch(request: Request, options?: FetchOptions): Promise<Response>;
+  protected handleRawHttpMessage(request: IncomingMessage, response: ServerResponse, path: string, key: Key): Promise<ServerResponse<IncomingMessage>>;
+  protected handleHttpMessage(interaction: Exclude<APIInteraction, APIPrimaryEntryPointCommandInteraction>, response: ServerResponse): Promise<ServerResponse>;
+}
+export interface ClientOptions {
+  /**
+   * The public key from Discord, available under "General Information" after opening an application from
+   * [Discord's applications](https://discord.com/developers/applications).
+   *
+   * @default process.env.DISCORD_PUBLIC_KEY
+   */
+  discordPublicKey?: string;
+  /**
+   * The Discord token used for authenticating requests outside of interaction responses.
+   *
+   * @default process.env.DISCORD_TOKEN
+   */
+  discordToken?: string;
+  /**
+   * The options to be passed to the underlying REST library.
+   */
+  restOptions?: Partial<RESTOptions>;
+  /**
+   * The body size limit in bytes.
+   * @default 1024 * 1024 // (1 MiB)
+   */
+  bodySizeLimit?: number;
+  /**
+   * Whether to reply with a 500 status code to Discord if an error occurs while processing an interaction.
+   * @default true
+   */
+  httpReplyOnError?: boolean;
+  /**
+   * The ID of the client.
+   *
+   * @default process.env.DISCORD_CLIENT_ID ?? Buffer.from(token.split('.')[0], 'base64').toString()
+   */
+  clientId?: string;
+  /**
+   * The prefix to use for authentication in REST calls.
+   * @default 'Bot'
+   * @since 2.0.0
+   */
+  authPrefix?: RequestAuthPrefix;
+  /**
+   * The Hot Module Reloading options. When {@link HMROptions.enabled} is `true`, {@link Client#load} starts a
+   * {@link HotModuleReloader} that watches every store path and reloads pieces as their files change.
+   *
+   * @remarks HMR is meant for development only, keep it disabled in production.
+   * @default undefined // HMR is not started
+   * @since 3.3.0
+   */
+  hmr?: HMROptions;
+  /**
+   * The options for {@link Client#logger}, which is also exposed as `container.logger`.
+   *
+   * @since 3.4.0
+   */
+  logger?: ClientLoggerOptions;
+}
+export interface ClientLoggerOptions {
+  /**
+   * The lowest {@link LogLevel} the built-in {@link Logger} writes. Ignored when
+   * {@link ClientLoggerOptions.instance} is set.
+   *
+   * @default LogLevel.Info
+   * @since 3.4.0
+   */
+  level?: LogLevel;
+  /**
+   * The {@link ILogger} to use instead of the built-in {@link Logger}. Plugins set this from a
+   * {@link PluginHook.PreGenericsInitialization} hook to extend the framework's logging.
+   *
+   * @default undefined // a new Logger is created
+   * @since 3.4.0
+   */
+  instance?: ILogger;
+}
+export interface LoadOptions {
+  /**
+   * The base user directory, if set to `null`, the library will not call {@link StoreRegistry.registerPath},
+   * meaning that you will need to manually set each folder for each store. Please read the aforementioned method's
+   * documentation for more information.
+   */
+  baseUserDirectory?: string | null;
+}
+export interface ListenOptions extends Omit<ListenOptions$1, 'path' | 'readableAll' | 'writableAll'> {
+  /**
+   * The port at which the server will listen for requests.
+   */
+  port: number;
+  /**
+   * The address at which the server will be started.
+   */
+  address?: string;
+  /**
+   * The path the HTTP server will listen to.
+   * @default process.env.HTTP_POST_PATH ?? '/'
+   */
+  postPath?: `/${string}`;
+  /**
+   * The options to pass to the `createServer` function.
+   */
+  serverOptions?: ServerOptions;
+}
+export interface FetchOptions {
+  /**
+   * The path interactions are posted to.
+   * @default process.env.HTTP_POST_PATH ?? '/'
+   */
+  postPath?: string;
+}
+export declare namespace Client {
+  type Options = ClientOptions;
+  type LoggerOptions = ClientLoggerOptions;
+  type PieceLoadOptions = LoadOptions;
+  type ServerListenOptions = ListenOptions;
+  type ServerFetchOptions = FetchOptions;
+}
+declare module '@sapphire/pieces' {
+  interface StoreRegistryEntries {
+    commands: CommandStore;
+    'interaction-handlers': InteractionHandlerStore;
+    listeners: ListenerStore;
+  }
+  interface Container {
+    client: Client;
+    idParser: IIdParser;
+    rest: REST;
+    applicationCommandRegistry: ApplicationCommandRegistry;
+    logger: ILogger;
+  }
+}
+//#endregion
 //#region src/lib/api/HttpCodes.d.ts
 export declare enum HttpCodes {
   /**
@@ -1033,5 +3349,5 @@ export declare class Logger implements ILogger {
  */
 export type LoggerConsoleMethod = 'debug' | 'error' | 'info' | 'trace' | 'warn';
 //#endregion
-export { type AbortError, type AddFiles, AliasPiece, type AliasPieceOptions, AliasStore, ApplicationCommandRegistry, ApplicationCommandRegistryEntry, ArgumentTypes, type AsyncDiscordResult, AsyncPluginHooks, AutocompleteInteraction, AutocompleteInteractionArguments, AutocompleteResponseData, AutocompleteResponseOptions, BaseCommandInteractionType, BaseInteraction, BaseInteractionType, ChatInputCommandInteraction, Client, ClientEventAutocompleteContext, ClientEventCommandContext, ClientEventInteractionHandlerContext, ClientEventName, ClientEvents, ClientLoggerOptions, ClientOptions, Command, CommandInteraction, CommandRegistry, CommandRouter, CommandStore, CommandStoreRouter, DeferResponseData, DeferResponseOptions, DeferUpdateResult, type DiscordError, type DiscordResult, Events, ExtractedOptions, FollowupOptions, HMROptions, HotModuleReloader, HttpFrameworkPluginAsyncHook, HttpFrameworkPluginHook, HttpFrameworkPluginHookEntry, IIdParser, ILogger, IdParserRead, InGuild, Interaction, InteractionArguments, InteractionHandler, InteractionHandlerStore, Interactions, ListenOptions, Listener, ListenerStore, LoadOptions, LoaderError, type LoaderPieceContext, LogLevel, MakeArguments, MappedClientEvents, Message, MessageComponentButtonInteraction, MessageComponentChannelSelectInteraction, MessageComponentInteraction, MessageComponentInteractionType, MessageComponentMentionableSelectInteraction, MessageComponentRoleSelectInteraction, MessageComponentStringSelectInteraction as MessageComponentSelectMenuInteraction, MessageComponentStringSelectInteraction, MessageComponentUserSelectInteraction, MessageContextMenuCommandInteraction, MessageResponseData, MessageResponseOptions, MissingExportsError, ModalResponseData, ModalResponseOptions, ModalSubmitInteraction, type NonPingInteraction, PartialMessage, Piece, type PieceContext, type PieceOptions, Plugin, PluginHook, PluginManager, RegisterCommand, RegisterMessageCommand, RegisterSubcommand, RegisterSubcommandGroup, RegisterUserCommand, RequestAuthPrefix, RestrictGuildIds, Store, type StoreOptions, StoreRegistry, type StoreRegistryEntries, SyncPluginHooks, TransformedArguments, UpdateData, UpdateOptions, UpdateResponseOptions, UpdateResponseResult, UserContextMenuCommandInteraction, applicationCommandRegistry, container, extractTopLevelOptions, makeInteraction, postInitialization, postListen, preGenericsInitialization, preInitialization, preLoad, restrictedGuildIdRegistry, transformAutocompleteInteraction, transformInteraction, transformMessageInteraction, transformUserInteraction };
+export { type AbortError, type AddFiles, AliasPiece, type AliasPieceOptions, AliasStore, type AsyncDiscordResult, AutocompleteInteraction$1 as AutocompleteInteraction, type DiscordError, type DiscordResult, Interaction$1 as Interaction, LoaderError, type LoaderPieceContext, MessageComponentStringSelectInteraction as MessageComponentSelectMenuInteraction, MissingExportsError, type NonPingInteraction, Piece, type PieceContext, type PieceOptions, Store, type StoreOptions, StoreRegistry, type StoreRegistryEntries, container };
 //# sourceMappingURL=index.d.ts.map