@wolfstar/http-framework 2.2.2

package/dist/esm/index.js

@@ -0,0 +1,3354 @@
+import { AliasPiece, AliasStore, LoaderError, LoaderStrategy, MissingExportsError, Piece, Piece as Piece$1, Store, Store as Store$1, StoreRegistry, container, container as container$1 } from "@sapphire/pieces";
+import { REST, makeURLSearchParams } from "@discordjs/rest";
+import { isFunction, isNullish, isNullishOrEmpty } from "@sapphire/utilities";
+import { AsyncEventEmitter } from "@vladfrangu/async_event_emitter";
+import { ApplicationCommandOptionType, ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType, Routes } from "discord-api-types/v10";
+import { createServer } from "node:http";
+import { Result, err, ok } from "@sapphire/result";
+import { Collection } from "@discordjs/collection";
+import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from "@discordjs/builders";
+import { isJSONEncodable } from "@discordjs/util";
+import { webcrypto } from "node:crypto";
+import { TextDecoder } from "node:util";
+
+//#region src/lib/api/HttpCodes.ts
+let HttpCodes = /* @__PURE__ */ function(HttpCodes) {
+	/**
+	* Standard response for successful HTTP requests. The actual response will
+	* depend on the request method used. In a GET request, the response will
+	* contain an entity corresponding to the requested resource. In a POST
+	* request, the response will contain an entity describing or containing the
+	* result of the action.
+	*/
+	HttpCodes[HttpCodes["OK"] = 200] = "OK";
+	/**
+	* The request has been fulfilled, resulting in the creation of a new
+	* resource.
+	*/
+	HttpCodes[HttpCodes["Created"] = 201] = "Created";
+	/**
+	* The request has been accepted for processing, but the processing has not
+	* been completed. The request might or might not be eventually acted upon,
+	* and may be disallowed when processing occurs.
+	*/
+	HttpCodes[HttpCodes["Accepted"] = 202] = "Accepted";
+	/**
+	* The server is a transforming proxy (e.g. a Web accelerator) that received
+	* a 200 OK from its origin, but is returning a modified version of the
+	* origin's response.
+	*/
+	HttpCodes[HttpCodes["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+	/**
+	* The server successfully processed the request, and is not returning any
+	* content.
+	*/
+	HttpCodes[HttpCodes["NoContent"] = 204] = "NoContent";
+	/**
+	* The server successfully processed the request, asks that the requester
+	* reset its document view, and is not returning any content.
+	*/
+	HttpCodes[HttpCodes["ResetContent"] = 205] = "ResetContent";
+	/**
+	* (RFC 7233) The server is delivering only part of the resource (byte
+	* serving) due to a range header sent by the client. The range header is
+	* used by HTTP clients to enable resuming of interrupted downloads, or
+	* split a download into multiple simultaneous streams.
+	*/
+	HttpCodes[HttpCodes["PartialContent"] = 206] = "PartialContent";
+	/**
+	* (WebDAV; RFC 4918) The message body that follows is by default an XML
+	* message and can contain a number of separate response codes, depending on
+	* how many sub-requests were made.
+	*/
+	HttpCodes[HttpCodes["MultiStatus"] = 207] = "MultiStatus";
+	/**
+	* (WebDAV; RFC 5842) The members of a DAV binding have already been
+	* enumerated in a preceding part of the (multistatus) response, and are not
+	* being included again.
+	*/
+	HttpCodes[HttpCodes["AlreadyReported"] = 208] = "AlreadyReported";
+	/**
+	* (RFC 3229) The server has fulfilled a request for the resource, and the
+	* response is a representation of the result of one or more
+	* instance-manipulations applied to the current instance.
+	*/
+	HttpCodes[HttpCodes["IMUsed"] = 226] = "IMUsed";
+	/**
+	* Indicates multiple options for the resource from which the client may
+	* choose (via agent-driven content negotiation). For example, this code
+	* could be used to present multiple video format options, to list files
+	* with different filename extensions, or to suggest word-sense
+	* disambiguation.
+	*/
+	HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
+	/**
+	* This and all future requests should be directed to the given URI.
+	*/
+	HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
+	/**
+	* (Previously "Moved temporarily") Tells the client to look at (browse to)
+	* another URL. 302 has been superseded by 303 and 307. This is an example
+	* of industry practice contradicting the standard. The HTTP/1.0
+	* specification (RFC 1945) required the client to perform a temporary
+	* redirect (the original describing phrase was "Moved Temporarily"), but
+	* popular browsers implemented 302 with the functionality of a 303 See
+	* Other. Therefore, HTTP/1.1 added status codes 303 and 307 to distinguish
+	* between the two behaviours. However, some Web applications and frameworks
+	* use the 302 status code as if it were the 303.
+	*/
+	HttpCodes[HttpCodes["Found"] = 302] = "Found";
+	/**
+	* The response to the request can be found under another URI using the GET
+	* method. When received in response to a POST (or PUT/DELETE), the client
+	* should presume that the server has received the data and should issue a
+	* new GET request to the given URI.
+	*/
+	HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
+	/**
+	* (RFC 7232) Indicates that the resource has not been modified since the
+	* version specified by the request headers If-Modified-Since or
+	* If-None-Match. In such case, there is no need to retransmit the resource
+	* since the client still has a previously-downloaded copy.
+	*/
+	HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
+	/**
+	* The requested resource is available only through a proxy, the address for
+	* which is provided in the response. For security reasons, many HTTP
+	* clients (such as Mozilla Firefox and Internet Explorer) do not obey this
+	* status code.
+	*/
+	HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
+	/**
+	* No longer used. Originally meant "Subsequent requests should use the
+	* specified proxy.".
+	*/
+	HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
+	/**
+	* In this case, the request should be repeated with another URI; however,
+	* future requests should still use the original URI. In contrast to how 302
+	* was historically implemented, the request method is not allowed to be
+	* changed when reissuing the original request. For example, a POST request
+	* should be repeated using another POST request.
+	*/
+	HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+	/**
+	* (RFC 7538) The request and all future requests should be repeated using
+	* another URI. 307 and 308 parallel the behaviors of 302 and 301, but do
+	* not allow the HTTP method to change. So, for example, submitting a form
+	* to a permanently redirected resource may continue smoothly.
+	*/
+	HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
+	/**
+	* The server cannot or will not process the request due to an apparent
+	* client error (e.g., malformed request syntax, size too large, invalid
+	* request message framing, or deceptive request routing).
+	*/
+	HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
+	/**
+	* (RFC 7235) Similar to 403 Forbidden, but specifically for use when
+	* authentication is required and has failed or has not yet been provided.
+	* The response must include a WWW-Authenticate header field containing a
+	* challenge applicable to the requested resource. See Basic access
+	* authentication and Digest access authentication. 401 semantically means
+	* "unauthorised", the user does not have valid authentication credentials
+	* for the target resource.
+	*/
+	HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
+	/**
+	* Reserved for future use. The original intention was that this code might
+	* be used as part of some form of digital cash or micropayment scheme, as
+	* proposed, for example, by GNU Taler, but that has not yet happened, and
+	* this code is not widely used. Google Developers API uses this status if a
+	* particular developer has exceeded the daily limit on requests. Sipgate
+	* uses this code if an account does not have sufficient funds to start a
+	* call. Shopify uses this code when the store has not paid their fees and
+	* is temporarily disabled. Stripe uses this code for failed payments where
+	* parameters were correct, for example blocked fraudulent payments.
+	*/
+	HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
+	/**
+	* The request contained valid data and was understood by the server, but
+	* the server is refusing action. This may be due to the user not having the
+	* necessary permissions for a resource or needing an account of some sort,
+	* or attempting a prohibited action (e.g. creating a duplicate record
+	* where only one is allowed). This code is also typically used if the
+	* request provided authentication by answering the WWW-Authenticate header
+	* field challenge, but the server did not accept that authentication. The
+	* request should not be repeated.
+	*/
+	HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
+	/**
+	* The requested resource could not be found but may be available in the
+	* future. Subsequent requests by the client are permissible.
+	*/
+	HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
+	/**
+	* A request method is not supported for the requested resource; for example,
+	* a GET request on a form that requires data to be presented via POST, or a
+	* PUT request on a read-only resource.
+	*/
+	HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+	/**
+	* The requested resource is capable of generating only content not
+	* acceptable according to the Accept headers sent in the request. See Content negotiation.
+	*/
+	HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
+	/**
+	* (RFC 7235) The client must first authenticate itself with the proxy.
+	*/
+	HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+	/**
+	* The server timed out waiting for the request. According to HTTP
+	* specifications: "The client did not produce a request within the time
+	* that the server was prepared to wait. The client MAY repeat the request
+	* without modifications at any later time."
+	*/
+	HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
+	/**
+	* Indicates that the request could not be processed because of conflict in
+	* the current state of the resource, such as an edit conflict between
+	* multiple simultaneous updates.
+	*/
+	HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
+	/**
+	* Indicates that the resource requested is no longer available and will not
+	* be available again. This should be used when a resource has been
+	* intentionally removed and the resource should be purged. Upon receiving a
+	* 410 status code, the client should not request the resource in the future.
+	* Clients such as search engines should remove the resource from their
+	* indices. Most use cases do not require clients and search engines to
+	* purge the resource, and a "404 Not Found" may be used instead.
+	*/
+	HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
+	/**
+	* The request did not specify the length of its content, which is required
+	* by the requested resource.
+	*/
+	HttpCodes[HttpCodes["LengthRequired"] = 411] = "LengthRequired";
+	/**
+	* (RFC 7232) The server does not meet one of the preconditions that the
+	* requester put on the request header fields.
+	*/
+	HttpCodes[HttpCodes["PreconditionFailed"] = 412] = "PreconditionFailed";
+	/**
+	* (RFC 7231) The request is larger than the server is willing or able to
+	* process. Previously called "Request Entity Too Large".
+	*/
+	HttpCodes[HttpCodes["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+	/**
+	* (RFC 7231) The URI provided was too long for the server to process. Often
+	* the result of too much data being encoded as a query-string of a GET
+	* request, in which case it should be converted to a POST request. Called
+	* "Request-URI Too Long" previously.
+	*/
+	HttpCodes[HttpCodes["URITooLong"] = 414] = "URITooLong";
+	/**
+	* (RFC 7231) The request entity has a media type which the server or
+	* resource does not support. For example, the client uploads an image as
+	* image/svg+xml, but the server requires that images use a different format.
+	*/
+	HttpCodes[HttpCodes["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+	/**
+	* (RFC 7233) The client has asked for a portion of the file (byte serving),
+	* but the server cannot supply that portion. For example, if the client
+	* asked for a part of the file that lies beyond the end of the file. Called
+	* "Requested Range Not Satisfiable" previously.
+	*/
+	HttpCodes[HttpCodes["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+	/**
+	* The server cannot meet the requirements of the Expect request-header
+	* field.
+	*/
+	HttpCodes[HttpCodes["ExpectationFailed"] = 417] = "ExpectationFailed";
+	/**
+	* (RFC 2324, RFC 7168) This code was defined in 1998 as one of the
+	* traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot
+	* Control Protocol, and is not expected to be implemented by actual HTTP
+	* servers. The RFC specifies this code should be returned by teapots
+	* requested to brew coffee. This HTTP status is used as an Easter egg in
+	* some websites, such as Google.com's I'm a teapot easter egg.
+	*/
+	HttpCodes[HttpCodes["IAmATeapot"] = 418] = "IAmATeapot";
+	/**
+	* Returned by the Twitter Search and Trends API when the client is being rate limited.
+	* The text is a quote from 'Demolition Man' and the '420' code is likely a reference
+	* to this number's association with marijuana. Other services may wish to implement
+	* the 429 Too Many Requests response code instead.
+	*/
+	HttpCodes[HttpCodes["EnhanceYourCalm"] = 420] = "EnhanceYourCalm";
+	/**
+	* (RFC 7540) The request was directed at a server that is not able to
+	* produce a response (for example because of connection reuse).
+	*/
+	HttpCodes[HttpCodes["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+	/**
+	* (WebDAV; RFC 4918) The request was well-formed but was unable to be
+	* followed due to semantic errors.
+	*/
+	HttpCodes[HttpCodes["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+	/**
+	* (WebDAV; RFC 4918) The resource that is being accessed is locked.
+	*/
+	HttpCodes[HttpCodes["Locked"] = 423] = "Locked";
+	/**
+	* (WebDAV; RFC 4918) The request failed because it depended on another
+	* request and that request failed (e.g., a PROPPATCH).
+	*/
+	HttpCodes[HttpCodes["FailedDependency"] = 424] = "FailedDependency";
+	/**
+	* (RFC 8470) Indicates that the server is unwilling to risk processing a
+	* request that might be replayed.
+	*/
+	HttpCodes[HttpCodes["TooEarly"] = 425] = "TooEarly";
+	/**
+	* The client should switch to a different protocol such as TLS/1.0, given
+	* in the Upgrade header field.
+	*/
+	HttpCodes[HttpCodes["UpgradeRequired"] = 426] = "UpgradeRequired";
+	/**
+	* (RFC 6585) The origin server requires the request to be conditional.
+	* Intended to prevent the 'lost update' problem, where a client GETs a
+	* resource's state, modifies it, and PUTs it back to the server, when
+	* meanwhile a third party has modified the state on the server, leading to
+	* a conflict.
+	*/
+	HttpCodes[HttpCodes["PreconditionRequired"] = 428] = "PreconditionRequired";
+	/**
+	* (RFC 6585) The user has sent too many requests in a given amount of time.
+	* Intended for use with rate-limiting schemes.
+	*/
+	HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
+	/**
+	* (RFC 6585) The server is unwilling to process the request because either
+	* an individual header field, or all the header fields collectively, are
+	* too large.
+	*/
+	HttpCodes[HttpCodes["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+	/**
+	* (RFC 7725) A server operator has received a legal demand to deny access
+	* to a resource or to a set of resources that includes the requested
+	* resource. The code 451 was chosen as a reference to the novel Fahrenheit
+	* 451 (see the Acknowledgements in the RFC).
+	*/
+	HttpCodes[HttpCodes["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+	/**
+	* A generic error message, given when an unexpected condition was
+	* encountered and no more specific message is suitable.
+	*/
+	HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
+	/**
+	* The server either does not recognize the request method, or it lacks the
+	* ability to fulfil the request. Usually this implies future availability
+	* (e.g., a new feature of a web-service API).
+	*/
+	HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
+	/**
+	* The server was acting as a gateway or proxy and received an invalid
+	* response from the upstream server.
+	*/
+	HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
+	/**
+	* The server cannot handle the request (because it is overloaded or down
+	* for maintenance). Generally, this is a temporary state.
+	*/
+	HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+	/**
+	* The server was acting as a gateway or proxy and did not receive a timely
+	* response from the upstream server.
+	*/
+	HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
+	/**
+	* The server does not support the HTTP protocol version used in the request.
+	*/
+	HttpCodes[HttpCodes["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+	/**
+	* (RFC 2295) Transparent content negotiation for the request results in a
+	* circular reference.
+	*/
+	HttpCodes[HttpCodes["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+	/**
+	* (WebDAV; RFC 4918) The server is unable to store the representation
+	* needed to complete the request.
+	*/
+	HttpCodes[HttpCodes["InsufficientStorage"] = 507] = "InsufficientStorage";
+	/**
+	* (WebDAV; RFC 5842) The server detected an infinite loop while processing
+	* the request (sent instead of 208 Already Reported).
+	*/
+	HttpCodes[HttpCodes["LoopDetected"] = 508] = "LoopDetected";
+	/**
+	* (RFC 2774) Further extensions to the request are required for the server
+	* to fulfil it.
+	*/
+	HttpCodes[HttpCodes["NotExtended"] = 510] = "NotExtended";
+	/**
+	* (RFC 6585) The client needs to authenticate to gain network access.
+	* Intended for use by intercepting proxies used to control access to the
+	* network (e.g., "captive portals" used to require agreement to Terms of
+	* Service before granting full Internet access via a Wi-Fi hotspot).
+	*/
+	HttpCodes[HttpCodes["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+	return HttpCodes;
+}({});
+
+//#endregion
+//#region src/lib/components/StringIdParser.ts
+var StringIdParser = class {
+	run(customId) {
+		if (customId.length === 0) return null;
+		const index = customId.indexOf(".");
+		if (index === -1) return {
+			name: customId,
+			content: null
+		};
+		return {
+			name: customId.slice(0, index),
+			content: customId.slice(index + 1).split(".").map((contentEntry) => contentEntry || null)
+		};
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/decorators/_shared.ts
+function ensureChatInputCommandResolver(target) {
+	return container$1.applicationCommandRegistry.ensure(target).makeChatInput();
+}
+function ensureContextMenuCommandResolver(target) {
+	return container$1.applicationCommandRegistry.ensure(target).makeContextMenu();
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RegisterCommand.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!');
+* 	}
+* }
+* ```
+*/
+function RegisterCommand(data) {
+	return function decorate(target) {
+		ensureChatInputCommandResolver(target).setCommand(data);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RegisterMessageCommand.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) {
+* 		// ...
+* 	}
+* }
+* ```
+*/
+function RegisterMessageCommand(data) {
+	return function decorate(target, method) {
+		ensureContextMenuCommandResolver(target.constructor).setCommand(data, ApplicationCommandType.Message, method);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RegisterSubcommand.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!');
+* 	}
+* }
+* ```
+*/
+function RegisterSubcommand(data, subCommandGroupName) {
+	return function decorate(target, method) {
+		ensureChatInputCommandResolver(target.constructor).addSubcommand(data, method, subCommandGroupName);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RegisterSubcommandGroup.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!');
+* 	}
+* }
+* ```
+*/
+function RegisterSubcommandGroup(data) {
+	return function decorate(target, method) {
+		ensureChatInputCommandResolver(target.constructor).addSubcommandGroup(data, method);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RegisterUserCommand.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) {
+* 		// ...
+* 	}
+* }
+* ```
+*/
+function RegisterUserCommand(data) {
+	return function decorate(target, method) {
+		ensureContextMenuCommandResolver(target.constructor).setCommand(data, ApplicationCommandType.User, method);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/decorators/RestrictGuildIds.ts
+const restrictedGuildIdRegistry = new Collection();
+/**
+* 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!');
+* 	}
+* }
+* ```
+*/
+function RestrictGuildIds(guildIds) {
+	return function decorate(target) {
+		restrictedGuildIdRegistry.set(target, guildIds);
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/resolvers/InteractionOptions.ts
+function transformInteraction(resolved, options) {
+	const extracted = extractTopLevelOptions(options);
+	return {
+		subCommand: extracted.subCommand?.name ?? null,
+		subCommandGroup: extracted.subCommandGroup?.name ?? null,
+		...transformArguments(resolved, extracted.options)
+	};
+}
+function transformAutocompleteInteraction(resolved, options) {
+	const extracted = extractTopLevelOptions(options);
+	const focused = extracted.options.find((option) => option.focused);
+	return {
+		subCommand: extracted.subCommand?.name ?? null,
+		subCommandGroup: extracted.subCommandGroup?.name ?? null,
+		focused: typeof focused === "undefined" ? null : focused.name,
+		...transformArguments(resolved, extracted.options)
+	};
+}
+function extractTopLevelOptions(options) {
+	if (options.length) {
+		const [firstOption] = options;
+		if (firstOption.type === ApplicationCommandOptionType.SubcommandGroup) {
+			const subCommand = firstOption.options[0];
+			return {
+				subCommandGroup: firstOption,
+				subCommand,
+				options: subCommand.options ?? []
+			};
+		}
+		if (firstOption.type === ApplicationCommandOptionType.Subcommand) return {
+			subCommandGroup: null,
+			subCommand: firstOption,
+			options: firstOption.options ?? []
+		};
+	}
+	return {
+		subCommandGroup: null,
+		subCommand: null,
+		options
+	};
+}
+function transformArguments(resolved, options) {
+	return Object.fromEntries(options.map((option) => [option.name, transformArgument(resolved, option)]));
+}
+function transformArgument(resolved, option) {
+	switch (option.type) {
+		case ApplicationCommandOptionType.Attachment: return resolved.attachments?.[option.value] ?? { id: option.value };
+		case ApplicationCommandOptionType.Channel: return resolved.channels?.[option.value] ?? { id: option.value };
+		case ApplicationCommandOptionType.Mentionable: return transformMentionable(resolved, option);
+		case ApplicationCommandOptionType.Role: return resolved.roles?.[option.value] ?? { id: option.value };
+		case ApplicationCommandOptionType.User: return {
+			id: option.value,
+			user: resolved.users?.[option.value] ?? null,
+			member: resolved.members?.[option.value] ?? null
+		};
+		default: return option.value;
+	}
+}
+function transformMentionable(resolved, option) {
+	const id = option.value;
+	const user = resolved.users?.[id];
+	if (user) return {
+		id,
+		user,
+		member: resolved.members?.[id] ?? null
+	};
+	const channel = resolved.channels?.[id];
+	if (channel) return {
+		id,
+		channel
+	};
+	const role = resolved.roles?.[id];
+	if (role) return {
+		id,
+		role
+	};
+	return { id };
+}
+function transformUserInteraction(data) {
+	return {
+		id: data.target_id,
+		user: data.resolved.users[data.target_id],
+		member: data.resolved.members?.[data.target_id] ?? null
+	};
+}
+function transformMessageInteraction(data) {
+	return {
+		id: data.target_id,
+		message: data.resolved.messages[data.target_id]
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/shared/link.ts
+const linkSymbol = Symbol("decorated-command.method.link");
+/**
+* Links the specified object with a name.
+*
+* @template T - The type of the object.
+* @param object - The object to link.
+* @param name - The name to link the object with.
+* @returns The linked object.
+* @internal
+*/
+function linkMethod(object, name) {
+	Object.defineProperty(object, linkSymbol, { value: name });
+	return object;
+}
+/**
+* Retrieves the linked method from the given object.
+*
+* @param object - The object from which to retrieve the method.
+* @returns The name of the linked method as a string, or `null` if not found.
+* @internal
+*/
+function getLinkedMethod(object) {
+	return Reflect.get(object, linkSymbol) ?? null;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region src/lib/interactions/resolvers/ChatInputCommandResolver.ts
+var _data$1 = /* @__PURE__ */ new WeakMap();
+var _commandData$1 = /* @__PURE__ */ new WeakMap();
+var _subcommandGroupData = /* @__PURE__ */ new WeakMap();
+var _subcommandData = /* @__PURE__ */ new WeakMap();
+var _ChatInputCommandResolver_brand = /* @__PURE__ */ new WeakSet();
+/**
+* The command resolver for chat input commands.
+* @internal
+*/
+var ChatInputCommandResolver = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _ChatInputCommandResolver_brand);
+		_classPrivateFieldInitSpec(this, _data$1, null);
+		_classPrivateFieldInitSpec(this, _commandData$1, null);
+		_classPrivateFieldInitSpec(this, _subcommandGroupData, []);
+		_classPrivateFieldInitSpec(this, _subcommandData, []);
+	}
+	/**
+	* Sets the command data for the ChatInputCommandResolver.
+	*
+	* @param data - The command data to set.
+	* @returns The instance of ChatInputCommandResolver.
+	*/
+	setCommand(data) {
+		_classPrivateFieldSet2(_commandData$1, this, data);
+		return 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, method) {
+		_classPrivateFieldGet2(_subcommandGroupData, this).push([method ?? null, data]);
+		return 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, method, groupName) {
+		_classPrivateFieldGet2(_subcommandData, this).push([
+			method ?? null,
+			groupName ?? null,
+			data
+		]);
+		return this;
+	}
+	/**
+	* Converts the ChatInputCommandResolver instance to a JSON representation.
+	*
+	* @returns The JSON representation of the ChatInputCommandResolver instance.
+	*/
+	toJSON() {
+		return _classPrivateFieldGet2(_data$1, this) ?? _classPrivateFieldSet2(_data$1, this, _assertClassBrand(_ChatInputCommandResolver_brand, this, _resolve$1).call(this));
+	}
+};
+/**
+* Resolves the chat input command.
+*
+* @returns The resolved command.
+*/
+function _resolve$1() {
+	const command = _assertClassBrand(_ChatInputCommandResolver_brand, this, _normalizeCommand).call(this, _classPrivateFieldGet2(_commandData$1, this));
+	_assertClassBrand(_ChatInputCommandResolver_brand, this, _resolveSubcommandGroups).call(this, command);
+	_assertClassBrand(_ChatInputCommandResolver_brand, this, _resolveSubcommands).call(this, command);
+	return command;
+}
+/**
+* Resolves the subcommand groups for the given command.
+*
+* @param command The resolved command.
+*/
+function _resolveSubcommandGroups(command) {
+	if (_classPrivateFieldGet2(_subcommandGroupData, this).length === 0) return;
+	command.options ??= [];
+	for (const [method, entry] of _classPrivateFieldGet2(_subcommandGroupData, this)) {
+		let data = _assertClassBrand(_ChatInputCommandResolver_brand, this, _normalizeSubcommandGroup).call(this, entry);
+		const index = command.options.findIndex((option) => option.name === data.name);
+		if (index === -1) command.options.push(data);
+		else {
+			data = _assertClassBrand(_ChatInputCommandResolver_brand, this, _mergeOption).call(this, command.options[index], data);
+			command.options[index] = data;
+		}
+		if (method) linkMethod(data, method);
+	}
+}
+/**
+* Resolves the subcommands for a given command.
+*
+* @param command - The resolved command object.
+*/
+function _resolveSubcommands(command) {
+	if (_classPrivateFieldGet2(_subcommandData, this).length === 0) return;
+	command.options ??= [];
+	for (const [method, groupName, entry] of _classPrivateFieldGet2(_subcommandData, this)) {
+		let data = _assertClassBrand(_ChatInputCommandResolver_brand, this, _normalizeSubcommand).call(this, entry);
+		let parent;
+		if (groupName === null) parent = command;
+		else {
+			const group = command.options.find((option) => option.name === groupName);
+			if (group === void 0) throw new Error(`The command '${command.name}' has no subcommand group named '${groupName}'`);
+			if (group.type !== ApplicationCommandOptionType.SubcommandGroup) throw new Error(`The command '${command.name}' has an option named '${groupName}' that is not a group`);
+			parent = group;
+		}
+		parent.options ??= [];
+		const index = parent.options.findIndex((option) => option.name === data.name);
+		if (index === -1) parent.options.push(data);
+		else {
+			data = _assertClassBrand(_ChatInputCommandResolver_brand, this, _mergeOption).call(this, parent.options[index], data);
+			parent.options[index] = data;
+		}
+		if (!method) continue;
+		const dataMethod = getLinkedMethod(data);
+		if (dataMethod) {
+			if (dataMethod !== method) throw new Error(`The command '${command.name}' has a subcommand named '${data.name}' that was already linked to '${dataMethod}'`);
+		} else linkMethod(data, method);
+	}
+}
+/**
+* Normalizes the command data and returns the resolved command.
+*
+* @param data The command data to be normalized.
+* @returns The resolved command.
+* @throws An `Error` if the command data is null or undefined.
+*/
+function _normalizeCommand(data) {
+	if (isNullish(data)) throw new Error("Could not normalize command data");
+	if (isFunction(data)) {
+		const builder = new SlashCommandBuilder();
+		data = data(builder) ?? builder;
+	}
+	return {
+		type: ApplicationCommandType.ChatInput,
+		...isJSONEncodable(data) ? data.toJSON() : data
+	};
+}
+/**
+* Normalizes the subcommand group data and returns the resolved subcommand group.
+*
+* @param data - The subcommand group data to be normalized.
+* @returns The normalized subcommand group.
+*/
+function _normalizeSubcommandGroup(data) {
+	if (isFunction(data)) {
+		const builder = new SlashCommandSubcommandGroupBuilder();
+		data = data(builder) ?? builder;
+	}
+	return {
+		type: ApplicationCommandOptionType.SubcommandGroup,
+		...isJSONEncodable(data) ? data.toJSON() : data
+	};
+}
+/**
+* Normalizes the subcommand data and returns the resolved subcommand.
+*
+* @param data - The subcommand data to be normalized.
+* @returns The resolved subcommand.
+*/
+function _normalizeSubcommand(data) {
+	if (isFunction(data)) {
+		const builder = new SlashCommandSubcommandBuilder();
+		data = data(builder) ?? builder;
+	}
+	return {
+		type: ApplicationCommandOptionType.Subcommand,
+		...isJSONEncodable(data) ? data.toJSON() : data
+	};
+}
+/**
+* Merges two arrays of {@linkcode APIApplicationCommandOption} objects.
+*
+* - If the 'existing' array is empty or undefined, the 'data' array is returned.
+* - If the 'data' array is empty or undefined, the 'existing' array is returned.
+* - If both arrays have elements, the options with the same name are merged.
+*
+* @param existing The existing array of {@linkcode APIApplicationCommandOption} objects.
+* @param data The data array of {@linkcode APIApplicationCommandOption} objects.
+* @returns The merged array of {@linkcode APIApplicationCommandOption} objects.
+*/
+function _mergeOptions(existing, data) {
+	if (!existing?.length) return data ?? [];
+	if (!data?.length) return existing;
+	const entries = new Map(existing.map((option) => [option.name, option]));
+	for (const option of data) entries.set(option.name, _assertClassBrand(_ChatInputCommandResolver_brand, this, _mergeOption).call(this, entries.get(option.name), option));
+	return [...entries.values()];
+}
+/**
+* Merges two {@linkcode APIApplicationCommandOption} objects.
+*
+* - If the `existing` option is not provided, the `data` option is returned.
+* - If the types of the existing and data options do not match, a {@link TypeError} is thrown.
+* - If both existing and data options have 'options' property, the options are recursively merged.
+* - Otherwise, the options are shallow merged.
+* - If a method is present in either the data or existing option, it is linked to the merged option.
+*
+* @param existing - The existing {@linkcode APIApplicationCommandOption} object.
+* @param data - The data {@linkcode APIApplicationCommandOption} object.
+* @returns The merged {@linkcode APIApplicationCommandOption} object.
+*/
+function _mergeOption(existing, data) {
+	if (!existing) return data;
+	if (existing.type !== data.type) {
+		const existingType = ApplicationCommandOptionType[existing.type];
+		const dataType = ApplicationCommandOptionType[data.type];
+		throw new TypeError(`Mismatching types, expected '${existingType}', but received '${dataType}'`);
+	}
+	const merged = "options" in existing && "options" in data ? {
+		...existing,
+		...data,
+		options: _assertClassBrand(_ChatInputCommandResolver_brand, this, _mergeOptions).call(this, existing.options, data.options)
+	} : {
+		...existing,
+		...data
+	};
+	const method = getLinkedMethod(data) ?? getLinkedMethod(existing);
+	return method ? linkMethod(merged, method) : merged;
+}
+
+//#endregion
+//#region src/lib/interactions/resolvers/ContextMenuCommandResolver.ts
+var _data = /* @__PURE__ */ new WeakMap();
+var _commandData = /* @__PURE__ */ new WeakMap();
+var _commandType = /* @__PURE__ */ new WeakMap();
+var _commandMethod = /* @__PURE__ */ new WeakMap();
+var _ContextMenuCommandResolver_brand = /* @__PURE__ */ new WeakSet();
+/**
+* The command resolver for context menu commands.
+* @internal
+*/
+var ContextMenuCommandResolver = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _ContextMenuCommandResolver_brand);
+		_classPrivateFieldInitSpec(this, _data, null);
+		_classPrivateFieldInitSpec(this, _commandData, null);
+		_classPrivateFieldInitSpec(this, _commandType, null);
+		_classPrivateFieldInitSpec(this, _commandMethod, null);
+	}
+	/**
+	* 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, type, method) {
+		_classPrivateFieldSet2(_commandData, this, data);
+		_classPrivateFieldSet2(_commandType, this, type);
+		_classPrivateFieldSet2(_commandMethod, this, method ?? null);
+		return this;
+	}
+	/**
+	* Converts the {@linkcode ContextMenuCommandResolver} instance to a JSON representation.
+	*
+	* @returns The JSON representation of the {@linkcode ContextMenuCommandResolver} instance.
+	*/
+	toJSON() {
+		return _classPrivateFieldGet2(_data, this) ?? _classPrivateFieldSet2(_data, this, _assertClassBrand(_ContextMenuCommandResolver_brand, this, _resolve).call(this));
+	}
+};
+/**
+* Resolves the context menu command.
+*
+* @returns The resolved command.
+*/
+function _resolve() {
+	const data = _classPrivateFieldGet2(_commandData, this);
+	const type = _classPrivateFieldGet2(_commandType, this);
+	if (isNullish(data) || isNullish(type)) throw new Error("Could not normalize command data");
+	const resolved = _assertClassBrand(_ContextMenuCommandResolver_brand, this, _normalizeContextMenuCommand).call(this, data, type);
+	return _classPrivateFieldGet2(_commandMethod, this) ? linkMethod(resolved, _classPrivateFieldGet2(_commandMethod, this)) : resolved;
+}
+/**
+* Normalizes the context menu command.
+*
+* @param data - The command data.
+* @param type - The command type.
+* @returns The normalized context menu command.
+*/
+function _normalizeContextMenuCommand(data, type) {
+	if (isFunction(data)) {
+		const builder = new ContextMenuCommandBuilder().setType(type);
+		data = data(builder) ?? builder;
+	}
+	return {
+		type,
+		...isJSONEncodable(data) ? data.toJSON() : data
+	};
+}
+
+//#endregion
+//#region src/lib/interactions/shared/ApplicationCommandRegistryEntry.ts
+var _chatInput = /* @__PURE__ */ new WeakMap();
+var _contextMenu = /* @__PURE__ */ new WeakMap();
+var _ids = /* @__PURE__ */ new WeakMap();
+/**
+* Represents an entry in the application command registry.
+*
+* This class provides methods to manage and manipulate application command data.
+*
+* @since 2.0.0
+*/
+var ApplicationCommandRegistryEntry = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _chatInput, null);
+		_classPrivateFieldInitSpec(this, _contextMenu, []);
+		_classPrivateFieldInitSpec(this, _ids, new Collection());
+	}
+	/**
+	* 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() {
+		return _classPrivateFieldGet2(_ids, this).get(null) ?? 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) {
+		_classPrivateFieldGet2(_ids, this).set(null, value);
+		return 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) {
+		return _classPrivateFieldGet2(_ids, this).get(guildId) ?? 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, value) {
+		_classPrivateFieldGet2(_ids, this).set(guildId, value);
+		return this;
+	}
+	/**
+	* Gets the chat input command resolver.
+	*
+	* @since 2.0.0
+	* @returns The chat input command resolver or `null` if not set.
+	*/
+	get chatInput() {
+		return _classPrivateFieldGet2(_chatInput, this);
+	}
+	/**
+	* 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() {
+		return _classPrivateFieldGet2(_contextMenu, this);
+	}
+	/**
+	* Converts the {@linkcode ApplicationCommandRegistryEntry} to a JSON representation.
+	*
+	* @since 2.0.0
+	* @returns An array of Command objects in JSON format.
+	*/
+	toJSON() {
+		return _classPrivateFieldGet2(_chatInput, this) === null ? _classPrivateFieldGet2(_contextMenu, this).map((command) => command.toJSON()) : [_classPrivateFieldGet2(_chatInput, this).toJSON(), ..._classPrivateFieldGet2(_contextMenu, this).map((command) => command.toJSON())];
+	}
+	/**
+	* 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() {
+		return _classPrivateFieldGet2(_chatInput, this) ?? _classPrivateFieldSet2(_chatInput, this, new 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() {
+		const resolver = new ContextMenuCommandResolver();
+		_classPrivateFieldGet2(_contextMenu, this).push(resolver);
+		return resolver;
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/shared/ApplicationCommandRegistry.ts
+var _entries = /* @__PURE__ */ new WeakMap();
+var _rest = /* @__PURE__ */ new WeakMap();
+var _clientId = /* @__PURE__ */ new WeakMap();
+var _authPrefix = /* @__PURE__ */ new WeakMap();
+var _ApplicationCommandRegistry_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Represents a registry for application commands.
+*
+* @remarks This registry is globally available through {@linkcode container.applicationCommandRegistry}.
+* @since 2.0.0
+*/
+var ApplicationCommandRegistry = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _ApplicationCommandRegistry_brand);
+		_classPrivateFieldInitSpec(this, _entries, new Collection());
+		_classPrivateFieldInitSpec(this, _rest, null);
+		_classPrivateFieldInitSpec(this, _clientId, null);
+		_classPrivateFieldInitSpec(this, _authPrefix, "Bot");
+	}
+	get store() {
+		return container$1.stores.get("commands");
+	}
+	/**
+	* 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) {
+		_classPrivateFieldSet2(_rest, this, options.rest);
+		_classPrivateFieldSet2(_clientId, this, options.clientId);
+		_classPrivateFieldSet2(_authPrefix, this, options.authPrefix ?? "Bot");
+		return 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(target) {
+		return _classPrivateFieldGet2(_entries, this).get(target) ?? 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(target) {
+		return _classPrivateFieldGet2(_entries, this).delete(target);
+	}
+	/**
+	* 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(target) {
+		return _classPrivateFieldGet2(_entries, this).ensure(target, () => new 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() {
+		return _classPrivateFieldGet2(_entries, this).map((entry) => entry.toJSON()).flat(1);
+	}
+	/**
+	* 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) {
+		if (baseUserDirectory !== null) container$1.stores.registerPath(baseUserDirectory);
+		return this.store.loadAll();
+	}
+	/**
+	* Retrieves the loaded chat input commands from the application command registry.
+	*
+	* @since 2.0.0
+	* @returns A collection of chat input commands.
+	*/
+	getLoadedChatInputCommands() {
+		const collection = new Collection();
+		for (const registryEntry of _classPrivateFieldGet2(_entries, this).values()) if (registryEntry.chatInput) collection.set(registryEntry.chatInput.toJSON().name, registryEntry);
+		return collection;
+	}
+	/**
+	* Retrieves the loaded context menu commands.
+	*
+	* @since 2.0.0
+	* @returns A collection of context menu commands.
+	*/
+	getLoadedContextMenuCommands() {
+		const collection = new Collection();
+		for (const registryEntry of _classPrivateFieldGet2(_entries, this).values()) for (const entry of registryEntry.contextMenu) collection.set(entry.toJSON().name, registryEntry);
+		return collection;
+	}
+	/**
+	* Retrieves the loaded global commands from the application command registry.
+	*
+	* @since 2.0.0
+	* @returns An array of loaded global commands.
+	*/
+	getLoadedGlobalCommands() {
+		return _classPrivateFieldGet2(_entries, this).filter((_, command) => !restrictedGuildIdRegistry.get(command)?.length).map((entry) => entry.toJSON()).flat(1);
+	}
+	/**
+	* 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() {
+		const collection = new Collection();
+		for (const [command, guildIds] of restrictedGuildIdRegistry) {
+			if (guildIds.length === 0) continue;
+			const entry = _classPrivateFieldGet2(_entries, this).get(command);
+			if (!entry) continue;
+			const commands = entry.toJSON();
+			for (const guildId of guildIds) collection.ensure(guildId, () => []).push(...commands);
+		}
+		return collection;
+	}
+	/**
+	* Registers all the non guild-restricted commands globally.
+	*
+	* @since 2.0.0
+	* @returns The raw result from registering the commands globally.
+	*/
+	pushGlobalCommands() {
+		return _assertClassBrand(_ApplicationCommandRegistry_brand, this, _push).call(this, Routes.applicationCommands(this.clientId), this.getLoadedGlobalCommands(), null);
+	}
+	/**
+	* 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) {
+		return _assertClassBrand(_ApplicationCommandRegistry_brand, this, _push).call(this, Routes.applicationGuildCommands(this.clientId, guildId), this.getLoadedGlobalCommands(), guildId);
+	}
+	/**
+	* 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) {
+		return _assertClassBrand(_ApplicationCommandRegistry_brand, this, _push).call(this, Routes.applicationGuildCommands(this.clientId, guildId), this.toJSON(), guildId);
+	}
+	/**
+	* Registers all the guild-restricted commands in their respective guilds.
+	*
+	* @returns The settled promises from all the guild command registrations.
+	*/
+	pushGuildRestrictedCommands() {
+		const promises = this.getLoadedGuildCommands().map((commands, guildId) => _assertClassBrand(_ApplicationCommandRegistry_brand, this, _push).call(this, Routes.applicationGuildCommands(this.clientId, guildId), commands, guildId));
+		return Promise.allSettled(promises);
+	}
+	get clientId() {
+		if (_classPrivateFieldGet2(_clientId, this) === null) throw new Error("The ApplicationCommandRegistry has not been setup yet.");
+		return _classPrivateFieldGet2(_clientId, this);
+	}
+};
+async function _push(route, body, guildId) {
+	if (_classPrivateFieldGet2(_rest, this) === null) throw new Error("The ApplicationCommandRegistry has not been setup yet.");
+	const entries = await _classPrivateFieldGet2(_rest, this).put(route, {
+		body,
+		authPrefix: _classPrivateFieldGet2(_authPrefix, this)
+	});
+	if (entries.length === 0) return entries;
+	const { router } = this.store;
+	for (const entry of entries) {
+		const registry = (entry.type === ApplicationCommandType.ChatInput ? router.getChatInput(entry.name) : router.getContextMenu(entry.name))?.registry;
+		if (!registry) continue;
+		if (guildId === null) registry.setGlobalId(entry.id);
+		else registry.setGuildId(guildId, entry.id);
+	}
+	return entries;
+}
+const applicationCommandRegistry = new ApplicationCommandRegistry();
+container$1.applicationCommandRegistry = applicationCommandRegistry;
+
+//#endregion
+//#region src/lib/utils/constants.ts
+const ErrorMessages = {
+	InternalError: JSON.stringify({ message: "Received an internal error" }),
+	InvalidBodySize: JSON.stringify({ message: "Request body exceeds maximum body size" }),
+	InvalidContentLengthInteger: JSON.stringify({ message: "Content-Length is not an integer number" }),
+	InvalidContentLengthNegative: JSON.stringify({ message: "Content-Length must not be zero or negative" }),
+	InvalidContentLengthTooBig: JSON.stringify({ message: "Content-Length is superior to the server's body size limit" }),
+	InvalidCustomId: JSON.stringify({ message: "Could not parse the `custom_id` field" }),
+	InvalidSignature: JSON.stringify({ message: "Received invalid signature" }),
+	MissingBodyData: JSON.stringify({ message: "Missing body data" }),
+	MissingCommandName: JSON.stringify({ message: "Missing command name" }),
+	MissingSignatureInformation: JSON.stringify({ message: "Missing signature information" }),
+	NotFound: JSON.stringify({ message: "Not found" }),
+	UnknownCommandHandler: JSON.stringify({ message: "Unknown command handler" }),
+	UnknownCommandName: JSON.stringify({ message: "Unknown command name" }),
+	UnknownHandlerName: JSON.stringify({ message: "Unknown handler name" }),
+	UnknownInteractionType: JSON.stringify({ message: "Received unknown interaction type" }),
+	UnsupportedHttpMethod: JSON.stringify({ message: "Unsupported HTTP method" })
+};
+const Payloads = { Pong: JSON.stringify({ type: InteractionResponseType.Pong }) };
+
+//#endregion
+//#region src/lib/interactions/structures/common/symbols.ts
+const Data = Symbol("data");
+const Response = Symbol("response");
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/BaseInteraction.ts
+var BaseInteraction = class {
+	constructor(response, data) {
+		_defineProperty(this, Data, void 0);
+		_defineProperty(this, Response, void 0);
+		this[Data] = data;
+		this[Response] = response;
+	}
+	get replied() {
+		return this[Response].writableEnded;
+	}
+	/**
+	* The ID of the interaction.
+	*/
+	get id() {
+		return this[Data].id;
+	}
+	/**
+	* The type of the interaction.
+	*/
+	get type() {
+		return this[Data].type;
+	}
+	/**
+	* Bitwise set of permissions the app or bot has within the channel the interaction was sent from.
+	*/
+	get app_permissions() {
+		return this[Data].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() {
+		return typeof this.app_permissions === "string" ? BigInt(this.app_permissions) : void 0;
+	}
+	/**
+	* The ID of the application the interaction is for.
+	*/
+	get application_id() {
+		return this[Data].application_id;
+	}
+	/**
+	* The ID of the application the interaction is for.
+	*
+	* @seealso {@link application_id} for the raw data.
+	*/
+	get applicationId() {
+		return this.application_id;
+	}
+	/**
+	* Mapping of installation contexts that the interaction was authorized for
+	* to related user or guild IDs.
+	*/
+	get authorizing_integration_owners() {
+		return this[Data].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() {
+		return this.authorizing_integration_owners;
+	}
+	/**
+	* The channel of the interaction.
+	*/
+	get channel() {
+		return this[Data].channel;
+	}
+	/**
+	* The channel the interaction was sent from.
+	* @deprecated Use {@link channel}.id instead.
+	*/
+	get channel_id() {
+		return this.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() {
+		return this.channel?.id;
+	}
+	/**
+	* Context where the interaction was triggered from.
+	*/
+	get context() {
+		return this[Data].context;
+	}
+	/**
+	* The command data payload.
+	*/
+	get data() {
+		return this[Data].data;
+	}
+	/**
+	* For monetized apps, any entitlements for the invoking user, representing
+	* access to premium SKUs.
+	*/
+	get entitlements() {
+		return this[Data].entitlements;
+	}
+	/**
+	* The guild the interaction was sent from.
+	*/
+	get guild_id() {
+		return this[Data].guild_id;
+	}
+	/**
+	* The guild the interaction was sent from.
+	*
+	* @seealso {@link guild_id} for the raw data.
+	*/
+	get guildId() {
+		return this.guild_id;
+	}
+	/**
+	* The guild's preferred locale, if invoked in a guild.
+	*/
+	get guild_locale() {
+		return this[Data].guild_locale;
+	}
+	/**
+	* The guild's preferred locale, if invoked in a guild.
+	*
+	* @seealso {@link guild_locale} for the raw data.
+	*/
+	get guildLocale() {
+		return this.guild_locale;
+	}
+	/**
+	* The selected language of the invoking user.
+	*/
+	get locale() {
+		return this[Data].locale;
+	}
+	/**
+	* Guild member data for the invoking user, including permissions.
+	*
+	* **This is only sent when an interaction is invoked in a guild**.
+	*/
+	get member() {
+		return this[Data].member;
+	}
+	/**
+	* A continuation token for responding to the interaction.
+	*/
+	get token() {
+		return this[Data].token;
+	}
+	/**
+	* User object for the invoking user.
+	*/
+	get user() {
+		return this[Data].member?.user ?? this[Data].user;
+	}
+	/**
+	* Read-only property, always `1`.
+	*/
+	get version() {
+		return this[Data].version;
+	}
+	/**
+	* Determines whether or not the interaction was sent from a guild.
+	* @returns The casted interaction type.
+	*/
+	inGuild() {
+		return !isNullish(this.guild_id);
+	}
+	/**
+	* Fetches the channel the interaction was sent from.
+	* @returns The fetched channel.
+	* @remarks **This requires REST to have a token.**
+	* @seealso {@link channel}.
+	*/
+	async fetchChannel() {
+		if (isNullishOrEmpty(this.channel)) return err(/* @__PURE__ */ new Error("The interaction was not sent from a channel"));
+		return resultFromDiscord(container$1.rest.get(Routes.channel(this.channel.id)));
+	}
+	/**
+	* Fetches the channel the interaction was sent from.
+	* @returns The fetched channel.
+	* @remarks **This requires REST to have a token.**
+	*/
+	async fetchGuild() {
+		if (isNullishOrEmpty(this.guildId)) return err(/* @__PURE__ */ new Error("The interaction was not sent from a guild"));
+		return resultFromDiscord(container$1.rest.get(Routes.guild(this.guildId)));
+	}
+	_sendReply(data) {
+		const response = this[Response];
+		if (response.writableEnded) throw new Error("Cannot send response, the request has already been replied.");
+		response.statusCode = 200;
+		return new Promise((resolve) => {
+			response.on("close", () => {
+				resolve();
+			});
+			response.end(JSON.stringify(data));
+		});
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/AutocompleteInteraction.ts
+var AutocompleteInteraction = class extends BaseInteraction {
+	/**
+	* Responds to the interaction with an autocomplete result.
+	* @param data The data to be sent.
+	*/
+	reply(data) {
+		const body = {
+			type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+			data
+		};
+		return this._sendReply(body);
+	}
+	/**
+	* Responds to the interaction with an empty autocomplete result.
+	*/
+	replyEmpty() {
+		return this.reply({ choices: [] });
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/CommandInteraction.ts
+var CommandInteraction = class extends BaseInteraction {
+	/**
+	* Responds to the interaction with a message.
+	* @param data The data to be sent.
+	*/
+	async reply(data) {
+		const body = {
+			type: InteractionResponseType.ChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new 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.
+	*/
+	async defer(data) {
+		const body = {
+			type: InteractionResponseType.DeferredChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new PartialMessage(this);
+	}
+	/**
+	* Responds to the interaction with a popup modal.
+	* @param data The data to be sent.
+	*/
+	showModal(data) {
+		const body = {
+			type: InteractionResponseType.Modal,
+			data
+		};
+		return this._sendReply(body);
+	}
+	/**
+	* Sends a follow-up message.
+	* @param data The data to be sent.
+	*/
+	async followup({ files, ...body }) {
+		return (await resultFromDiscord(container$1.rest.post(Routes.webhook(this.applicationId, this.token), {
+			body,
+			files,
+			auth: false
+		}))).map((message) => new Message(this, message));
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/base/MessageComponentInteraction.ts
+var MessageComponentInteraction = class extends BaseInteraction {
+	/**
+	* The message the interaction was attached to.
+	*/
+	get message() {
+		return this[Data].message;
+	}
+	/**
+	* ACK a button interaction and update it to a loading state.
+	*/
+	async deferUpdate() {
+		const body = { type: InteractionResponseType.DeferredMessageUpdate };
+		await this._sendReply(body);
+		return new 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.
+	*/
+	async update(data) {
+		const body = {
+			type: InteractionResponseType.UpdateMessage,
+			data
+		};
+		await this._sendReply(body);
+		return new PartialMessage(this);
+	}
+	/**
+	* Responds to the interaction with a message.
+	* @param data The data to be sent.
+	*/
+	async reply(data) {
+		const body = {
+			type: InteractionResponseType.ChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new 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.
+	*/
+	async defer(data) {
+		const body = {
+			type: InteractionResponseType.DeferredChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new PartialMessage(this);
+	}
+	/**
+	* Responds to the interaction with a popup modal.
+	* @param data The data to be sent.
+	*/
+	showModal(data) {
+		const body = {
+			type: InteractionResponseType.Modal,
+			data
+		};
+		return this._sendReply(body);
+	}
+	/**
+	* Sends a follow-up message.
+	* @param data The data to be sent.
+	*/
+	async followup({ files, ...body }) {
+		return (await resultFromDiscord(container$1.rest.post(Routes.webhook(this.applicationId, this.token), {
+			body,
+			files,
+			auth: false
+		}))).map((message) => new Message(this, message));
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/ChatInputCommandInteraction.ts
+var ChatInputCommandInteraction = class extends CommandInteraction {};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentButtonInteraction.ts
+var MessageComponentButtonInteraction = class extends MessageComponentInteraction {};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentChannelSelectInteraction.ts
+var MessageComponentChannelSelectInteraction = class extends MessageComponentInteraction {
+	/**
+	* Gets the IDs of the selected channels.
+	*/
+	get ids() {
+		return this.data.values;
+	}
+	/**
+	* Creates a collection with all the selected channels.
+	*
+	* @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.values}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+	*/
+	get channels() {
+		return new Collection(this.entries());
+	}
+	/**
+	* Returns an iterator of the selected channel IDs.
+	*
+	* @seealso {@link MessageComponentChannelSelectInteraction.ids}.
+	*/
+	*keys() {
+		yield* this.ids;
+	}
+	/**
+	* Returns an iterator of the selected channels.
+	*
+	* @seealso {@link MessageComponentChannelSelectInteraction.channels}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+	*/
+	*values() {
+		const { resolved } = this.data;
+		for (const id of this.ids) yield resolved.channels[id];
+	}
+	/**
+	* Returns an iterator of [ID, Channel] pairs.
+	*
+	* @seealso {@link MessageComponentChannelSelectInteraction.channels}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.values}.
+	*/
+	*entries() {
+		for (const value of this.values()) yield [value.id, value];
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentMentionableSelectInteraction.ts
+var MessageComponentMentionableSelectInteraction = class extends MessageComponentInteraction {
+	/**
+	* Gets the IDs of the selected users and roles.
+	*/
+	get ids() {
+		return this.data.values;
+	}
+	/**
+	* Creates a collection with all the selected users.
+	*
+	* @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+	* @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+	* @seealso {@link MessageComponentMentionableSelectInteraction.entries}.
+	*/
+	get users() {
+		const output = new Collection();
+		const { users, members } = this.data.resolved;
+		if (users) for (const user of Object.values(users)) output.set(user.id, {
+			id: user.id,
+			user,
+			member: members?.[user.id] ?? null
+		});
+		return output;
+	}
+	/**
+	* 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() {
+		const output = new Collection();
+		const { roles } = this.data.resolved;
+		if (roles) for (const role of Object.values(roles)) output.set(role.id, role);
+		return output;
+	}
+	/**
+	* 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() {
+		return new Collection(this.entries());
+	}
+	/**
+	* Returns an iterator of the selected users and roles IDs.
+	*
+	* @seealso {@link MessageComponentMentionableSelectInteraction.ids}.
+	*/
+	*keys() {
+		yield* this.ids;
+	}
+	/**
+	* 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() {
+		const { resolved } = this.data;
+		for (const id of this.ids) {
+			const user = resolved.users?.[id];
+			if (user) {
+				yield {
+					id,
+					user,
+					member: resolved.members?.[id] ?? null
+				};
+				continue;
+			}
+			const role = resolved.roles?.[id];
+			if (role) {
+				yield {
+					id,
+					role
+				};
+				continue;
+			}
+			yield { id };
+		}
+	}
+	/**
+	* Returns an iterator of [ID, Mentionable] pairs.
+	*
+	* @seealso {@link MessageComponentMentionableSelectInteraction.users}.
+	* @seealso {@link MessageComponentMentionableSelectInteraction.roles}.
+	* @seealso {@link MessageComponentMentionableSelectInteraction.keys}.
+	* @seealso {@link MessageComponentMentionableSelectInteraction.values}.
+	*/
+	*entries() {
+		for (const value of this.values()) yield [value.id, value];
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentRoleSelectInteraction.ts
+var MessageComponentRoleSelectInteraction = class extends MessageComponentInteraction {
+	/**
+	* Gets the IDs of the selected roles.
+	*/
+	get ids() {
+		return this.data.values;
+	}
+	/**
+	* Creates a collection with all the selected roles.
+	*
+	* @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.values}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.entries}.
+	*/
+	get roles() {
+		return new Collection(this.entries());
+	}
+	/**
+	* Returns an iterator of the selected role IDs.
+	*
+	* @seealso {@link MessageComponentRoleSelectInteraction.ids}.
+	*/
+	*keys() {
+		yield* this.ids;
+	}
+	/**
+	* Returns an iterator of the selected channels.
+	*
+	* @seealso {@link MessageComponentRoleSelectInteraction.roles}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.entries}.
+	*/
+	*values() {
+		const { resolved } = this.data;
+		for (const id of this.ids) yield resolved.roles[id];
+	}
+	/**
+	* Returns an iterator of [ID, Role] pairs.
+	*
+	* @seealso {@link MessageComponentRoleSelectInteraction.roles}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.keys}.
+	* @seealso {@link MessageComponentRoleSelectInteraction.values}.
+	*/
+	*entries() {
+		for (const value of this.values()) yield [value.id, value];
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentStringSelectInteraction.ts
+var MessageComponentStringSelectInteraction = class extends MessageComponentInteraction {
+	get values() {
+		return this.data.values ?? [];
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageComponentUserSelectInteraction.ts
+var MessageComponentUserSelectInteraction = class extends MessageComponentInteraction {
+	/**
+	* Gets the IDs of the selected users.
+	*/
+	get ids() {
+		return this.data.values;
+	}
+	/**
+	* Creates a collection with all the selected users.
+	*
+	* @seealso {@link MessageComponentChannelSelectInteraction.keys}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.values}.
+	* @seealso {@link MessageComponentChannelSelectInteraction.entries}.
+	*/
+	get users() {
+		return new Collection(this.entries());
+	}
+	/**
+	* Returns an iterator of the selected user IDs.
+	*
+	* @seealso {@link MessageComponentUserSelectInteraction.ids}.
+	*/
+	*keys() {
+		yield* this.ids;
+	}
+	/**
+	* Returns an iterator of the selected users.
+	*
+	* @seealso {@link MessageComponentUserSelectInteraction.users}.
+	* @seealso {@link MessageComponentUserSelectInteraction.keys}.
+	* @seealso {@link MessageComponentUserSelectInteraction.entries}.
+	*/
+	*values() {
+		const { resolved } = this.data;
+		for (const id of this.ids) yield {
+			id,
+			user: resolved.users[id],
+			member: resolved.members?.[id] ?? null
+		};
+	}
+	/**
+	* Returns an iterator of [ID, User] pairs.
+	*
+	* @seealso {@link MessageComponentUserSelectInteraction.channels}.
+	* @seealso {@link MessageComponentUserSelectInteraction.keys}.
+	* @seealso {@link MessageComponentUserSelectInteraction.values}.
+	*/
+	*entries() {
+		for (const value of this.values()) yield [value.user.id, value];
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/MessageContextMenuCommandInteraction.ts
+var MessageContextMenuCommandInteraction = class extends CommandInteraction {};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/ModalSubmitInteraction.ts
+var ModalSubmitInteraction = class extends BaseInteraction {
+	/**
+	* The message the interaction was attached to, if any.
+	*/
+	get message() {
+		return this[Data].message;
+	}
+	/**
+	* ACK a button interaction and update it to a loading state.
+	*/
+	async deferUpdate() {
+		const body = { type: InteractionResponseType.DeferredMessageUpdate };
+		await this._sendReply(body);
+		return new 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.
+	*/
+	async update(data) {
+		const body = {
+			type: InteractionResponseType.UpdateMessage,
+			data
+		};
+		await this._sendReply(body);
+		return new PartialMessage(this);
+	}
+	/**
+	* Responds to the interaction with a message.
+	* @param data The data to be sent.
+	*/
+	async reply(data) {
+		const body = {
+			type: InteractionResponseType.ChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new 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.
+	*/
+	async defer(data) {
+		const body = {
+			type: InteractionResponseType.DeferredChannelMessageWithSource,
+			data
+		};
+		await this._sendReply(body);
+		return new PartialMessage(this);
+	}
+	/**
+	* Sends a follow-up message.
+	* @param data The data to be sent.
+	*/
+	async followup({ files, ...body }) {
+		return (await resultFromDiscord(container$1.rest.post(Routes.webhook(this.applicationId, this.token), {
+			body,
+			files,
+			auth: false
+		}))).map((message) => new Message(this, message));
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/structures/interactions/UserContextMenuCommandInteraction.ts
+var UserContextMenuCommandInteraction = class extends CommandInteraction {};
+
+//#endregion
+//#region src/lib/interactions/utils/util.ts
+function makeInteraction(response, interaction) {
+	switch (interaction.type) {
+		case InteractionType.ApplicationCommand: switch (interaction.data.type) {
+			case ApplicationCommandType.ChatInput: return new ChatInputCommandInteraction(response, interaction);
+			case ApplicationCommandType.User: return new UserContextMenuCommandInteraction(response, interaction);
+			case ApplicationCommandType.Message: return new MessageContextMenuCommandInteraction(response, interaction);
+			case ApplicationCommandType.PrimaryEntryPoint: throw new Error("PrimaryEntryPoint is not supported");
+		}
+		case InteractionType.MessageComponent: switch (interaction.data.component_type) {
+			case ComponentType.Button: return new MessageComponentButtonInteraction(response, interaction);
+			case ComponentType.ChannelSelect: return new MessageComponentChannelSelectInteraction(response, interaction);
+			case ComponentType.MentionableSelect: return new MessageComponentMentionableSelectInteraction(response, interaction);
+			case ComponentType.RoleSelect: return new MessageComponentRoleSelectInteraction(response, interaction);
+			case ComponentType.StringSelect: return new MessageComponentStringSelectInteraction(response, interaction);
+			case ComponentType.UserSelect: return new MessageComponentUserSelectInteraction(response, interaction);
+		}
+		case InteractionType.ApplicationCommandAutocomplete: return new AutocompleteInteraction(response, interaction);
+		case InteractionType.ModalSubmit: return new ModalSubmitInteraction(response, interaction);
+	}
+}
+/**
+* Handles a received error. This function must only be called if the HTTP
+* interaction was not replied to.
+*
+* This function has a special case for string errors, which are translated to a
+* regular message with content as the error.
+*
+* When an error is thrown, the error is emitted in client, and a generic error
+* message is sent back to Discord.
+* @param response The HTTP request we can response to.
+* @param error The error to handle.
+* @returns The response object.
+*/
+function handleError(response, error) {
+	container$1.client.emit("error", error);
+	if (!container$1.client.httpReplyOnError || response.closed) return response;
+	response.statusCode = 500;
+	return response.end(ErrorMessages.InternalError);
+}
+function resultFromDiscord(promise) {
+	return Result.fromAsync(promise);
+}
+
+//#endregion
+//#region src/lib/interactions/structures/Message.ts
+var PartialMessage = class {
+	constructor(interaction) {
+		_defineProperty(this, "interaction", void 0);
+		this.interaction = interaction;
+	}
+	/**
+	* The ID of the message.
+	*/
+	get id() {
+		return "@original";
+	}
+	/**
+	* The thread, if the message started one.
+	*/
+	get thread() {}
+	/**
+	* Retrieves the message from Discord, returns a clone of the instance.
+	*/
+	async get() {
+		return (await resultFromDiscord(container$1.rest.get(Routes.webhookMessage(this.interaction.applicationId, this.interaction.token, this.id), {
+			auth: false,
+			query: makeURLSearchParams({ thread_id: this.thread?.id })
+		}))).map((data) => new Message(this.interaction, data));
+	}
+	/**
+	* Updates the message, returns a clone of the instance.
+	* @param data The data to be sent.
+	*/
+	async update({ files, ...body }) {
+		return (await resultFromDiscord(container$1.rest.patch(Routes.webhookMessage(this.interaction.applicationId, this.interaction.token, this.id), {
+			body,
+			files,
+			auth: false,
+			query: makeURLSearchParams({ thread_id: this.thread?.id })
+		}))).map((data) => new Message(this.interaction, data));
+	}
+	/**
+	* Deletes the message.
+	*/
+	async delete() {
+		return (await resultFromDiscord(container$1.rest.delete(Routes.webhookMessage(this.interaction.applicationId, this.interaction.token, this.id), {
+			auth: false,
+			query: makeURLSearchParams({ thread_id: this.thread?.id })
+		}))).map(() => this);
+	}
+};
+var Message = class extends PartialMessage {
+	constructor(interaction, data) {
+		super(interaction);
+		_defineProperty(this, Data, void 0);
+		this[Data] = data;
+	}
+	/**
+	* The ID of the message.
+	*
+	* @raw
+	*/
+	get id() {
+		return this[Data].id;
+	}
+	/**
+	* The ID of the channel the message is from.
+	*
+	* @raw
+	* @seealso {@link channelId} for the camelCase property.
+	*/
+	get channel_id() {
+		return this[Data].channel_id;
+	}
+	/**
+	* The ID of the channel the message is from.
+	*/
+	get channelId() {
+		return this.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() {
+		return this[Data].author;
+	}
+	/**
+	* The contents of the message.
+	*
+	* @raw
+	*/
+	get content() {
+		return this[Data].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() {
+		return this[Data].timestamp;
+	}
+	/**
+	* The timestamp the message was sent at.
+	*
+	* @seealso {@link timestamp} for the raw data.
+	*/
+	get createdTimestamp() {
+		return Date.parse(this.timestamp);
+	}
+	/**
+	* The {@link Date} version of {@link createdTimestamp}.
+	*/
+	get createdAt() {
+		return new Date(this.createdTimestamp);
+	}
+	/**
+	* 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() {
+		return this[Data].edited_timestamp;
+	}
+	/**
+	* The timestamp the message was edited at, `null` if it was never edited.
+	*/
+	get editedTimestamp() {
+		const value = this.edited_timestamp;
+		return isNullishOrEmpty(value) ? null : Date.parse(value);
+	}
+	/**
+	* The {@link Date} version of {@link editedTimestamp}.
+	*/
+	get editedAt() {
+		const value = this.editedTimestamp;
+		return isNullishOrEmpty(value) ? null : new Date(value);
+	}
+	/**
+	* Whether or not the message is a TTS message.
+	*
+	* @raw
+	*/
+	get tts() {
+		return this[Data].tts;
+	}
+	/**
+	* Whether or not the message mentioned everyone.
+	*
+	* @raw
+	* @seealso {@link mention_everyone} for the camelCase property.
+	*/
+	get mention_everyone() {
+		return this[Data].mention_everyone;
+	}
+	/**
+	* Whether or not the message mentioned everyone.
+	*
+	* @seealso {@link mention_everyone} for the raw data.
+	*/
+	get mentionEveryone() {
+		return this.mention_everyone;
+	}
+	/**
+	* The users specifically mentioned in the message.
+	*
+	* @raw
+	* @seealso {@link https://discord.com/developers/docs/resources/user#user-object}
+	*/
+	get mentions() {
+		return this[Data].mentions;
+	}
+	/**
+	* The roles specifically mentioned in the message.
+	*
+	* @raw
+	* @seealso {@link https://discord.com/developers/docs/topics/permissions#role-object}
+	*/
+	get mention_roles() {
+		return this[Data].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() {
+		return this.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() {
+		return this[Data].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() {
+		return this[Data].mention_channels ?? [];
+	}
+	/**
+	* A nonce that can be used for optimistic message sending (up to 25 characters).
+	*
+	* @raw
+	*/
+	get nonce() {
+		return this[Data].nonce;
+	}
+	/**
+	* Whether or not the message is pinned.
+	*
+	* @raw
+	*/
+	get pinned() {
+		return this[Data].pinned;
+	}
+	/**
+	* The attached files.
+	*
+	* @seealso {@link https://discord.com/developers/docs/resources/channel#attachment-object}
+	*/
+	get attachments() {
+		return this[Data].attachments;
+	}
+	/**
+	* The embedded content.
+	*
+	* @seealso {@link https://discord.com/developers/docs/resources/channel#embed-object}
+	*/
+	get embeds() {
+		return this[Data].embeds;
+	}
+	/**
+	* The reactions the message has.
+	*
+	* @seealso {@link https://discord.com/developers/docs/resources/channel#reaction-object}
+	*/
+	get reactions() {
+		return this[Data].reactions ?? [];
+	}
+	/**
+	* The webhook ID.
+	*/
+	get webhook_id() {
+		return this[Data].webhook_id;
+	}
+	/**
+	* The webhook ID.
+	*
+	* @seealso {@link webhook_id} for the raw data.
+	*/
+	get webhookId() {
+		return this.webhook_id ?? null;
+	}
+	/**
+	* The message's type.
+	*
+	* @seealso {@link https://discord.com/developers/docs/resources/channel#message-object-message-types}
+	*/
+	get type() {
+		return this[Data].type;
+	}
+	/**
+	* The thread, if the message started one.
+	*/
+	get thread() {
+		return this[Data].thread;
+	}
+	/**
+	* 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() {
+		return this[Data].flags;
+	}
+	/**
+	* The message's components, such as buttons, action rows, or other interactive components.
+	*/
+	get components() {
+		return this[Data].components ?? [];
+	}
+	/**
+	* The stickers the message contains, if any.
+	*/
+	get sticker_items() {
+		return this[Data].sticker_items;
+	}
+	/**
+	* The stickers the message contains, if any.
+	*
+	* @seealso {@link sticker_items} for the raw data.
+	*/
+	get stickerItems() {
+		return this.sticker_items ?? [];
+	}
+};
+
+//#endregion
+//#region src/lib/errors/ChatInputRouterError.ts
+/**
+* Represents an error that is thrown when a {@link ChatInputRouter} encounters an error.
+* @since 2.0.0
+*/
+var ChatInputRouterError = class extends Error {
+	constructor(key, command, group, subcommand) {
+		super(ChatInputRouterErrors[key](command.name, group?.name ?? "", subcommand?.name ?? ""));
+		_defineProperty(this, "key", void 0);
+		_defineProperty(this, "command", void 0);
+		_defineProperty(this, "group", void 0);
+		_defineProperty(this, "subcommand", void 0);
+		this.key = key;
+		this.command = command;
+		this.group = group ?? null;
+		this.subcommand = subcommand ?? null;
+	}
+	/**
+	* The path of the command that was being processed when the error was thrown.
+	* @since 2.0.0
+	*/
+	get path() {
+		return `${this.command.name}${this.group ? `/${this.group.name}` : ""}${this.subcommand ? `/${this.subcommand.name}` : ""}`;
+	}
+};
+const ChatInputRouterErrors = {
+	DuplicatedSubcommandGroup: (command, subcommandGroup) => `Duplicated subcommand group named '${subcommandGroup}' in command '${command}'`,
+	DuplicatedSubcommand: (command, subcommandGroup, subcommand) => `Duplicated subcommand named '${subcommand}' in subcommand group '${subcommandGroup}' in command '${command}'`,
+	SubcommandGroupLinkInvalid: (command, subcommandGroup) => `Subcommand group named '${subcommandGroup}' in command '${command}' is not linked to a method`,
+	SubcommandLinkInvalid: (command, subcommandGroup, subcommand) => `Subcommand named '${subcommand}' ${subcommandGroup ? `in subcommand group '${subcommandGroup}' ` : ""}in command '${command}' is not linked to a method`
+};
+
+//#endregion
+//#region src/lib/interactions/router/CommandRouterSubcommand.ts
+var _subcommandMapping$1 = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a subcommand in a command router.
+*
+* @template Options - The options type for the command.
+* @internal
+*/
+var CommandRouterSubcommand = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _subcommandMapping$1, null);
+	}
+	/**
+	* Checks if the subcommand is a subcommand group.
+	*
+	* @returns True if the subcommand is a subcommand group, false otherwise.
+	*/
+	isSubcommandGroup() {
+		return false;
+	}
+	/**
+	* Checks if the subcommand is a subcommand.
+	*
+	* @returns True if the subcommand is a subcommand, false otherwise.
+	*/
+	isSubcommand() {
+		return true;
+	}
+	/**
+	* Throws an error indicating that the subcommand is a subcommand group.
+	*
+	* @throws Error - Cannot assert subcommand on a subcommand group.
+	*/
+	assertSubcommandGroup() {
+		throw new Error("Cannot assert subcommand on a subcommand group");
+	}
+	/**
+	* Asserts that the subcommand is a subcommand.
+	*
+	* @returns The current subcommand instance.
+	*/
+	assertSubcommand() {
+		return this;
+	}
+	/**
+	* Gets the subcommand mapping.
+	*
+	* @returns The subcommand mapping.
+	*/
+	getSubcommandMapping() {
+		return _classPrivateFieldGet2(_subcommandMapping$1, this);
+	}
+	/**
+	* Sets the subcommand mapping.
+	*
+	* @param command - The command instance.
+	* @param subcommand - The subcommand option.
+	* @param method - The method name.
+	* @returns The current subcommand instance.
+	* @throws ChatInputRouterError - Throws an error if the method is not a function.
+	*/
+	setSubcommandMapping(command, subcommand, method) {
+		if (!isFunction(Reflect.get(command, method))) throw new ChatInputRouterError("SubcommandLinkInvalid", command, null, subcommand);
+		_classPrivateFieldSet2(_subcommandMapping$1, this, method);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/router/CommandRouterSubcommandGroup.ts
+var _subcommandGroupMapping = /* @__PURE__ */ new WeakMap();
+var _subcommandMapping = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a subcommand group in a command router.
+*
+* @template Options - The options type for the command.
+* @internal
+*/
+var CommandRouterSubcommandGroup = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _subcommandGroupMapping, null);
+		_classPrivateFieldInitSpec(this, _subcommandMapping, new Collection());
+	}
+	/**
+	* Checks if this instance is a subcommand group.
+	*
+	* @returns True if this instance is a subcommand group, false otherwise.
+	*/
+	isSubcommandGroup() {
+		return true;
+	}
+	/**
+	* Checks if this instance is a subcommand.
+	*
+	* @returns True if this instance is a subcommand, false otherwise.
+	*/
+	isSubcommand() {
+		return false;
+	}
+	/**
+	* Asserts that this instance is a subcommand group.
+	*
+	* @returns The current instance.
+	*/
+	assertSubcommandGroup() {
+		return this;
+	}
+	/**
+	* Throws an error indicating that this instance cannot be asserted as a subcommand.
+	* @throws Error - An error indicating that subcommand cannot be asserted on a subcommand group.
+	*/
+	assertSubcommand() {
+		throw new Error("Cannot assert subcommand on a subcommand group");
+	}
+	/**
+	* Gets the subcommand group mapping.
+	*
+	* @returns The subcommand group mapping.
+	*/
+	getSubcommandGroupMapping() {
+		return _classPrivateFieldGet2(_subcommandGroupMapping, this);
+	}
+	/**
+	* Gets the subcommand mapping for the specified subcommand.
+	*
+	* @param subcommand - The name of the subcommand.
+	* @returns The subcommand mapping.
+	*/
+	getSubcommandMapping(subcommand) {
+		return _classPrivateFieldGet2(_subcommandMapping, this).get(subcommand) ?? null;
+	}
+	/**
+	* Sets the subcommand group mapping.
+	*
+	* @param command - The command instance.
+	* @param group - The subcommand group option.
+	* @param method - The method name.
+	* @returns The current instance.
+	* @throws ChatInputRouterError - If the method is not a function on the command instance.
+	*/
+	setSubcommandGroupMapping(command, group, method) {
+		if (!isFunction(Reflect.get(command, method))) throw new ChatInputRouterError("SubcommandGroupLinkInvalid", command, group, null);
+		_classPrivateFieldSet2(_subcommandGroupMapping, this, method);
+		return this;
+	}
+	/**
+	* Sets the subcommand mapping.
+	*
+	* @param command - The command instance.
+	* @param group - The subcommand group option.
+	* @param subcommand - The subcommand option.
+	* @param method - The method name.
+	* @returns The current instance.
+	* @throws ChatInputRouterError - If the method is not a function on the command instance.
+	*/
+	setSubcommandMapping(command, group, subcommand, method) {
+		if (!isFunction(Reflect.get(command, method))) throw new ChatInputRouterError("SubcommandLinkInvalid", command, group, subcommand);
+		_classPrivateFieldGet2(_subcommandMapping, this).set(subcommand.name, method);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/lib/interactions/router/CommandRouter.ts
+var _command = /* @__PURE__ */ new WeakMap();
+var _chatInputName = /* @__PURE__ */ new WeakMap();
+var _chatInputRouter = /* @__PURE__ */ new WeakMap();
+var _messageContextMenuRouter = /* @__PURE__ */ new WeakMap();
+var _userContextMenuRouter = /* @__PURE__ */ new WeakMap();
+var _CommandRouter_brand = /* @__PURE__ */ new WeakSet();
+/**
+* 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.
+*/
+var CommandRouter = class {
+	constructor(command) {
+		_classPrivateMethodInitSpec(this, _CommandRouter_brand);
+		_classPrivateFieldInitSpec(this, _command, void 0);
+		_classPrivateFieldInitSpec(this, _chatInputName, null);
+		_classPrivateFieldInitSpec(this, _chatInputRouter, new Collection());
+		_classPrivateFieldInitSpec(this, _messageContextMenuRouter, new Collection());
+		_classPrivateFieldInitSpec(this, _userContextMenuRouter, new Collection());
+		_classPrivateFieldSet2(_command, this, command);
+		const entry = container$1.applicationCommandRegistry.get(command.constructor);
+		if (entry === null) console.warn(`CommandRouter: No entry found for command '${command.name}'`);
+		else {
+			_assertClassBrand(_CommandRouter_brand, this, _populateChatInputRouter).call(this, entry.chatInput);
+			_assertClassBrand(_CommandRouter_brand, this, _populateContextMenuRouter).call(this, entry.contextMenu);
+		}
+	}
+	/**
+	* The name of the registered chat input command for this command, if any.
+	*
+	* @since 2.0.0
+	*/
+	get chatInputName() {
+		return _classPrivateFieldGet2(_chatInputName, this);
+	}
+	/**
+	* The names of the registered context menu commands for this command, if any.
+	*
+	* @since 2.0.0
+	*/
+	get contextMenuNames() {
+		return [..._classPrivateFieldGet2(_messageContextMenuRouter, this).keys(), ..._classPrivateFieldGet2(_userContextMenuRouter, this).keys()];
+	}
+	/**
+	* 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) {
+		if (!data.options?.length) return "chatInputRun";
+		const [firstOption] = data.options;
+		if (firstOption.type === ApplicationCommandOptionType.Subcommand) {
+			const entry = _classPrivateFieldGet2(_chatInputRouter, this).get(firstOption.name);
+			return entry?.isSubcommand() ? entry.getSubcommandMapping() : null;
+		}
+		if (firstOption.type === ApplicationCommandOptionType.SubcommandGroup) {
+			const entry = _classPrivateFieldGet2(_chatInputRouter, this).get(firstOption.name);
+			return entry?.isSubcommandGroup() ? entry.getSubcommandMapping(firstOption.options[0].name) ?? entry.getSubcommandGroupMapping() : null;
+		}
+		return "chatInputRun";
+	}
+	/**
+	* 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) {
+		return _assertClassBrand(_CommandRouter_brand, this, _getContextMenuCollection).call(this, data.type)?.get(data.name) ?? null;
+	}
+};
+function _populateChatInputRouter(entry) {
+	if (entry === null) return;
+	const data = entry.toJSON();
+	_classPrivateFieldSet2(_chatInputName, this, data.name);
+	if (!data.options?.length) return;
+	const command = _classPrivateFieldGet2(_command, this);
+	const chatInputRouter = _classPrivateFieldGet2(_chatInputRouter, this);
+	for (const option of data.options) if (option.type === ApplicationCommandOptionType.SubcommandGroup) {
+		const entry = chatInputRouter.ensure(option.name, () => new CommandRouterSubcommandGroup()).assertSubcommandGroup();
+		const subcommandGroupMethod = getLinkedMethod(option);
+		if (subcommandGroupMethod) entry.setSubcommandGroupMapping(command, option, subcommandGroupMethod);
+		for (const subOption of option.options ?? []) {
+			const subcommandMethod = getLinkedMethod(subOption);
+			if (subcommandMethod) entry.setSubcommandMapping(command, option, subOption, subcommandMethod);
+		}
+	} else if (option.type === ApplicationCommandOptionType.Subcommand) {
+		const entry = chatInputRouter.ensure(option.name, () => new CommandRouterSubcommand()).assertSubcommand();
+		const subcommandMethod = getLinkedMethod(option);
+		if (subcommandMethod) entry.setSubcommandMapping(command, option, subcommandMethod);
+	}
+}
+function _populateContextMenuRouter(entries) {
+	const command = _classPrivateFieldGet2(_command, this);
+	for (const entry of entries) {
+		const data = entry.toJSON();
+		const method = getLinkedMethod(data);
+		if (!method) continue;
+		if (isFunction(Reflect.get(command, method))) _assertClassBrand(_CommandRouter_brand, this, _getContextMenuCollection).call(this, data.type)?.set(data.name, method);
+		else throw new Error(`Context menu command named "${data.name}" is not linked to a method`);
+	}
+}
+function _getContextMenuCollection(type) {
+	switch (type) {
+		case ApplicationCommandType.Message: return _classPrivateFieldGet2(_messageContextMenuRouter, this);
+		case ApplicationCommandType.User: return _classPrivateFieldGet2(_userContextMenuRouter, this);
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/lib/structures/Command.ts
+var Command = class extends Piece$1 {
+	constructor(context, options = {}) {
+		super(context, options);
+		_defineProperty(this, "router", void 0);
+		this.router = new CommandRouter(this);
+	}
+	/**
+	* Gets the registry for this command.
+	*
+	* @returns The registry for this command, or `null` if it is not registered.
+	*/
+	get registry() {
+		return this.container.applicationCommandRegistry.get(this.constructor) ?? null;
+	}
+	chatInputRun() {
+		throw new Error(`The method 'chatInputRun' has not been implemented in ${this.name}.`);
+	}
+	autocompleteRun() {
+		throw new Error(`The method 'autocompleteRun' has not been implemented in ${this.name}.`);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/CommandLoaderStrategy.ts
+/**
+* Represents a strategy for loading and unloading commands.
+*
+* @since 2.0.0
+*/
+var CommandLoaderStrategy = class extends LoaderStrategy {
+	/**
+	* Called when a command is loaded.
+	*
+	* @since 2.0.0
+	* @param store - The command store.
+	* @param piece - The command being loaded.
+	* @returns The loaded command.
+	*/
+	onLoad(store, piece) {
+		if (piece.router.chatInputName) store.router.addChatInputMapping(piece.router.chatInputName, piece);
+		for (const name of piece.router.contextMenuNames) store.router.addContextMenuMapping(name, piece);
+		return piece;
+	}
+	/**
+	* Called when a command is unloaded.
+	*
+	* @since 2.0.0
+	* @param store - The command store.
+	* @param piece - The command being unloaded.
+	* @returns The unloaded command.
+	*/
+	onUnload(store, piece) {
+		if (piece.router.chatInputName) store.router.removeChatInputMapping(piece.router.chatInputName);
+		for (const name of piece.router.contextMenuNames) store.router.removeContextMenuMapping(name);
+		return piece;
+	}
+};
+
+//#endregion
+//#region src/lib/structures/CommandStoreRouter.ts
+var _chatInputMappings = /* @__PURE__ */ new WeakMap();
+var _contextMenuMappings = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a router for mapping commands to chat inputs and context menus.
+*
+* @since 2.0.0
+*/
+var CommandStoreRouter = class {
+	constructor() {
+		_classPrivateFieldInitSpec(this, _chatInputMappings, new Collection());
+		_classPrivateFieldInitSpec(this, _contextMenuMappings, new Collection());
+	}
+	/**
+	* 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) {
+		return interaction.data.type === ApplicationCommandType.ChatInput ? this.getChatInput(interaction.data.name) : this.getContextMenu(interaction.data.name);
+	}
+	/**
+	* 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) {
+		return _classPrivateFieldGet2(_chatInputMappings, this).get(name) ?? 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) {
+		return _classPrivateFieldGet2(_contextMenuMappings, this).get(name) ?? 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, command) {
+		_classPrivateFieldGet2(_chatInputMappings, this).set(name, command);
+	}
+	/**
+	* 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, command) {
+		_classPrivateFieldGet2(_contextMenuMappings, this).set(name, command);
+	}
+	/**
+	* 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) {
+		return _classPrivateFieldGet2(_chatInputMappings, this).delete(name);
+	}
+	/**
+	* 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) {
+		return _classPrivateFieldGet2(_contextMenuMappings, this).delete(name);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/CommandStore.ts
+var _CommandStore_brand = /* @__PURE__ */ new WeakSet();
+var CommandStore = class extends Store$1 {
+	constructor() {
+		super(Command, {
+			name: "commands",
+			strategy: new CommandLoaderStrategy()
+		});
+		_classPrivateMethodInitSpec(this, _CommandStore_brand);
+		_defineProperty(this, "router", new CommandStoreRouter());
+	}
+	/**
+	* 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.
+	*/
+	async runApplicationCommand(response, interaction) {
+		const command = this.router.get(interaction);
+		if (!command) {
+			container$1.client.emit("commandNameUnknown", interaction, response);
+			response.statusCode = 501;
+			return response.end(ErrorMessages.UnknownCommandName);
+		}
+		const context = {
+			command,
+			interaction,
+			response
+		};
+		const method = _assertClassBrand(_CommandStore_brand, this, _routeCommandMethodName).call(this, command, interaction.data);
+		if (!method) {
+			container$1.client.emit("commandMethodUnknown", context);
+			response.statusCode = 501;
+			return response.end(ErrorMessages.UnknownCommandHandler);
+		}
+		container$1.client.emit("commandRun", context);
+		(await Result.fromAsync(() => _assertClassBrand(_CommandStore_brand, this, _runCommandMethod).call(this, command, method, makeInteraction(response, interaction)))).inspect((value) => container$1.client.emit("commandSuccess", context, value)).inspectErr((error) => (container$1.client.emit("commandError", error, context), handleError(response, error)));
+		container$1.client.emit("commandFinish", context);
+		return response;
+	}
+	/**
+	* 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.
+	*/
+	async runApplicationCommandAutocomplete(response, interaction) {
+		if (!interaction.data?.name) {
+			container$1.client.emit("commandNameMissing", interaction, response);
+			response.statusCode = 400;
+			return response.end(ErrorMessages.MissingCommandName);
+		}
+		const command = this.router.getChatInput(interaction.data.name);
+		if (!command) {
+			container$1.client.emit("commandNameUnknown", interaction, response);
+			response.statusCode = 501;
+			return response.end(ErrorMessages.UnknownCommandName);
+		}
+		const context = {
+			command,
+			interaction,
+			response
+		};
+		const options = transformAutocompleteInteraction(interaction.data.resolved ?? {}, interaction.data.options);
+		container$1.client.emit("autocompleteRun", context);
+		(await Result.fromAsync(() => command.autocompleteRun(makeInteraction(response, interaction), options))).inspect((value) => container$1.client.emit("autocompleteSuccess", context, value)).inspectErr((error) => (container$1.client.emit("autocompleteError", error, context), handleError(response, error)));
+		container$1.client.emit("autocompleteFinish", context);
+		return response;
+	}
+};
+/**
+* Executes a command method on a command object.
+*
+* @since 1.0.0
+* @param command - The command object.
+* @param method - The name of the method to execute.
+* @param interaction - The application command interaction.
+* @returns A promise that resolves to the result of the method execution.
+*/
+function _runCommandMethod(command, method, interaction) {
+	return Reflect.apply(Reflect.get(command, method), command, [interaction, _assertClassBrand(_CommandStore_brand, this, _createArguments).call(this, interaction.data)]);
+}
+/**
+* Determines the method name to route a command based on the type of interaction data.
+*
+* @since 1.0.0
+* @param command - The command object.
+* @param data - The interaction data.
+* @returns The method name to route the command, or null if no method is found.
+* @throws Error - If the interaction data type is not recognized.
+*/
+function _routeCommandMethodName(command, data) {
+	switch (data.type) {
+		case ApplicationCommandType.ChatInput: return command.router.routeChatInputInteraction(data);
+		case ApplicationCommandType.User:
+		case ApplicationCommandType.Message: return command.router.routeContextMenuInteraction(data);
+		default: throw new Error("Unreachable");
+	}
+}
+/**
+* Creates arguments based on the provided {@linkcode APIApplicationCommandInteractionData}.
+*
+* @since 1.0.0
+* @param data The {@linkcode APIApplicationCommandInteractionData} object.
+* @returns The transformed arguments based on the interaction data.
+* @throws Error - If the {@linkcode ApplicationCommandType} is unsupported.
+*/
+function _createArguments(data) {
+	switch (data.type) {
+		case ApplicationCommandType.ChatInput: return transformInteraction(data.resolved ?? {}, data.options ?? []);
+		case ApplicationCommandType.User: return transformUserInteraction(data);
+		case ApplicationCommandType.Message: return transformMessageInteraction(data);
+		default: throw new Error("Unknown ApplicationCommandType");
+	}
+}
+
+//#endregion
+//#region src/lib/structures/InteractionHandler.ts
+var InteractionHandler = class extends Piece$1 {
+	constructor(context, options = {}) {
+		super(context, options);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/InteractionHandlerStore.ts
+var InteractionHandlerStore = class extends Store$1 {
+	constructor() {
+		super(InteractionHandler, { name: "interaction-handlers" });
+	}
+	async runHandler(response, interaction) {
+		const parsed = container$1.idParser.run(interaction.data.custom_id);
+		if (parsed === null) {
+			container$1.client.emit("interactionHandlerNameInvalid", interaction, response);
+			response.statusCode = 400;
+			return response.end(ErrorMessages.InvalidCustomId);
+		}
+		const handler = this.get(parsed.name);
+		if (!handler) {
+			container$1.client.emit("interactionHandlerNameUnknown", interaction, response);
+			response.statusCode = 501;
+			return response.end(ErrorMessages.UnknownHandlerName);
+		}
+		const context = {
+			handler,
+			interaction,
+			response
+		};
+		container$1.client.emit("interactionHandlerRun", context);
+		(await Result.fromAsync(() => handler.run(makeInteraction(response, interaction), parsed.content))).inspect((value) => container$1.client.emit("interactionHandlerSuccess", context, value)).inspectErr((error) => (container$1.client.emit("interactionHandlerError", error, context), handleError(response, error)));
+		container$1.client.emit("interactionHandlerFinish", context);
+		return response;
+	}
+};
+
+//#endregion
+//#region src/lib/structures/Listener.ts
+var Listener = class extends Piece$1 {
+	constructor(context, options) {
+		super(context, options);
+		_defineProperty(this, "emitter", void 0);
+		_defineProperty(this, "event", void 0);
+		_defineProperty(this, "_listener", void 0);
+		this.emitter = typeof options.emitter === "string" ? this.container[options.emitter] : options.emitter ?? this.container.client;
+		this.event = options.event ?? this.name;
+		this._listener = this.run.bind(this);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/ListenerLoaderStrategy.ts
+/**
+* Represents a strategy for loading and unloading listeners.
+*
+* @since 2.1.0
+*/
+var ListenerLoaderStrategy = class extends LoaderStrategy {
+	/**
+	* Called when a listener is loaded.
+	*
+	* @since 2.1.0
+	* @param store - The listener store.
+	* @param piece - The listener being loaded.
+	* @returns The loaded listener.
+	*/
+	onLoad(_store, piece) {
+		const emitter = piece.emitter;
+		const maxListeners = emitter.getMaxListeners();
+		if (maxListeners !== 0) emitter.setMaxListeners(maxListeners + 1);
+		emitter.on(piece.event, piece["_listener"]);
+	}
+	/**
+	* Called when a listener is unloaded.
+	*
+	* @since 2.1.0
+	* @param store - The listener store.
+	* @param piece - The listener being unloaded.
+	* @returns The unloaded listener.
+	*/
+	onUnload(_store, piece) {
+		const emitter = piece.emitter;
+		const maxListeners = emitter.getMaxListeners();
+		if (maxListeners !== 0) emitter.setMaxListeners(maxListeners - 1);
+		emitter.off(piece.event, piece["_listener"]);
+	}
+};
+
+//#endregion
+//#region src/lib/structures/ListenerStore.ts
+var ListenerStore = class extends Store$1 {
+	constructor() {
+		super(Listener, {
+			name: "listeners",
+			strategy: new ListenerLoaderStrategy()
+		});
+	}
+};
+
+//#endregion
+//#region src/lib/utils/security.ts
+const AlgorithmName = "Ed25519";
+function headerToString(header) {
+	return typeof header === "string" ? header : header[0];
+}
+function makeKey(key) {
+	return webcrypto.subtle.importKey("raw", Buffer.from(key, "hex"), { name: AlgorithmName }, true, ["verify"]);
+}
+/**
+* Validates a payload from Discord against its signature and key.
+* @param body The request body.
+* @param signature The value of the `x-signature-ed25519` header.
+* @param signature The value of the `x-signature-timestamp` header.
+* @param key The public key from the Discord developer dashboard, generated by {@link makeKey}
+*/
+async function verifyBody(body, signature, timestamp, key) {
+	const signatureData = Buffer.from(headerToString(signature), "hex");
+	const data = Buffer.isBuffer(body) ? Buffer.concat([Buffer.from(headerToString(timestamp)), body]) : Buffer.from(`${headerToString(timestamp)}${body}`);
+	return webcrypto.subtle.verify(AlgorithmName, key, signatureData, Buffer.from(data));
+}
+
+//#endregion
+//#region src/lib/utils/streams.ts
+/**
+* Safely reads the {@link IncomingMessage incoming message}'s body as a string.
+* @param request The incoming message to get the data from.
+* @returns The string, if it's within the body size limit.
+*/
+async function getSafeTextBody(request) {
+	let limit = container$1.client.bodySizeLimit;
+	if (!isNullishOrEmpty(request.headers["content-length"])) {
+		const parsed = Number(request.headers["content-length"]);
+		if (!Number.isSafeInteger(parsed)) return err(ErrorMessages.InvalidContentLengthInteger);
+		if (parsed <= 0) return err(ErrorMessages.InvalidContentLengthNegative);
+		if (parsed > limit) return err(ErrorMessages.InvalidContentLengthTooBig);
+		limit = parsed;
+	}
+	const decoder = new TextDecoder();
+	let output = "";
+	for await (const chunk of request) {
+		const part = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+		if (part.length + output.length > limit) return err(ErrorMessages.InvalidBodySize);
+		output += part;
+	}
+	const part = decoder.decode(void 0, { stream: false });
+	if (part.length + output.length > limit) return err(ErrorMessages.InvalidBodySize);
+	output += part;
+	return ok(output);
+}
+
+//#endregion
+//#region src/lib/Client.ts
+container$1.stores.register(new CommandStore());
+container$1.stores.register(new InteractionHandlerStore());
+container$1.stores.register(new ListenerStore());
+var _discordPublicKey = /* @__PURE__ */ new WeakMap();
+var Client = class extends AsyncEventEmitter {
+	constructor(options = {}) {
+		super();
+		_defineProperty(this, "server", void 0);
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "bodySizeLimit", void 0);
+		_defineProperty(this, "httpReplyOnError", void 0);
+		_classPrivateFieldInitSpec(this, _discordPublicKey, void 0);
+		this.bodySizeLimit = options.bodySizeLimit ?? 1024 * 1024;
+		this.httpReplyOnError = options.httpReplyOnError ?? true;
+		const discordPublicKey = options.discordPublicKey ?? process.env.DISCORD_PUBLIC_KEY;
+		if (!discordPublicKey) throw new Error("The discordPublicKey cannot be empty");
+		_classPrivateFieldSet2(_discordPublicKey, this, discordPublicKey);
+		container$1.rest = new REST(options.restOptions);
+		const token = options.discordToken ?? process.env.DISCORD_TOKEN;
+		if (!token) throw new Error("The discordToken cannot be empty");
+		this.id = options.clientId ?? process.env.DISCORD_CLIENT_ID ?? Buffer.from(token.split(".")[0], "base64").toString();
+		container$1.client = this;
+		container$1.rest.setToken(token);
+		container$1.idParser ??= new StringIdParser();
+		container$1.applicationCommandRegistry.setup({
+			clientId: this.id,
+			rest: container$1.rest,
+			authPrefix: options.authPrefix
+		});
+	}
+	/**
+	* Gets the application command registry.
+	*
+	* @since 2.0.0
+	* @returns The application command registry.
+	*/
+	get registry() {
+		return container$1.applicationCommandRegistry;
+	}
+	/**
+	* Loads all the commands.
+	* @param options The load options.
+	*/
+	async load(options = {}) {
+		if (options.baseUserDirectory !== null) container$1.stores.registerPath(options.baseUserDirectory);
+		await container$1.stores.load();
+	}
+	/**
+	* Starts the HTTP server, listening for HTTP interactions.
+	* @param options The listen options.
+	*/
+	async listen({ serverOptions, postPath, port, address, ...listenOptions }) {
+		const key = await makeKey(_classPrivateFieldGet2(_discordPublicKey, this));
+		const path = postPath ?? process.env.HTTP_POST_PATH ?? "/";
+		this.server = createServer(serverOptions ?? {});
+		this.server.on("request", (request, response) => void this.handleRawHttpMessage(request, response, path, key));
+		return new Promise((resolve) => this.server.listen({
+			...listenOptions,
+			port,
+			host: address
+		}, resolve));
+	}
+	async handleRawHttpMessage(request, response, path, key) {
+		response.setHeader("Content-Type", "application/json");
+		if (request.url !== path) {
+			response.statusCode = 404;
+			return response.end(ErrorMessages.NotFound);
+		}
+		if (request.method !== "POST") {
+			response.statusCode = 405;
+			return response.end(ErrorMessages.UnsupportedHttpMethod);
+		}
+		const signature = request.headers["x-signature-ed25519"];
+		const timestamp = request.headers["x-signature-timestamp"];
+		if (isNullishOrEmpty(signature) || isNullishOrEmpty(timestamp)) {
+			response.statusCode = 401;
+			return response.end(ErrorMessages.MissingSignatureInformation);
+		}
+		const result = await getSafeTextBody(request);
+		if (result.isErr()) {
+			response.statusCode = 400;
+			return response.end(result.unwrapErr());
+		}
+		const body = result.unwrap();
+		if (!await verifyBody(body, signature, timestamp, key)) {
+			response.statusCode = 401;
+			return response.end(ErrorMessages.InvalidSignature);
+		}
+		return this.handleHttpMessage(JSON.parse(body), response);
+	}
+	async handleHttpMessage(interaction, response) {
+		if (interaction.type === InteractionType.Ping) {
+			response.statusCode = 200;
+			return response.end(Payloads.Pong);
+		}
+		switch (interaction.type) {
+			case InteractionType.ApplicationCommand: return container$1.stores.get("commands").runApplicationCommand(response, interaction);
+			case InteractionType.ApplicationCommandAutocomplete: return container$1.stores.get("commands").runApplicationCommandAutocomplete(response, interaction);
+			case InteractionType.MessageComponent:
+			case InteractionType.ModalSubmit: return container$1.stores.get("interaction-handlers").runHandler(response, interaction);
+			default:
+				response.statusCode = 501;
+				return response.end(ErrorMessages.UnknownInteractionType);
+		}
+	}
+};
+
+//#endregion
+export { AliasPiece, AliasStore, ApplicationCommandRegistry, ApplicationCommandRegistryEntry, AutocompleteInteraction, BaseInteraction, ChatInputCommandInteraction, Client, Command, CommandInteraction, CommandLoaderStrategy, CommandRouter, CommandStore, CommandStoreRouter, HttpCodes, InteractionHandler, InteractionHandlerStore, Listener, ListenerLoaderStrategy, ListenerStore, LoaderError, Message, MessageComponentButtonInteraction, MessageComponentChannelSelectInteraction, MessageComponentInteraction, MessageComponentMentionableSelectInteraction, MessageComponentRoleSelectInteraction, MessageComponentStringSelectInteraction as MessageComponentSelectMenuInteraction, MessageComponentStringSelectInteraction, MessageComponentUserSelectInteraction, MessageContextMenuCommandInteraction, MissingExportsError, ModalSubmitInteraction, PartialMessage, Piece, RegisterCommand, RegisterMessageCommand, RegisterSubcommand, RegisterSubcommandGroup, RegisterUserCommand, RestrictGuildIds, Store, StoreRegistry, StringIdParser, UserContextMenuCommandInteraction, applicationCommandRegistry, container, extractTopLevelOptions, makeInteraction, restrictedGuildIdRegistry, transformAutocompleteInteraction, transformInteraction, transformMessageInteraction, transformUserInteraction };
+//# sourceMappingURL=index.js.map