chore: monorepo setup (#7175)

packages/builders/src/index.ts

@@ -0,0 +1,18 @@
+export * as EmbedAssertions from './messages/embed/Assertions';
+export * from './messages/embed/Embed';
+export * from './messages/formatters';
+
+export * as SlashCommandAssertions from './interactions/slashCommands/Assertions';
+export * from './interactions/slashCommands/SlashCommandBuilder';
+export * from './interactions/slashCommands/SlashCommandSubcommands';
+export * from './interactions/slashCommands/options/boolean';
+export * from './interactions/slashCommands/options/channel';
+export * from './interactions/slashCommands/options/integer';
+export * from './interactions/slashCommands/options/mentionable';
+export * from './interactions/slashCommands/options/number';
+export * from './interactions/slashCommands/options/role';
+export * from './interactions/slashCommands/options/string';
+export * from './interactions/slashCommands/options/user';
+
+export * as ContextMenuCommandAssertions from './interactions/contextMenuCommands/Assertions';
+export * from './interactions/contextMenuCommands/ContextMenuCommandBuilder';

packages/builders/src/interactions/contextMenuCommands/Assertions.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ApplicationCommandType } from 'discord-api-types/v9';
+import type { ContextMenuCommandType } from './ContextMenuCommandBuilder';
+
+export function validateRequiredParameters(name: string, type: number) {
+	// Assert name matches all conditions
+	validateName(name);
+
+	// Assert type is valid
+	validateType(type);
+}
+
+const namePredicate = z
+	.string()
+	.min(1)
+	.max(32)
+	.regex(/^( *[\p{L}\p{N}_-]+ *)+$/u);
+
+export function validateName(name: unknown): asserts name is string {
+	namePredicate.parse(name);
+}
+
+const typePredicate = z.union([z.literal(ApplicationCommandType.User), z.literal(ApplicationCommandType.Message)]);
+
+export function validateType(type: unknown): asserts type is ContextMenuCommandType {
+	typePredicate.parse(type);
+}
+
+const booleanPredicate = z.boolean();
+
+export function validateDefaultPermission(value: unknown): asserts value is boolean {
+	booleanPredicate.parse(value);
+}

packages/builders/src/interactions/contextMenuCommands/ContextMenuCommandBuilder.ts

@@ -0,0 +1,83 @@
+import { validateRequiredParameters, validateName, validateType, validateDefaultPermission } from './Assertions';
+import type { ApplicationCommandType, RESTPostAPIApplicationCommandsJSONBody } from 'discord-api-types/v9';
+
+export class ContextMenuCommandBuilder {
+	/**
+	 * The name of this context menu command
+	 */
+	public readonly name: string = undefined!;
+
+	/**
+	 * The type of this context menu command
+	 */
+	public readonly type: ContextMenuCommandType = undefined!;
+
+	/**
+	 * Whether the command is enabled by default when the app is added to a guild
+	 *
+	 * @default true
+	 */
+	public readonly defaultPermission: boolean | undefined = undefined;
+
+	/**
+	 * Sets the name
+	 *
+	 * @param name The name
+	 */
+	public setName(name: string) {
+		// Assert the name matches the conditions
+		validateName(name);
+
+		Reflect.set(this, 'name', name);
+
+		return this;
+	}
+
+	/**
+	 * Sets the type
+	 *
+	 * @param type The type
+	 */
+	public setType(type: ContextMenuCommandType) {
+		// Assert the type is valid
+		validateType(type);
+
+		Reflect.set(this, 'type', type);
+
+		return this;
+	}
+
+	/**
+	 * Sets whether the command is enabled by default when the application is added to a guild.
+	 *
+	 * **Note**: If set to `false`, you will have to later `PUT` the permissions for this command.
+	 *
+	 * @param value Whether or not to enable this command by default
+	 *
+	 * @see https://discord.com/developers/docs/interactions/application-commands#permissions
+	 */
+	public setDefaultPermission(value: boolean) {
+		// Assert the value matches the conditions
+		validateDefaultPermission(value);
+
+		Reflect.set(this, 'defaultPermission', value);
+
+		return this;
+	}
+
+	/**
+	 * Returns the final data that should be sent to Discord.
+	 *
+	 * **Note:** Calling this function will validate required properties based on their conditions.
+	 */
+	public toJSON(): RESTPostAPIApplicationCommandsJSONBody {
+		validateRequiredParameters(this.name, this.type);
+		return {
+			name: this.name,
+			type: this.type,
+			default_permission: this.defaultPermission,
+		};
+	}
+}
+
+export type ContextMenuCommandType = ApplicationCommandType.User | ApplicationCommandType.Message;

packages/builders/src/interactions/slashCommands/Assertions.ts

@@ -0,0 +1,84 @@
+import is from '@sindresorhus/is';
+import type { APIApplicationCommandOptionChoice } from 'discord-api-types/v9';
+import { z } from 'zod';
+import type { ApplicationCommandOptionBase } from './mixins/ApplicationCommandOptionBase';
+import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
+import type { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
+
+export function validateRequiredParameters(
+	name: string,
+	description: string,
+	options: ToAPIApplicationCommandOptions[],
+) {
+	// Assert name matches all conditions
+	validateName(name);
+
+	// Assert description conditions
+	validateDescription(description);
+
+	// Assert options conditions
+	validateMaxOptionsLength(options);
+}
+
+const namePredicate = z
+	.string()
+	.min(1)
+	.max(32)
+	.regex(/^[\P{Lu}\p{N}_-]+$/u);
+
+export function validateName(name: unknown): asserts name is string {
+	namePredicate.parse(name);
+}
+
+const descriptionPredicate = z.string().min(1).max(100);
+
+export function validateDescription(description: unknown): asserts description is string {
+	descriptionPredicate.parse(description);
+}
+
+const booleanPredicate = z.boolean();
+
+export function validateDefaultPermission(value: unknown): asserts value is boolean {
+	booleanPredicate.parse(value);
+}
+
+export function validateRequired(required: unknown): asserts required is boolean {
+	booleanPredicate.parse(required);
+}
+
+const maxArrayLengthPredicate = z.unknown().array().max(25);
+
+export function validateMaxOptionsLength(options: unknown): asserts options is ToAPIApplicationCommandOptions[] {
+	maxArrayLengthPredicate.parse(options);
+}
+
+export function validateMaxChoicesLength(choices: APIApplicationCommandOptionChoice[]) {
+	maxArrayLengthPredicate.parse(choices);
+}
+
+export function assertReturnOfBuilder<
+	T extends ApplicationCommandOptionBase | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder,
+>(input: unknown, ExpectedInstanceOf: new () => T): asserts input is T {
+	const instanceName = ExpectedInstanceOf.name;
+
+	if (is.nullOrUndefined(input)) {
+		throw new TypeError(
+			`Expected to receive a ${instanceName} builder, got ${input === null ? 'null' : 'undefined'} instead.`,
+		);
+	}
+
+	if (is.primitive(input)) {
+		throw new TypeError(`Expected to receive a ${instanceName} builder, got a primitive (${typeof input}) instead.`);
+	}
+
+	if (!(input instanceof ExpectedInstanceOf)) {
+		const casted = input as Record<PropertyKey, unknown>;
+
+		const constructorName = is.function_(input) ? input.name : casted.constructor.name;
+		const stringTag = Reflect.get(casted, Symbol.toStringTag) as string | undefined;
+
+		const fullResultName = stringTag ? `${constructorName} [${stringTag}]` : constructorName;
+
+		throw new TypeError(`Expected to receive a ${instanceName} builder, got ${fullResultName} instead.`);
+	}
+}

packages/builders/src/interactions/slashCommands/SlashCommandBuilder.ts

@@ -0,0 +1,137 @@
+import type { APIApplicationCommandOption, RESTPostAPIApplicationCommandsJSONBody } from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import {
+	assertReturnOfBuilder,
+	validateDefaultPermission,
+	validateMaxOptionsLength,
+	validateRequiredParameters,
+} from './Assertions';
+import { SharedSlashCommandOptions } from './mixins/SharedSlashCommandOptions';
+import { SharedNameAndDescription } from './mixins/NameAndDescription';
+import { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from './SlashCommandSubcommands';
+
+@mix(SharedSlashCommandOptions, SharedNameAndDescription)
+export class SlashCommandBuilder {
+	/**
+	 * The name of this slash command
+	 */
+	public readonly name: string = undefined!;
+
+	/**
+	 * The description of this slash command
+	 */
+	public readonly description: string = undefined!;
+
+	/**
+	 * The options of this slash command
+	 */
+	public readonly options: ToAPIApplicationCommandOptions[] = [];
+
+	/**
+	 * Whether the command is enabled by default when the app is added to a guild
+	 *
+	 * @default true
+	 */
+	public readonly defaultPermission: boolean | undefined = undefined;
+
+	/**
+	 * Returns the final data that should be sent to Discord.
+	 *
+	 * **Note:** Calling this function will validate required properties based on their conditions.
+	 */
+	public toJSON(): RESTPostAPIApplicationCommandsJSONBody {
+		validateRequiredParameters(this.name, this.description, this.options);
+
+		return {
+			name: this.name,
+			description: this.description,
+			options: this.options.map((option) => option.toJSON()),
+			default_permission: this.defaultPermission,
+		};
+	}
+
+	/**
+	 * Sets whether the command is enabled by default when the application is added to a guild.
+	 *
+	 * **Note**: If set to `false`, you will have to later `PUT` the permissions for this command.
+	 *
+	 * @param value Whether or not to enable this command by default
+	 *
+	 * @see https://discord.com/developers/docs/interactions/application-commands#permissions
+	 */
+	public setDefaultPermission(value: boolean) {
+		// Assert the value matches the conditions
+		validateDefaultPermission(value);
+
+		Reflect.set(this, 'defaultPermission', value);
+
+		return this;
+	}
+
+	/**
+	 * Adds a new subcommand group to this command
+	 *
+	 * @param input A function that returns a subcommand group builder, or an already built builder
+	 */
+	public addSubcommandGroup(
+		input:
+			| SlashCommandSubcommandGroupBuilder
+			| ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder),
+	): SlashCommandSubcommandsOnlyBuilder {
+		const { options } = this;
+
+		// First, assert options conditions - we cannot have more than 25 options
+		validateMaxOptionsLength(options);
+
+		// Get the final result
+		const result = typeof input === 'function' ? input(new SlashCommandSubcommandGroupBuilder()) : input;
+
+		assertReturnOfBuilder(result, SlashCommandSubcommandGroupBuilder);
+
+		// Push it
+		options.push(result);
+
+		return this;
+	}
+
+	/**
+	 * Adds a new subcommand to this command
+	 *
+	 * @param input A function that returns a subcommand builder, or an already built builder
+	 */
+	public addSubcommand(
+		input:
+			| SlashCommandSubcommandBuilder
+			| ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder),
+	): SlashCommandSubcommandsOnlyBuilder {
+		const { options } = this;
+
+		// First, assert options conditions - we cannot have more than 25 options
+		validateMaxOptionsLength(options);
+
+		// Get the final result
+		const result = typeof input === 'function' ? input(new SlashCommandSubcommandBuilder()) : input;
+
+		assertReturnOfBuilder(result, SlashCommandSubcommandBuilder);
+
+		// Push it
+		options.push(result);
+
+		return this;
+	}
+}
+
+export interface SlashCommandBuilder extends SharedNameAndDescription, SharedSlashCommandOptions {}
+
+export interface SlashCommandSubcommandsOnlyBuilder
+	extends SharedNameAndDescription,
+		Pick<SlashCommandBuilder, 'toJSON' | 'addSubcommand' | 'addSubcommandGroup'> {}
+
+export interface SlashCommandOptionsOnlyBuilder
+	extends SharedNameAndDescription,
+		SharedSlashCommandOptions,
+		Pick<SlashCommandBuilder, 'toJSON'> {}
+
+export interface ToAPIApplicationCommandOptions {
+	toJSON(): APIApplicationCommandOption;
+}

packages/builders/src/interactions/slashCommands/SlashCommandSubcommands.ts

@@ -0,0 +1,109 @@
+import {
+	APIApplicationCommandSubcommandGroupOption,
+	APIApplicationCommandSubcommandOption,
+	ApplicationCommandOptionType,
+} from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import { assertReturnOfBuilder, validateMaxOptionsLength, validateRequiredParameters } from './Assertions';
+import type { ApplicationCommandOptionBase } from './mixins/ApplicationCommandOptionBase';
+import { SharedNameAndDescription } from './mixins/NameAndDescription';
+import { SharedSlashCommandOptions } from './mixins/SharedSlashCommandOptions';
+import type { ToAPIApplicationCommandOptions } from './SlashCommandBuilder';
+
+/**
+ * Represents a folder for subcommands
+ *
+ * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
+ */
+@mix(SharedNameAndDescription)
+export class SlashCommandSubcommandGroupBuilder implements ToAPIApplicationCommandOptions {
+	/**
+	 * The name of this subcommand group
+	 */
+	public readonly name: string = undefined!;
+
+	/**
+	 * The description of this subcommand group
+	 */
+	public readonly description: string = undefined!;
+
+	/**
+	 * The subcommands part of this subcommand group
+	 */
+	public readonly options: SlashCommandSubcommandBuilder[] = [];
+
+	/**
+	 * Adds a new subcommand to this group
+	 *
+	 * @param input A function that returns a subcommand builder, or an already built builder
+	 */
+	public addSubcommand(
+		input:
+			| SlashCommandSubcommandBuilder
+			| ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder),
+	) {
+		const { options } = this;
+
+		// First, assert options conditions - we cannot have more than 25 options
+		validateMaxOptionsLength(options);
+
+		// Get the final result
+		const result = typeof input === 'function' ? input(new SlashCommandSubcommandBuilder()) : input;
+
+		assertReturnOfBuilder(result, SlashCommandSubcommandBuilder);
+
+		// Push it
+		options.push(result);
+
+		return this;
+	}
+
+	public toJSON(): APIApplicationCommandSubcommandGroupOption {
+		validateRequiredParameters(this.name, this.description, this.options);
+
+		return {
+			type: ApplicationCommandOptionType.SubcommandGroup,
+			name: this.name,
+			description: this.description,
+			options: this.options.map((option) => option.toJSON()),
+		};
+	}
+}
+
+export interface SlashCommandSubcommandGroupBuilder extends SharedNameAndDescription {}
+
+/**
+ * Represents a subcommand
+ *
+ * For more information, go to https://discord.com/developers/docs/interactions/slash-commands#subcommands-and-subcommand-groups
+ */
+@mix(SharedNameAndDescription, SharedSlashCommandOptions)
+export class SlashCommandSubcommandBuilder implements ToAPIApplicationCommandOptions {
+	/**
+	 * The name of this subcommand
+	 */
+	public readonly name: string = undefined!;
+
+	/**
+	 * The description of this subcommand
+	 */
+	public readonly description: string = undefined!;
+
+	/**
+	 * The options of this subcommand
+	 */
+	public readonly options: ApplicationCommandOptionBase[] = [];
+
+	public toJSON(): APIApplicationCommandSubcommandOption {
+		validateRequiredParameters(this.name, this.description, this.options);
+
+		return {
+			type: ApplicationCommandOptionType.Subcommand,
+			name: this.name,
+			description: this.description,
+			options: this.options.map((option) => option.toJSON()),
+		};
+	}
+}
+
+export interface SlashCommandSubcommandBuilder extends SharedNameAndDescription, SharedSlashCommandOptions<false> {}

packages/builders/src/interactions/slashCommands/mixins/ApplicationCommandNumericOptionMinMaxValueMixin.ts

@@ -0,0 +1,16 @@
+export abstract class ApplicationCommandNumericOptionMinMaxValueMixin {
+	public readonly max_value?: number;
+	public readonly min_value?: number;
+
+	/**
+	 * Sets the maximum number value of this option
+	 * @param max The maximum value this option can be
+	 */
+	public abstract setMaxValue(max: number): this;
+
+	/**
+	 * Sets the minimum number value of this option
+	 * @param min The minimum value this option can be
+	 */
+	public abstract setMinValue(min: number): this;
+}

packages/builders/src/interactions/slashCommands/mixins/ApplicationCommandOptionBase.ts

@@ -0,0 +1,32 @@
+import type { APIApplicationCommandBasicOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { validateRequiredParameters, validateRequired } from '../Assertions';
+import { SharedNameAndDescription } from './NameAndDescription';
+
+export abstract class ApplicationCommandOptionBase extends SharedNameAndDescription {
+	public abstract readonly type: ApplicationCommandOptionType;
+
+	public readonly required = false;
+
+	/**
+	 * Marks the option as required
+	 *
+	 * @param required If this option should be required
+	 */
+	public setRequired(required: boolean) {
+		// Assert that you actually passed a boolean
+		validateRequired(required);
+
+		Reflect.set(this, 'required', required);
+
+		return this;
+	}
+
+	public abstract toJSON(): APIApplicationCommandBasicOption;
+
+	protected runRequiredValidations() {
+		validateRequiredParameters(this.name, this.description, []);
+
+		// Assert that you actually passed a boolean
+		validateRequired(this.required);
+	}
+}

packages/builders/src/interactions/slashCommands/mixins/ApplicationCommandOptionChannelTypesMixin.ts

@@ -0,0 +1,55 @@
+import { ChannelType } from 'discord-api-types/v9';
+import { z, ZodLiteral } from 'zod';
+
+// Only allow valid channel types to be used. (This can't be dynamic because const enums are erased at runtime)
+const allowedChannelTypes = [
+	ChannelType.GuildText,
+	ChannelType.GuildVoice,
+	ChannelType.GuildCategory,
+	ChannelType.GuildNews,
+	ChannelType.GuildStore,
+	ChannelType.GuildNewsThread,
+	ChannelType.GuildPublicThread,
+	ChannelType.GuildPrivateThread,
+	ChannelType.GuildStageVoice,
+] as const;
+
+export type ApplicationCommandOptionAllowedChannelTypes = typeof allowedChannelTypes[number];
+
+const channelTypePredicate = z.union(
+	allowedChannelTypes.map((type) => z.literal(type)) as [
+		ZodLiteral<ChannelType>,
+		ZodLiteral<ChannelType>,
+		...ZodLiteral<ChannelType>[]
+	],
+);
+
+export class ApplicationCommandOptionChannelTypesMixin {
+	public readonly channel_types?: ApplicationCommandOptionAllowedChannelTypes[];
+
+	/**
+	 * Adds a channel type to this option
+	 *
+	 * @param channelType The type of channel to allow
+	 */
+	public addChannelType(channelType: ApplicationCommandOptionAllowedChannelTypes) {
+		if (this.channel_types === undefined) {
+			Reflect.set(this, 'channel_types', []);
+		}
+
+		channelTypePredicate.parse(channelType);
+		this.channel_types!.push(channelType);
+
+		return this;
+	}
+
+	/**
+	 * Adds channel types to this option
+	 *
+	 * @param channelTypes The channel types to add
+	 */
+	public addChannelTypes(channelTypes: ApplicationCommandOptionAllowedChannelTypes[]) {
+		channelTypes.forEach((channelType) => this.addChannelType(channelType));
+		return this;
+	}
+}

packages/builders/src/interactions/slashCommands/mixins/ApplicationCommandOptionWithChoicesAndAutocompleteMixin.ts

@@ -0,0 +1,102 @@
+import { APIApplicationCommandOptionChoice, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { z } from 'zod';
+import { validateMaxChoicesLength } from '../Assertions';
+
+const stringPredicate = z.string().min(1).max(100);
+const numberPredicate = z.number().gt(-Infinity).lt(Infinity);
+const choicesPredicate = z.tuple([stringPredicate, z.union([stringPredicate, numberPredicate])]).array();
+const booleanPredicate = z.boolean();
+
+export class ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T extends string | number> {
+	public readonly choices?: APIApplicationCommandOptionChoice<T>[];
+	public readonly autocomplete?: boolean;
+
+	// Since this is present and this is a mixin, this is needed
+	public readonly type!: ApplicationCommandOptionType;
+
+	/**
+	 * Adds a choice for this option
+	 *
+	 * @param name The name of the choice
+	 * @param value The value of the choice
+	 */
+	public addChoice(name: string, value: T): Omit<this, 'setAutocomplete'> {
+		if (this.autocomplete) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		if (this.choices === undefined) {
+			Reflect.set(this, 'choices', []);
+		}
+
+		validateMaxChoicesLength(this.choices!);
+
+		// Validate name
+		stringPredicate.parse(name);
+
+		// Validate the value
+		if (this.type === ApplicationCommandOptionType.String) {
+			stringPredicate.parse(value);
+		} else {
+			numberPredicate.parse(value);
+		}
+
+		this.choices!.push({ name, value });
+
+		return this;
+	}
+
+	/**
+	 * Adds multiple choices for this option
+	 *
+	 * @param choices The choices to add
+	 */
+	public addChoices(choices: [name: string, value: T][]): Omit<this, 'setAutocomplete'> {
+		if (this.autocomplete) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		choicesPredicate.parse(choices);
+
+		for (const [label, value] of choices) this.addChoice(label, value);
+		return this;
+	}
+
+	public setChoices<Input extends [name: string, value: T][]>(
+		choices: Input,
+	): Input extends []
+		? this & Pick<ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T>, 'setAutocomplete'>
+		: Omit<this, 'setAutocomplete'> {
+		if (choices.length > 0 && this.autocomplete) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		choicesPredicate.parse(choices);
+
+		Reflect.set(this, 'choices', []);
+		for (const [label, value] of choices) this.addChoice(label, value);
+
+		return this;
+	}
+
+	/**
+	 * Marks the option as autocompletable
+	 * @param autocomplete If this option should be autocompletable
+	 */
+	public setAutocomplete<U extends boolean>(
+		autocomplete: U,
+	): U extends true
+		? Omit<this, 'addChoice' | 'addChoices'>
+		: this & Pick<ApplicationCommandOptionWithChoicesAndAutocompleteMixin<T>, 'addChoice' | 'addChoices'> {
+		// Assert that you actually passed a boolean
+		booleanPredicate.parse(autocomplete);
+
+		if (autocomplete && Array.isArray(this.choices) && this.choices.length > 0) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		Reflect.set(this, 'autocomplete', autocomplete);
+
+		return this;
+	}
+}

packages/builders/src/interactions/slashCommands/mixins/NameAndDescription.ts

@@ -0,0 +1,34 @@
+import { validateDescription, validateName } from '../Assertions';
+
+export class SharedNameAndDescription {
+	public readonly name!: string;
+	public readonly description!: string;
+
+	/**
+	 * Sets the name
+	 *
+	 * @param name The name
+	 */
+	public setName(name: string): this {
+		// Assert the name matches the conditions
+		validateName(name);
+
+		Reflect.set(this, 'name', name);
+
+		return this;
+	}
+
+	/**
+	 * Sets the description
+	 *
+	 * @param description The description
+	 */
+	public setDescription(description: string) {
+		// Assert the description matches the conditions
+		validateDescription(description);
+
+		Reflect.set(this, 'description', description);
+
+		return this;
+	}
+}

packages/builders/src/interactions/slashCommands/mixins/SharedSlashCommandOptions.ts

@@ -0,0 +1,150 @@
+import { assertReturnOfBuilder, validateMaxOptionsLength } from '../Assertions';
+import type { ApplicationCommandOptionBase } from './ApplicationCommandOptionBase';
+import { SlashCommandBooleanOption } from '../options/boolean';
+import { SlashCommandChannelOption } from '../options/channel';
+import { SlashCommandIntegerOption } from '../options/integer';
+import { SlashCommandMentionableOption } from '../options/mentionable';
+import { SlashCommandNumberOption } from '../options/number';
+import { SlashCommandRoleOption } from '../options/role';
+import { SlashCommandStringOption } from '../options/string';
+import { SlashCommandUserOption } from '../options/user';
+import type { ToAPIApplicationCommandOptions } from '../SlashCommandBuilder';
+
+export class SharedSlashCommandOptions<ShouldOmitSubcommandFunctions = true> {
+	public readonly options!: ToAPIApplicationCommandOptions[];
+
+	/**
+	 * Adds a boolean option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addBooleanOption(
+		input: SlashCommandBooleanOption | ((builder: SlashCommandBooleanOption) => SlashCommandBooleanOption),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandBooleanOption);
+	}
+
+	/**
+	 * Adds a user option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addUserOption(input: SlashCommandUserOption | ((builder: SlashCommandUserOption) => SlashCommandUserOption)) {
+		return this._sharedAddOptionMethod(input, SlashCommandUserOption);
+	}
+
+	/**
+	 * Adds a channel option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addChannelOption(
+		input: SlashCommandChannelOption | ((builder: SlashCommandChannelOption) => SlashCommandChannelOption),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandChannelOption);
+	}
+
+	/**
+	 * Adds a role option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addRoleOption(input: SlashCommandRoleOption | ((builder: SlashCommandRoleOption) => SlashCommandRoleOption)) {
+		return this._sharedAddOptionMethod(input, SlashCommandRoleOption);
+	}
+
+	/**
+	 * Adds a mentionable option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addMentionableOption(
+		input: SlashCommandMentionableOption | ((builder: SlashCommandMentionableOption) => SlashCommandMentionableOption),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandMentionableOption);
+	}
+
+	/**
+	 * Adds a string option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addStringOption(
+		input:
+			| SlashCommandStringOption
+			| Omit<SlashCommandStringOption, 'setAutocomplete'>
+			| Omit<SlashCommandStringOption, 'addChoice' | 'addChoices'>
+			| ((
+					builder: SlashCommandStringOption,
+			  ) =>
+					| SlashCommandStringOption
+					| Omit<SlashCommandStringOption, 'setAutocomplete'>
+					| Omit<SlashCommandStringOption, 'addChoice' | 'addChoices'>),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandStringOption);
+	}
+
+	/**
+	 * Adds an integer option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addIntegerOption(
+		input:
+			| SlashCommandIntegerOption
+			| Omit<SlashCommandIntegerOption, 'setAutocomplete'>
+			| Omit<SlashCommandIntegerOption, 'addChoice' | 'addChoices'>
+			| ((
+					builder: SlashCommandIntegerOption,
+			  ) =>
+					| SlashCommandIntegerOption
+					| Omit<SlashCommandIntegerOption, 'setAutocomplete'>
+					| Omit<SlashCommandIntegerOption, 'addChoice' | 'addChoices'>),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandIntegerOption);
+	}
+
+	/**
+	 * Adds a number option
+	 *
+	 * @param input A function that returns an option builder, or an already built builder
+	 */
+	public addNumberOption(
+		input:
+			| SlashCommandNumberOption
+			| Omit<SlashCommandNumberOption, 'setAutocomplete'>
+			| Omit<SlashCommandNumberOption, 'addChoice' | 'addChoices'>
+			| ((
+					builder: SlashCommandNumberOption,
+			  ) =>
+					| SlashCommandNumberOption
+					| Omit<SlashCommandNumberOption, 'setAutocomplete'>
+					| Omit<SlashCommandNumberOption, 'addChoice' | 'addChoices'>),
+	) {
+		return this._sharedAddOptionMethod(input, SlashCommandNumberOption);
+	}
+
+	private _sharedAddOptionMethod<T extends ApplicationCommandOptionBase>(
+		input:
+			| T
+			| Omit<T, 'setAutocomplete'>
+			| Omit<T, 'addChoice' | 'addChoices'>
+			| ((builder: T) => T | Omit<T, 'setAutocomplete'> | Omit<T, 'addChoice' | 'addChoices'>),
+		Instance: new () => T,
+	): ShouldOmitSubcommandFunctions extends true ? Omit<this, 'addSubcommand' | 'addSubcommandGroup'> : this {
+		const { options } = this;
+
+		// First, assert options conditions - we cannot have more than 25 options
+		validateMaxOptionsLength(options);
+
+		// Get the final result
+		const result = typeof input === 'function' ? input(new Instance()) : input;
+
+		assertReturnOfBuilder(result, Instance);
+
+		// Push it
+		options.push(result);
+
+		return this;
+	}
+}

packages/builders/src/interactions/slashCommands/options/boolean.ts

@@ -0,0 +1,12 @@
+import { APIApplicationCommandBooleanOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+
+export class SlashCommandBooleanOption extends ApplicationCommandOptionBase {
+	public readonly type = ApplicationCommandOptionType.Boolean as const;
+
+	public toJSON(): APIApplicationCommandBooleanOption {
+		this.runRequiredValidations();
+
+		return { ...this };
+	}
+}

packages/builders/src/interactions/slashCommands/options/channel.ts

@@ -0,0 +1,17 @@
+import { APIApplicationCommandChannelOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+import { ApplicationCommandOptionChannelTypesMixin } from '../mixins/ApplicationCommandOptionChannelTypesMixin';
+
+@mix(ApplicationCommandOptionChannelTypesMixin)
+export class SlashCommandChannelOption extends ApplicationCommandOptionBase {
+	public override readonly type = ApplicationCommandOptionType.Channel as const;
+
+	public toJSON(): APIApplicationCommandChannelOption {
+		this.runRequiredValidations();
+
+		return { ...this };
+	}
+}
+
+export interface SlashCommandChannelOption extends ApplicationCommandOptionChannelTypesMixin {}

packages/builders/src/interactions/slashCommands/options/integer.ts

@@ -0,0 +1,46 @@
+import { APIApplicationCommandIntegerOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import { z } from 'zod';
+import { ApplicationCommandNumericOptionMinMaxValueMixin } from '../mixins/ApplicationCommandNumericOptionMinMaxValueMixin';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+import { ApplicationCommandOptionWithChoicesAndAutocompleteMixin } from '../mixins/ApplicationCommandOptionWithChoicesAndAutocompleteMixin';
+
+const numberValidator = z.number().int().nonnegative();
+
+@mix(ApplicationCommandNumericOptionMinMaxValueMixin, ApplicationCommandOptionWithChoicesAndAutocompleteMixin)
+export class SlashCommandIntegerOption
+	extends ApplicationCommandOptionBase
+	implements ApplicationCommandNumericOptionMinMaxValueMixin
+{
+	public readonly type = ApplicationCommandOptionType.Integer as const;
+
+	public setMaxValue(max: number): this {
+		numberValidator.parse(max);
+
+		Reflect.set(this, 'max_value', max);
+
+		return this;
+	}
+
+	public setMinValue(min: number): this {
+		numberValidator.parse(min);
+
+		Reflect.set(this, 'min_value', min);
+
+		return this;
+	}
+
+	public toJSON(): APIApplicationCommandIntegerOption {
+		this.runRequiredValidations();
+
+		if (this.autocomplete && Array.isArray(this.choices) && this.choices.length > 0) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		return { ...this };
+	}
+}
+
+export interface SlashCommandIntegerOption
+	extends ApplicationCommandNumericOptionMinMaxValueMixin,
+		ApplicationCommandOptionWithChoicesAndAutocompleteMixin<number> {}

packages/builders/src/interactions/slashCommands/options/mentionable.ts

@@ -0,0 +1,12 @@
+import { APIApplicationCommandMentionableOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+
+export class SlashCommandMentionableOption extends ApplicationCommandOptionBase {
+	public readonly type = ApplicationCommandOptionType.Mentionable as const;
+
+	public toJSON(): APIApplicationCommandMentionableOption {
+		this.runRequiredValidations();
+
+		return { ...this };
+	}
+}

packages/builders/src/interactions/slashCommands/options/number.ts

@@ -0,0 +1,46 @@
+import { APIApplicationCommandNumberOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import { z } from 'zod';
+import { ApplicationCommandNumericOptionMinMaxValueMixin } from '../mixins/ApplicationCommandNumericOptionMinMaxValueMixin';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+import { ApplicationCommandOptionWithChoicesAndAutocompleteMixin } from '../mixins/ApplicationCommandOptionWithChoicesAndAutocompleteMixin';
+
+const numberValidator = z.number().nonnegative();
+
+@mix(ApplicationCommandNumericOptionMinMaxValueMixin, ApplicationCommandOptionWithChoicesAndAutocompleteMixin)
+export class SlashCommandNumberOption
+	extends ApplicationCommandOptionBase
+	implements ApplicationCommandNumericOptionMinMaxValueMixin
+{
+	public readonly type = ApplicationCommandOptionType.Number as const;
+
+	public setMaxValue(max: number): this {
+		numberValidator.parse(max);
+
+		Reflect.set(this, 'max_value', max);
+
+		return this;
+	}
+
+	public setMinValue(min: number): this {
+		numberValidator.parse(min);
+
+		Reflect.set(this, 'min_value', min);
+
+		return this;
+	}
+
+	public toJSON(): APIApplicationCommandNumberOption {
+		this.runRequiredValidations();
+
+		if (this.autocomplete && Array.isArray(this.choices) && this.choices.length > 0) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		return { ...this };
+	}
+}
+
+export interface SlashCommandNumberOption
+	extends ApplicationCommandNumericOptionMinMaxValueMixin,
+		ApplicationCommandOptionWithChoicesAndAutocompleteMixin<number> {}

packages/builders/src/interactions/slashCommands/options/role.ts

@@ -0,0 +1,12 @@
+import { APIApplicationCommandRoleOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+
+export class SlashCommandRoleOption extends ApplicationCommandOptionBase {
+	public override readonly type = ApplicationCommandOptionType.Role as const;
+
+	public toJSON(): APIApplicationCommandRoleOption {
+		this.runRequiredValidations();
+
+		return { ...this };
+	}
+}

packages/builders/src/interactions/slashCommands/options/string.ts

@@ -0,0 +1,21 @@
+import { APIApplicationCommandStringOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { mix } from 'ts-mixer';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+import { ApplicationCommandOptionWithChoicesAndAutocompleteMixin } from '../mixins/ApplicationCommandOptionWithChoicesAndAutocompleteMixin';
+
+@mix(ApplicationCommandOptionWithChoicesAndAutocompleteMixin)
+export class SlashCommandStringOption extends ApplicationCommandOptionBase {
+	public readonly type = ApplicationCommandOptionType.String as const;
+
+	public toJSON(): APIApplicationCommandStringOption {
+		this.runRequiredValidations();
+
+		if (this.autocomplete && Array.isArray(this.choices) && this.choices.length > 0) {
+			throw new RangeError('Autocomplete and choices are mutually exclusive to each other.');
+		}
+
+		return { ...this };
+	}
+}
+
+export interface SlashCommandStringOption extends ApplicationCommandOptionWithChoicesAndAutocompleteMixin<string> {}

packages/builders/src/interactions/slashCommands/options/user.ts

@@ -0,0 +1,12 @@
+import { APIApplicationCommandUserOption, ApplicationCommandOptionType } from 'discord-api-types/v9';
+import { ApplicationCommandOptionBase } from '../mixins/ApplicationCommandOptionBase';
+
+export class SlashCommandUserOption extends ApplicationCommandOptionBase {
+	public readonly type = ApplicationCommandOptionType.User as const;
+
+	public toJSON(): APIApplicationCommandUserOption {
+		this.runRequiredValidations();
+
+		return { ...this };
+	}
+}

packages/builders/src/messages/embed/Assertions.ts

@@ -0,0 +1,36 @@
+import type { APIEmbedField } from 'discord-api-types/v9';
+import { z } from 'zod';
+
+export const fieldNamePredicate = z.string().min(1).max(256);
+
+export const fieldValuePredicate = z.string().min(1).max(1024);
+
+export const fieldInlinePredicate = z.boolean().optional();
+
+export const embedFieldPredicate = z.object({
+	name: fieldNamePredicate,
+	value: fieldValuePredicate,
+	inline: fieldInlinePredicate,
+});
+
+export const embedFieldsArrayPredicate = embedFieldPredicate.array();
+
+export const fieldLengthPredicate = z.number().lte(25);
+
+export function validateFieldLength(fields: APIEmbedField[], amountAdding: number): void {
+	fieldLengthPredicate.parse(fields.length + amountAdding);
+}
+
+export const authorNamePredicate = fieldNamePredicate.nullable();
+
+export const urlPredicate = z.string().url().nullish();
+
+export const colorPredicate = z.number().gte(0).lte(0xffffff).nullable();
+
+export const descriptionPredicate = z.string().min(1).max(4096).nullable();
+
+export const footerTextPredicate = z.string().min(1).max(2048).nullable();
+
+export const timestampPredicate = z.union([z.number(), z.date()]).nullable();
+
+export const titlePredicate = fieldNamePredicate.nullable();

packages/builders/src/messages/embed/Embed.ts

@@ -0,0 +1,326 @@
+import type {
+	APIEmbed,
+	APIEmbedAuthor,
+	APIEmbedField,
+	APIEmbedFooter,
+	APIEmbedImage,
+	APIEmbedProvider,
+	APIEmbedThumbnail,
+	APIEmbedVideo,
+} from 'discord-api-types/v9';
+import {
+	authorNamePredicate,
+	colorPredicate,
+	descriptionPredicate,
+	embedFieldsArrayPredicate,
+	fieldInlinePredicate,
+	fieldNamePredicate,
+	fieldValuePredicate,
+	footerTextPredicate,
+	timestampPredicate,
+	titlePredicate,
+	urlPredicate,
+	validateFieldLength,
+} from './Assertions';
+
+export interface AuthorOptions {
+	name: string;
+	url?: string;
+	iconURL?: string;
+}
+
+export interface FooterOptions {
+	text: string;
+	iconURL?: string;
+}
+
+/**
+ * Represents an embed in a message (image/video preview, rich embed, etc.)
+ */
+export class Embed implements APIEmbed {
+	/**
+	 * An array of fields of this embed
+	 */
+	public fields: APIEmbedField[];
+
+	/**
+	 * The embed title
+	 */
+	public title?: string;
+
+	/**
+	 * The embed description
+	 */
+	public description?: string;
+
+	/**
+	 * The embed url
+	 */
+	public url?: string;
+
+	/**
+	 * The embed color
+	 */
+	public color?: number;
+
+	/**
+	 * The timestamp of the embed in the ISO format
+	 */
+	public timestamp?: string;
+
+	/**
+	 * The embed thumbnail data
+	 */
+	public thumbnail?: APIEmbedThumbnail;
+
+	/**
+	 * The embed image data
+	 */
+	public image?: APIEmbedImage;
+
+	/**
+	 * Received video data
+	 */
+	public video?: APIEmbedVideo;
+
+	/**
+	 * The embed author data
+	 */
+	public author?: APIEmbedAuthor;
+
+	/**
+	 * Received data about the embed provider
+	 */
+	public provider?: APIEmbedProvider;
+
+	/**
+	 * The embed footer data
+	 */
+	public footer?: APIEmbedFooter;
+
+	public constructor(data: APIEmbed = {}) {
+		this.title = data.title;
+		this.description = data.description;
+		this.url = data.url;
+		this.color = data.color;
+		this.thumbnail = data.thumbnail;
+		this.image = data.image;
+		this.video = data.video;
+		this.author = data.author;
+		this.provider = data.provider;
+		this.footer = data.footer;
+		this.fields = data.fields ?? [];
+
+		if (data.timestamp) this.timestamp = new Date(data.timestamp).toISOString();
+	}
+
+	/**
+	 * The accumulated length for the embed title, description, fields, footer text, and author name
+	 */
+	public get length(): number {
+		return (
+			(this.title?.length ?? 0) +
+			(this.description?.length ?? 0) +
+			this.fields.reduce((prev, curr) => prev + curr.name.length + curr.value.length, 0) +
+			(this.footer?.text.length ?? 0) +
+			(this.author?.name.length ?? 0)
+		);
+	}
+
+	/**
+	 * Adds a field to the embed (max 25)
+	 *
+	 * @param field The field to add.
+	 */
+	public addField(field: APIEmbedField): this {
+		return this.addFields(field);
+	}
+
+	/**
+	 * Adds fields to the embed (max 25)
+	 *
+	 * @param fields The fields to add
+	 */
+	public addFields(...fields: APIEmbedField[]): this {
+		// Data assertions
+		embedFieldsArrayPredicate.parse(fields);
+
+		// Ensure adding these fields won't exceed the 25 field limit
+		validateFieldLength(this.fields, fields.length);
+
+		this.fields.push(...Embed.normalizeFields(...fields));
+		return this;
+	}
+
+	/**
+	 * Removes, replaces, or inserts fields in the embed (max 25)
+	 *
+	 * @param index The index to start at
+	 * @param deleteCount The number of fields to remove
+	 * @param fields The replacing field objects
+	 */
+	public spliceFields(index: number, deleteCount: number, ...fields: APIEmbedField[]): this {
+		// Data assertions
+		embedFieldsArrayPredicate.parse(fields);
+
+		// Ensure adding these fields won't exceed the 25 field limit
+		validateFieldLength(this.fields, fields.length - deleteCount);
+
+		this.fields.splice(index, deleteCount, ...Embed.normalizeFields(...fields));
+		return this;
+	}
+
+	/**
+	 * Sets the author of this embed
+	 *
+	 * @param options The options for the author
+	 */
+	public setAuthor(options: AuthorOptions | null): this {
+		if (options === null) {
+			this.author = undefined;
+			return this;
+		}
+
+		const { name, iconURL, url } = options;
+		// Data assertions
+		authorNamePredicate.parse(name);
+		urlPredicate.parse(iconURL);
+		urlPredicate.parse(url);
+
+		this.author = { name, url, icon_url: iconURL };
+		return this;
+	}
+
+	/**
+	 * Sets the color of this embed
+	 *
+	 * @param color The color of the embed
+	 */
+	public setColor(color: number | null): this {
+		// Data assertions
+		colorPredicate.parse(color);
+
+		this.color = color ?? undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the description of this embed
+	 *
+	 * @param description The description
+	 */
+	public setDescription(description: string | null): this {
+		// Data assertions
+		descriptionPredicate.parse(description);
+
+		this.description = description ?? undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the footer of this embed
+	 *
+	 * @param options The options for the footer
+	 */
+	public setFooter(options: FooterOptions | null): this {
+		if (options === null) {
+			this.footer = undefined;
+			return this;
+		}
+
+		const { text, iconURL } = options;
+		// Data assertions
+		footerTextPredicate.parse(text);
+		urlPredicate.parse(iconURL);
+
+		this.footer = { text, icon_url: iconURL };
+		return this;
+	}
+
+	/**
+	 * Sets the image of this embed
+	 *
+	 * @param url The URL of the image
+	 */
+	public setImage(url: string | null): this {
+		// Data assertions
+		urlPredicate.parse(url);
+
+		this.image = url ? { url } : undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the thumbnail of this embed
+	 *
+	 * @param url The URL of the thumbnail
+	 */
+	public setThumbnail(url: string | null): this {
+		// Data assertions
+		urlPredicate.parse(url);
+
+		this.thumbnail = url ? { url } : undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the timestamp of this embed
+	 *
+	 * @param timestamp The timestamp or date
+	 */
+	public setTimestamp(timestamp: number | Date | null = Date.now()): this {
+		// Data assertions
+		timestampPredicate.parse(timestamp);
+
+		this.timestamp = timestamp ? new Date(timestamp).toISOString() : undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the title of this embed
+	 *
+	 * @param title The title
+	 */
+	public setTitle(title: string | null): this {
+		// Data assertions
+		titlePredicate.parse(title);
+
+		this.title = title ?? undefined;
+		return this;
+	}
+
+	/**
+	 * Sets the URL of this embed
+	 *
+	 * @param url The URL
+	 */
+	public setURL(url: string | null): this {
+		// Data assertions
+		urlPredicate.parse(url);
+
+		this.url = url ?? undefined;
+		return this;
+	}
+
+	/**
+	 * Transforms the embed to a plain object
+	 */
+	public toJSON(): APIEmbed {
+		return { ...this };
+	}
+
+	/**
+	 * Normalizes field input and resolves strings
+	 *
+	 * @param fields Fields to normalize
+	 */
+	public static normalizeFields(...fields: APIEmbedField[]): APIEmbedField[] {
+		return fields.flat(Infinity).map((field) => {
+			fieldNamePredicate.parse(field.name);
+			fieldValuePredicate.parse(field.value);
+			fieldInlinePredicate.parse(field.inline);
+
+			return { name: field.name, value: field.value, inline: field.inline ?? undefined };
+		});
+	}
+}

packages/builders/src/messages/formatters.ts

@@ -0,0 +1,319 @@
+import type { Snowflake } from 'discord-api-types/globals';
+import type { URL } from 'url';
+
+/**
+ * Wraps the content inside a codeblock with no language
+ *
+ * @param content The content to wrap
+ */
+export function codeBlock<C extends string>(content: C): `\`\`\`\n${C}\`\`\``;
+
+/**
+ * Wraps the content inside a codeblock with the specified language
+ *
+ * @param language The language for the codeblock
+ * @param content The content to wrap
+ */
+export function codeBlock<L extends string, C extends string>(language: L, content: C): `\`\`\`${L}\n${C}\`\`\``;
+export function codeBlock(language: string, content?: string): string {
+	return typeof content === 'undefined' ? `\`\`\`\n${language}\`\`\`` : `\`\`\`${language}\n${content}\`\`\``;
+}
+
+/**
+ * Wraps the content inside \`backticks\`, which formats it as inline code
+ *
+ * @param content The content to wrap
+ */
+export function inlineCode<C extends string>(content: C): `\`${C}\`` {
+	return `\`${content}\``;
+}
+
+/**
+ * Formats the content into italic text
+ *
+ * @param content The content to wrap
+ */
+export function italic<C extends string>(content: C): `_${C}_` {
+	return `_${content}_`;
+}
+
+/**
+ * Formats the content into bold text
+ *
+ * @param content The content to wrap
+ */
+export function bold<C extends string>(content: C): `**${C}**` {
+	return `**${content}**`;
+}
+
+/**
+ * Formats the content into underscored text
+ *
+ * @param content The content to wrap
+ */
+export function underscore<C extends string>(content: C): `__${C}__` {
+	return `__${content}__`;
+}
+
+/**
+ * Formats the content into strike-through text
+ *
+ * @param content The content to wrap
+ */
+export function strikethrough<C extends string>(content: C): `~~${C}~~` {
+	return `~~${content}~~`;
+}
+
+/**
+ * Formats the content into a quote. This needs to be at the start of the line for Discord to format it
+ *
+ * @param content The content to wrap
+ */
+export function quote<C extends string>(content: C): `> ${C}` {
+	return `> ${content}`;
+}
+
+/**
+ * Formats the content into a block quote. This needs to be at the start of the line for Discord to format it
+ *
+ * @param content The content to wrap
+ */
+export function blockQuote<C extends string>(content: C): `>>> ${C}` {
+	return `>>> ${content}`;
+}
+
+/**
+ * Wraps the URL into `<>`, which stops it from embedding
+ *
+ * @param url The URL to wrap
+ */
+export function hideLinkEmbed<C extends string>(url: C): `<${C}>`;
+
+/**
+ * Wraps the URL into `<>`, which stops it from embedding
+ *
+ * @param url The URL to wrap
+ */
+export function hideLinkEmbed(url: URL): `<${string}>`;
+export function hideLinkEmbed(url: string | URL) {
+	// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+	return `<${url}>`;
+}
+
+/**
+ * Formats the content and the URL into a masked URL
+ *
+ * @param content The content to display
+ * @param url The URL the content links to
+ */
+export function hyperlink<C extends string>(content: C, url: URL): `[${C}](${string})`;
+
+/**
+ * Formats the content and the URL into a masked URL
+ *
+ * @param content The content to display
+ * @param url The URL the content links to
+ */
+export function hyperlink<C extends string, U extends string>(content: C, url: U): `[${C}](${U})`;
+
+/**
+ * Formats the content and the URL into a masked URL
+ *
+ * @param content The content to display
+ * @param url The URL the content links to
+ * @param title The title shown when hovering on the masked link
+ */
+export function hyperlink<C extends string, T extends string>(
+	content: C,
+	url: URL,
+	title: T,
+): `[${C}](${string} "${T}")`;
+
+/**
+ * Formats the content and the URL into a masked URL
+ *
+ * @param content The content to display
+ * @param url The URL the content links to
+ * @param title The title shown when hovering on the masked link
+ */
+export function hyperlink<C extends string, U extends string, T extends string>(
+	content: C,
+	url: U,
+	title: T,
+): `[${C}](${U} "${T}")`;
+export function hyperlink(content: string, url: string | URL, title?: string) {
+	// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+	return title ? `[${content}](${url} "${title}")` : `[${content}](${url})`;
+}
+
+/**
+ * Wraps the content inside spoiler (hidden text)
+ *
+ * @param content The content to wrap
+ */
+export function spoiler<C extends string>(content: C): `||${C}||` {
+	return `||${content}||`;
+}
+
+/**
+ * Formats a user ID into a user mention
+ *
+ * @param userId The user ID to format
+ */
+export function userMention<C extends Snowflake>(userId: C): `<@${C}>` {
+	return `<@${userId}>`;
+}
+
+/**
+ * Formats a user ID into a member-nickname mention
+ *
+ * @param memberId The user ID to format
+ */
+export function memberNicknameMention<C extends Snowflake>(memberId: C): `<@!${C}>` {
+	return `<@!${memberId}>`;
+}
+
+/**
+ * Formats a channel ID into a channel mention
+ *
+ * @param channelId The channel ID to format
+ */
+export function channelMention<C extends Snowflake>(channelId: C): `<#${C}>` {
+	return `<#${channelId}>`;
+}
+
+/**
+ * Formats a role ID into a role mention
+ *
+ * @param roleId The role ID to format
+ */
+export function roleMention<C extends Snowflake>(roleId: C): `<@&${C}>` {
+	return `<@&${roleId}>`;
+}
+
+/**
+ * Formats an emoji ID into a fully qualified emoji identifier
+ *
+ * @param emojiId The emoji ID to format
+ */
+export function formatEmoji<C extends Snowflake>(emojiId: C, animated?: false): `<:_:${C}>`;
+
+/**
+ * Formats an emoji ID into a fully qualified emoji identifier
+ *
+ * @param emojiId The emoji ID to format
+ * @param animated Whether the emoji is animated or not. Defaults to `false`
+ */
+export function formatEmoji<C extends Snowflake>(emojiId: C, animated?: true): `<a:_:${C}>`;
+
+/**
+ * Formats an emoji ID into a fully qualified emoji identifier
+ *
+ * @param emojiId The emoji ID to format
+ * @param animated Whether the emoji is animated or not. Defaults to `false`
+ */
+export function formatEmoji<C extends Snowflake>(emojiId: C, animated = false): `<a:_:${C}>` | `<:_:${C}>` {
+	return `<${animated ? 'a' : ''}:_:${emojiId}>`;
+}
+
+/**
+ * Formats a date into a short date-time string
+ *
+ * @param date The date to format, defaults to the current time
+ */
+export function time(date?: Date): `<t:${bigint}>`;
+
+/**
+ * Formats a date given a format style
+ *
+ * @param date The date to format
+ * @param style The style to use
+ */
+export function time<S extends TimestampStylesString>(date: Date, style: S): `<t:${bigint}:${S}>`;
+
+/**
+ * Formats the given timestamp into a short date-time string
+ *
+ * @param seconds The time to format, represents an UNIX timestamp in seconds
+ */
+export function time<C extends number>(seconds: C): `<t:${C}>`;
+
+/**
+ * Formats the given timestamp into a short date-time string
+ *
+ * @param seconds The time to format, represents an UNIX timestamp in seconds
+ * @param style The style to use
+ */
+export function time<C extends number, S extends TimestampStylesString>(seconds: C, style: S): `<t:${C}:${S}>`;
+export function time(timeOrSeconds?: number | Date, style?: TimestampStylesString): string {
+	if (typeof timeOrSeconds !== 'number') {
+		timeOrSeconds = Math.floor((timeOrSeconds?.getTime() ?? Date.now()) / 1000);
+	}
+
+	return typeof style === 'string' ? `<t:${timeOrSeconds}:${style}>` : `<t:${timeOrSeconds}>`;
+}
+
+/**
+ * The [message formatting timestamp styles](https://discord.com/developers/docs/reference#message-formatting-timestamp-styles) supported by Discord
+ */
+export const TimestampStyles = {
+	/**
+	 * Short time format, consisting of hours and minutes, e.g. 16:20
+	 */
+	ShortTime: 't',
+
+	/**
+	 * Long time format, consisting of hours, minutes, and seconds, e.g. 16:20:30
+	 */
+	LongTime: 'T',
+
+	/**
+	 * Short date format, consisting of day, month, and year, e.g. 20/04/2021
+	 */
+	ShortDate: 'd',
+
+	/**
+	 * Long date format, consisting of day, month, and year, e.g. 20 April 2021
+	 */
+	LongDate: 'D',
+
+	/**
+	 * Short date-time format, consisting of short date and short time formats, e.g. 20 April 2021 16:20
+	 */
+	ShortDateTime: 'f',
+
+	/**
+	 * Long date-time format, consisting of long date and short time formats, e.g. Tuesday, 20 April 2021 16:20
+	 */
+	LongDateTime: 'F',
+
+	/**
+	 * Relative time format, consisting of a relative duration format, e.g. 2 months ago
+	 */
+	RelativeTime: 'R',
+} as const;
+
+/**
+ * The possible values, see {@link TimestampStyles} for more information
+ */
+export type TimestampStylesString = typeof TimestampStyles[keyof typeof TimestampStyles];
+
+/**
+ * An enum with all the available faces from Discord's native slash commands
+ */
+export enum Faces {
+	/**
+	 * ¯\\_(ツ)\\_/¯
+	 */
+	Shrug = '¯\\_(ツ)\\_/¯',
+
+	/**
+	 * (╯°□°）╯︵ ┻━┻
+	 */
+	Tableflip = '(╯°□°）╯︵ ┻━┻',
+
+	/**
+	 * ┬─┬ ノ( ゜-゜ノ)
+	 */
+	Unflip = '┬─┬ ノ( ゜-゜ノ)',
+}