discordthing 0.1.2 → 0.2.0

package/build/commands/manager.js

@@ -0,0 +1,138 @@
+import { err, NONE, Result } from "@l3dev/result";
+import { Events, InteractionContextType } from "discord.js";
+import { createCommandContext } from "./context.js";
+import { CommandRegistration } from "./registration.js";
+export class CommandManager {
+    bot;
+    commands = new Map();
+    commandFilters = [];
+    errorHandler = null;
+    constructor(bot, options) {
+        this.bot = bot;
+        for (const command of options.commands ?? []) {
+            this.commands.set(command.name, command);
+        }
+        bot.client.on(Events.InteractionCreate, this.onInteraction.bind(this));
+    }
+    /**
+     * Adds commands to the bot.
+     * @param commands The commands to add
+     * @returns A result indicating whether the commands were added successfully
+     * @example
+     * bot.commands.addMany(myCommand1, myCommand2);
+     * bot.commands.addMany([myCommand1, myCommand2]);
+     */
+    addMany(...commands) {
+        return Result.all(...commands.flat().map((command) => this.add(command)));
+    }
+    /**
+     * Adds a command to the bot.
+     * @param command The command to add
+     * @returns A result indicating whether the command was added successfully
+     * @example
+     * const myCommand = command({
+     * 	meta: {
+     * 		name: 'my-command',
+     * 	},
+     * 	handler: async (ctx) => {
+     * 		// your code here
+     * 	}
+     * });
+     *
+     * bot.commands.add(myCommand);
+     */
+    add(command) {
+        if (this.bot.client.isReady()) {
+            return err("BOT_ALREADY_STARTED", {
+                message: "Cannot add command after bot has started"
+            });
+        }
+        this.commands.set(command.name, command);
+        return NONE;
+    }
+    /**
+     * Adds a command filter that determines whether a command should be executed.
+     * @param filter The filter to add to the bot
+     * @example
+     * bot.commands.addFilter(async (interaction, command) => {
+     * 	if (interaction.guild.id !== process.env.GUILD_ID) return false;
+     * 	return true;
+     * });
+     */
+    addFilter(filter) {
+        this.commandFilters.push(filter);
+    }
+    /**
+     * Sets the command error handler for the bot.
+     * @param handler The error handler to use
+     * @example
+     * bot.commands.setErrorHandler(async (ctx, err) => {
+     * 	await ctx.interaction.reply("An error occurred!");
+     * });
+     */
+    setErrorHandler(handler) {
+        this.errorHandler = handler;
+    }
+    /** @internal */
+    async register(client) {
+        const commandRegistration = new CommandRegistration(this.bot.rest, client);
+        const globalCommands = Object.values(this.commands).filter((command) => {
+            const contexts = command.getContexts();
+            return (contexts.includes(InteractionContextType.BotDM) ||
+                contexts.includes(InteractionContextType.PrivateChannel));
+        });
+        const guildCommands = Object.values(this.commands).filter((command) => {
+            const contexts = command.getContexts();
+            return contexts.includes(InteractionContextType.Guild);
+        });
+        this.bot.logger.debug(`Registering global commands...`);
+        await commandRegistration.registerGlobalCommands(globalCommands);
+        const guilds = await client.guilds.fetch();
+        for (const guild of guilds.values()) {
+            this.bot.logger.debug(`Registering guild commands for guild ${guild.id}...`);
+            await commandRegistration.registerGuildCommands(guild.id, guildCommands);
+        }
+    }
+    async onInteraction(interaction) {
+        if (interaction.user.bot || !interaction.isChatInputCommand())
+            return;
+        const ctx = createCommandContext(this.bot, interaction);
+        const result = await this.executeCommand(ctx);
+        if (!result.ok && this.errorHandler) {
+            try {
+                await this.errorHandler(ctx, result);
+            }
+            catch (error) {
+                this.bot.logger.error(`Error while executing error handler:`, error);
+            }
+        }
+    }
+    async executeCommand(ctx) {
+        const commandName = ctx.interaction.commandName;
+        const command = this.commands.get(commandName);
+        if (!command) {
+            this.bot.logger.error(`Unknown command '${commandName}'`);
+            return err("UNKNOWN_COMMAND", {
+                command: commandName
+            });
+        }
+        if (!this.commandFilters.some((filter) => filter(ctx.interaction, command))) {
+            return NONE;
+        }
+        let result;
+        try {
+            result = await command.execute(ctx);
+        }
+        catch (error) {
+            result = err("COMMAND_FAILED", {
+                command: commandName,
+                error
+            });
+        }
+        const unwrapped = Result.unwrap(result);
+        if (!unwrapped.ok) {
+            this.bot.logger.error(`Error while executing command '${commandName}':`, result);
+        }
+        return unwrapped;
+    }
+}

package/build/commands/registration.js

@@ -37,4 +37,3 @@ export class CommandRegistration {
         await Promise.all([...addPromises, ...removePromises]);
     }
 }
-//# sourceMappingURL=registration.js.map

package/build/context.d.ts

@@ -6,4 +6,4 @@ export type GenericCtx = {
     permissions: PermissionsResolver;
     logger: ILogger;
 };
-export declare function createContext(bot: Bot, logger: ILogger): GenericCtx;
+export declare function createGenericContext(bot: Bot): GenericCtx;

package/build/context.js

@@ -1,9 +1,8 @@
 import { PermissionsResolver } from "./permissions.js";
-export function createContext(bot, logger) {
+export function createGenericContext(bot) {
     return {
         bot,
         permissions: new PermissionsResolver(bot),
-        logger
+        logger: bot.logger
     };
 }
-//# sourceMappingURL=context.js.map

package/build/events/index.d.ts

@@ -1,2 +1,3 @@
 export { listen } from "./listener.js";
 export type { Listener } from "./listener.js";
+export type { EventsManager, EventsManagerOptions } from "./manager.js";

package/build/events/index.js

@@ -1,2 +1 @@
 export { listen } from "./listener.js";
-//# sourceMappingURL=index.js.map

package/build/events/listener.js

@@ -12,4 +12,3 @@ export class Listener {
 export function listen(listener) {
     return new Listener(listener.event, listener.handler, listener.once);
 }
-//# sourceMappingURL=listener.js.map

package/build/events/manager.d.ts

@@ -0,0 +1,40 @@
+import { type RestOrArray } from "discord.js";
+import type { Bot } from "../bot.js";
+import type { Listener } from "./listener.js";
+export type EventsManagerOptions = {
+    listeners?: Listener<any>[];
+};
+export declare class EventsManager {
+    private readonly bot;
+    private readonly readyListeners;
+    constructor(bot: Bot, options: EventsManagerOptions);
+    /**
+     * Adds event listeners to the bot.
+     * @param listeners The listeners to add
+     * @returns A result indicating whether the listeners were added successfully
+     * @example
+     * bot.events.addMany(myListener1, myListener2);
+     * bot.events.addMany([myListener1, myListener2]);
+     */
+    addMany(...listeners: RestOrArray<Listener<any>>): import("@l3dev/result").Ok<void[]> | import("@l3dev/result").Err<"BOT_ALREADY_STARTED", {
+        message: string;
+    }>;
+    /**
+     * Adds an event listener to the bot.
+     * @param listener The listener to add
+     * @returns A result indicating whether the listener was added successfully
+     * @example
+     * const myListener = listen({
+     * 	event: Events.InteractionCreate,
+     * 	handler: async (ctx, interaction) => {
+     * 		// your code here
+     * 	}
+     * });
+     *
+     * bot.events.add(myListener);
+     */
+    add(listener: Listener<any>): import("@l3dev/result").None | import("@l3dev/result").Err<"BOT_ALREADY_STARTED", {
+        message: string;
+    }>;
+    private createListenerFn;
+}

package/build/events/manager.js

@@ -0,0 +1,86 @@
+import { err, NONE, Result } from "@l3dev/result";
+import { Events } from "discord.js";
+import { createGenericContext } from "../context.js";
+export class EventsManager {
+    bot;
+    readyListeners = [];
+    constructor(bot, options) {
+        this.bot = bot;
+        for (const listener of options.listeners ?? []) {
+            const result = this.add(listener);
+            if (!result.ok) {
+                throw new (class extends Error {
+                    result = result;
+                    constructor(message) {
+                        super(message);
+                    }
+                })("Error adding listener while initializing events manager");
+            }
+        }
+    }
+    /**
+     * Adds event listeners to the bot.
+     * @param listeners The listeners to add
+     * @returns A result indicating whether the listeners were added successfully
+     * @example
+     * bot.events.addMany(myListener1, myListener2);
+     * bot.events.addMany([myListener1, myListener2]);
+     */
+    addMany(...listeners) {
+        return Result.all(...listeners.flat().map((listener) => this.add(listener)));
+    }
+    /**
+     * Adds an event listener to the bot.
+     * @param listener The listener to add
+     * @returns A result indicating whether the listener was added successfully
+     * @example
+     * const myListener = listen({
+     * 	event: Events.InteractionCreate,
+     * 	handler: async (ctx, interaction) => {
+     * 		// your code here
+     * 	}
+     * });
+     *
+     * bot.events.add(myListener);
+     */
+    add(listener) {
+        if (this.bot.client.isReady()) {
+            return err("BOT_ALREADY_STARTED", {
+                message: "Cannot add listener after bot has started"
+            });
+        }
+        if (listener.event === Events.ClientReady) {
+            this.readyListeners.push(listener);
+            return NONE;
+        }
+        (listener.once ? this.bot.client.once : this.bot.client.on)(listener.event, this.createListenerFn(listener));
+        return NONE;
+    }
+    createListenerFn(listener) {
+        return async (...args) => {
+            const ctx = createGenericContext(this.bot);
+            try {
+                await listener.handler(ctx, ...args);
+            }
+            catch (error) {
+                this.bot.logger.error(`Error in listener ${listener.event}:`, error);
+            }
+        };
+    }
+    /** @internal */
+    async runReadyListeners(client) {
+        // Make a copy so we can remove _once_ listeners
+        const listeners = [...this.readyListeners];
+        await Promise.all(listeners.map(async (listener) => {
+            const handler = this.createListenerFn(listener);
+            await handler(client);
+            if (listener.once) {
+                const index = this.readyListeners.indexOf(listener);
+                if (index === -1) {
+                    return;
+                }
+                this.readyListeners.splice(index, 1);
+            }
+        }));
+    }
+}

package/build/index.js

@@ -1,4 +1,3 @@
 export { Bot } from "./bot.js";
 export { plugin, ResolvedPlugin } from "./plugin.js";
 export * from "./utility-types.js";
-//# sourceMappingURL=index.js.map

package/build/logger.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=logger.js.map

package/build/options/index.js

@@ -1,2 +1 @@
 export { o, optionsToJson } from "./option.js";
-//# sourceMappingURL=index.js.map

package/build/options/option.d.ts

@@ -1,4 +1,5 @@
-import { type APIApplicationCommandOption, type ApplicationCommandOptionAllowedChannelTypes, type RestOrArray } from "discord.js";
+import { type APIApplicationCommandOption } from "discord.js";
+import type * as z from "zod";
 import { AttachmentOption, BooleanOption, ChannelOption, Choice, IntegerOption, MentionableOption, NumberOption, RoleOption, StringOption, UserOption, type AsOptional, type Option, type OptionalType } from "./options.js";
 import type { Expand } from "../utility-types.js";
 export type GenericOption = Option<any, any>;
@@ -14,34 +15,15 @@ export declare const o: {
     /**
      * A command attachment option.
      */
-    attachment: () => AttachmentOption<import("discord.js").Attachment, "required">;
+    attachment: () => AttachmentOption<import("discord.js").Attachment, "required", z.ZodType<import("discord.js").Attachment, import("discord.js").Attachment, z.core.$ZodTypeInternals<import("discord.js").Attachment, import("discord.js").Attachment>>>;
     /**
      * A command boolean option.
      */
-    boolean: () => BooleanOption<boolean, "required">;
+    boolean: () => BooleanOption<boolean, "required", z.ZodType<boolean, boolean, z.core.$ZodTypeInternals<boolean, boolean>>>;
     /**
      * A command channel option.
-     * @param channelTypes The channel types.
      */
-    channel: <T extends ApplicationCommandOptionAllowedChannelTypes>(...channelTypes: RestOrArray<T>) => ChannelOption<Extract<import("discord.js").CategoryChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").NewsChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").StageChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").TextChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").PublicThreadChannel<boolean>, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").PrivateThreadChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").VoiceChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").ForumChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }> | Extract<import("discord.js").MediaChannel, {
-        type: T | (T extends readonly (infer InnerArr)[] ? InnerArr : T);
-    }>, "required">;
+    channel: () => ChannelOption<import("discord.js").GuildBasedChannel, "required", z.ZodType<import("discord.js").GuildBasedChannel, import("discord.js").GuildBasedChannel, z.core.$ZodTypeInternals<import("discord.js").GuildBasedChannel, import("discord.js").GuildBasedChannel>>>;
     /**
      * A choice for a command option.
      * @param name The name of the choice.
@@ -51,27 +33,27 @@ export declare const o: {
     /**
      * A command integer option.
      */
-    integer: () => IntegerOption<number, "required">;
+    integer: () => IntegerOption<number, "required", z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
     /**
      * A command number option.
      */
-    number: () => NumberOption<number, "required">;
+    number: () => NumberOption<number, "required", z.ZodType<number, number, z.core.$ZodTypeInternals<number, number>>>;
     /**
      * A command mentionable option.
      */
-    mentionable: () => MentionableOption<import("discord.js").GuildMember | import("discord.js").User | import("discord.js").Role, "required">;
+    mentionable: () => MentionableOption<import("discord.js").User | import("discord.js").GuildMember | import("discord.js").Role, "required", z.ZodType<import("discord.js").User | import("discord.js").GuildMember | import("discord.js").Role, import("discord.js").User | import("discord.js").GuildMember | import("discord.js").Role, z.core.$ZodTypeInternals<import("discord.js").User | import("discord.js").GuildMember | import("discord.js").Role, import("discord.js").User | import("discord.js").GuildMember | import("discord.js").Role>>>;
     /**
      * A command role option.
      */
-    role: () => RoleOption<import("discord.js").Role, "required">;
+    role: () => RoleOption<import("discord.js").Role, "required", z.ZodType<import("discord.js").Role, import("discord.js").Role, z.core.$ZodTypeInternals<import("discord.js").Role, import("discord.js").Role>>>;
     /**
      * A command string option.
      */
-    string: () => StringOption<string, "required">;
+    string: () => StringOption<string, "required", z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
     /**
      * A command user option.
      */
-    user: () => UserOption<import("discord.js").User, "required">;
+    user: () => UserOption<import("discord.js").User, "required", z.ZodType<import("discord.js").User, import("discord.js").User, z.core.$ZodTypeInternals<import("discord.js").User, import("discord.js").User>>>;
     /**
      * Allows not specifying an option for a command.
      * @param option The option to make optional.
@@ -112,5 +94,5 @@ type RequiredKeys<Options extends Record<string, GenericOption>> = Exclude<keyof
  *
  * @public
  */
-export type Infer<T extends Option<any, OptionalType>> = T["type"];
+export type Infer<T extends Option<any, OptionalType>> = T["validator"] extends z.ZodType<infer Type> ? Type : T["type"];
 export {};

package/build/options/option.js

@@ -1,15 +1,10 @@
 import { SlashCommandAttachmentOption, SlashCommandBooleanOption, SlashCommandChannelOption, SlashCommandIntegerOption, SlashCommandMentionableOption, SlashCommandNumberOption, SlashCommandRoleOption, SlashCommandStringOption, SlashCommandUserOption } from "discord.js";
-import { AttachmentOption, BooleanOption, BuilderOption, ChannelOption, Choice, IntegerOption, MentionableOption, NumberOption, RoleOption, StringOption, UserOption } from "./options.js";
+import { AttachmentOption, BooleanOption, ChannelOption, Choice, IntegerOption, MentionableOption, NumberOption, RoleOption, StringOption, UserOption } from "./options.js";
 export function optionsToJson(options) {
-    return Object.entries(options)
-        .map(([name, option]) => {
-        if (option instanceof BuilderOption) {
-            const builder = option.getBuilder();
-            return builder.setName(name).toJSON();
-        }
-        return null;
-    })
-        .filter((json) => json !== null);
+    return Object.entries(options).map(([name, option]) => {
+        const builder = option.getBuilder();
+        return builder.setName(name).toJSON();
+    });
 }
 /**
  * The option builder.
@@ -33,11 +28,9 @@ export const o = {
     },
     /**
      * A command channel option.
-     * @param channelTypes The channel types.
      */
-    channel: (...channelTypes) => {
-        const option = new ChannelOption(new SlashCommandChannelOption(), "required");
-        return option.union(channelTypes.flat());
+    channel: () => {
+        return new ChannelOption(new SlashCommandChannelOption(), "required");
     },
     /**
      * A choice for a command option.
@@ -98,4 +91,3 @@ export const o = {
         return option.asOptional();
     }
 };
-//# sourceMappingURL=option.js.map

package/build/options/options.d.ts

@@ -1,34 +1,37 @@
 import { SlashCommandAttachmentOption, SlashCommandBooleanOption, SlashCommandChannelOption, SlashCommandIntegerOption, SlashCommandMentionableOption, SlashCommandNumberOption, SlashCommandRoleOption, SlashCommandStringOption, SlashCommandUserOption, type APIApplicationCommandOptionChoice, type ApplicationCommandNumericOptionMinMaxValueMixin, type ApplicationCommandOptionAllowedChannelTypes, type ApplicationCommandOptionBase, type ApplicationCommandOptionWithAutocompleteMixin, type ApplicationCommandOptionWithChoicesMixin, type Attachment, type GuildBasedChannel, type GuildMember, type LocalizationMap, type RestOrArray, type Role, type User } from "discord.js";
-declare abstract class BaseOption<Type, IsOptional extends OptionalType = "required"> {
+import type * as z from "zod";
+export declare abstract class BaseOption<Builder extends ApplicationCommandOptionBase, Type, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> {
+    readonly isOptional: IsOptional;
+    readonly validator: Validator | undefined;
     /**
      * Only for Typescript.
      */
     readonly type: Type;
-    readonly isOptional: IsOptional;
-    constructor(isOptional: IsOptional);
-}
-export declare abstract class BuilderOption<Builder extends ApplicationCommandOptionBase, Type, IsOptional extends OptionalType = "required"> extends BaseOption<Type, IsOptional> {
     protected builder: Builder;
-    constructor(builder: Builder, isOptional: IsOptional);
+    constructor(builder: Builder, isOptional: IsOptional, validator: Validator | undefined);
     describe(description: string): this;
     localize({ name, description }: {
         name?: LocalizationMap;
         description?: LocalizationMap;
     }): this;
+    abstract validate<T extends z.ZodType<any, Type>>(validator: T): Option<Type, IsOptional, T>;
 }
-export declare class AttachmentOption<Type = Attachment, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandAttachmentOption, Type, IsOptional> {
-    constructor(builder: SlashCommandAttachmentOption, isOptional: IsOptional);
+export declare class AttachmentOption<Type = Attachment, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandAttachmentOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandAttachmentOption, isOptional: IsOptional, validator?: Validator);
+    validate<T extends z.ZodType<any, Type>>(validator: T): AttachmentOption<Type, IsOptional, T>;
 }
-export declare class BooleanOption<Type = boolean, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandBooleanOption, Type, IsOptional> {
-    constructor(builder: SlashCommandBooleanOption, isOptional: IsOptional);
+export declare class BooleanOption<Type = boolean, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandBooleanOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandBooleanOption, isOptional: IsOptional, validator?: Validator);
+    validate<T extends z.ZodType<any, Type>>(validator: T): BooleanOption<Type, IsOptional, T>;
 }
-export declare class ChannelOption<Type = GuildBasedChannel, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandChannelOption, Type, IsOptional> {
-    constructor(builder: SlashCommandChannelOption, isOptional: IsOptional);
-    union<T extends ApplicationCommandOptionAllowedChannelTypes>(channelTypes: T[]): ChannelOption<Extract<GuildBasedChannel, {
+export declare class ChannelOption<Type = GuildBasedChannel, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandChannelOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandChannelOption, isOptional: IsOptional, validator?: Validator);
+    narrow<T extends ApplicationCommandOptionAllowedChannelTypes>(channelTypes: T[]): ChannelOption<Extract<GuildBasedChannel, {
         type: T;
     }>, IsOptional>;
+    validate<T extends z.ZodType<any, Type>>(validator: T): ChannelOption<Type, IsOptional, T>;
 }
-declare abstract class AutocompleteOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandOptionWithAutocompleteMixin, Type, IsOptional extends OptionalType = "required"> extends BuilderOption<Builder, Type, IsOptional> {
+declare abstract class AutocompleteOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandOptionWithAutocompleteMixin, Type, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<Builder, Type, IsOptional, Validator> {
     autocomplete(autocomplete?: boolean): this;
 }
 export declare class Choice<Type extends number | string> {
@@ -39,40 +42,46 @@ export declare class Choice<Type extends number | string> {
     }): this;
 }
 type InferChoiceType<T extends ApplicationCommandOptionWithChoicesMixin<any>> = T extends ApplicationCommandOptionWithChoicesMixin<infer Type> ? Type : never;
-declare abstract class ChoicesOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandOptionWithAutocompleteMixin & ApplicationCommandOptionWithChoicesMixin<any>, Type, IsOptional extends OptionalType = "required"> extends AutocompleteOption<Builder, Type, IsOptional> {
+declare abstract class ChoicesOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandOptionWithAutocompleteMixin & ApplicationCommandOptionWithChoicesMixin<any>, Type, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends AutocompleteOption<Builder, Type, IsOptional, Validator> {
     abstract union<UnionType extends InferChoiceType<Builder>>(...choices: RestOrArray<Choice<UnionType>>): Option<UnionType, IsOptional>;
 }
-declare abstract class NumbericOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandNumericOptionMinMaxValueMixin & ApplicationCommandOptionWithAutocompleteMixin & ApplicationCommandOptionWithChoicesMixin<number>, Type = number, IsOptional extends OptionalType = "required"> extends ChoicesOption<Builder, Type, IsOptional> {
+declare abstract class NumbericOption<Builder extends ApplicationCommandOptionBase & ApplicationCommandNumericOptionMinMaxValueMixin & ApplicationCommandOptionWithAutocompleteMixin & ApplicationCommandOptionWithChoicesMixin<number>, Type = number, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends ChoicesOption<Builder, Type, IsOptional, Validator> {
     min(min: number): this;
     max(max: number): this;
 }
-export declare class IntegerOption<Type = number, IsOptional extends OptionalType = "required"> extends NumbericOption<SlashCommandIntegerOption, Type, IsOptional> {
-    constructor(builder: SlashCommandIntegerOption, isOptional: IsOptional);
+export declare class IntegerOption<Type = number, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends NumbericOption<SlashCommandIntegerOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandIntegerOption, isOptional: IsOptional, validator?: Validator);
     union<UnionType extends number>(...choices: RestOrArray<Choice<UnionType>>): IntegerOption<UnionType, IsOptional>;
+    validate<T extends z.ZodType<any, Type>>(validator: T): IntegerOption<Type, IsOptional, T>;
 }
-export declare class NumberOption<Type = number, IsOptional extends OptionalType = "required"> extends NumbericOption<SlashCommandNumberOption, Type, IsOptional> {
-    constructor(builder: SlashCommandNumberOption, isOptional: IsOptional);
+export declare class NumberOption<Type = number, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends NumbericOption<SlashCommandNumberOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandNumberOption, isOptional: IsOptional, validator?: Validator);
     union<UnionType extends number>(...choices: RestOrArray<Choice<UnionType>>): NumberOption<UnionType, IsOptional>;
+    validate<T extends z.ZodType<any, Type>>(validator: T): NumberOption<Type, IsOptional, T>;
 }
-export declare class MentionableOption<Type = User | GuildMember | Role, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandMentionableOption, Type, IsOptional> {
-    constructor(builder: SlashCommandMentionableOption, isOptional: IsOptional);
+export declare class MentionableOption<Type = User | GuildMember | Role, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandMentionableOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandMentionableOption, isOptional: IsOptional, validator?: Validator);
+    validate<T extends z.ZodType<any, Type>>(validator: T): MentionableOption<Type, IsOptional, T>;
 }
-export declare class RoleOption<Type = Role, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandRoleOption, Type, IsOptional> {
-    constructor(builder: SlashCommandRoleOption, isOptional: IsOptional);
+export declare class RoleOption<Type = Role, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandRoleOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandRoleOption, isOptional: IsOptional, validator?: Validator);
+    validate<T extends z.ZodType<any, Type>>(validator: T): RoleOption<Type, IsOptional, T>;
 }
-export declare class StringOption<Type = string, IsOptional extends OptionalType = "required"> extends ChoicesOption<SlashCommandStringOption, Type, IsOptional> {
-    constructor(builder: SlashCommandStringOption, isOptional: IsOptional);
+export declare class StringOption<Type = string, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends ChoicesOption<SlashCommandStringOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandStringOption, isOptional: IsOptional, validator?: Validator);
     min(min: number): this;
     max(max: number): this;
     union<UnionType extends string>(...choices: RestOrArray<Choice<UnionType>>): StringOption<UnionType, IsOptional>;
+    validate<T extends z.ZodType<any, Type>>(validator: T): StringOption<Type, IsOptional, T>;
 }
-export declare class UserOption<Type = User, IsOptional extends OptionalType = "required"> extends BuilderOption<SlashCommandUserOption, Type, IsOptional> {
-    constructor(builder: SlashCommandUserOption, isOptional: IsOptional);
+export declare class UserOption<Type = User, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> extends BaseOption<SlashCommandUserOption, Type, IsOptional, Validator> {
+    constructor(builder: SlashCommandUserOption, isOptional: IsOptional, validator?: Validator);
+    validate<T extends z.ZodType<any, Type>>(validator: T): UserOption<Type, IsOptional, T>;
 }
 /**
  * A type representing whether an option is optional or not.
  */
 export type OptionalType = "required" | "optional";
-export type AsOptional<T extends Option<any, OptionalType>> = T extends AttachmentOption<infer Type, OptionalType> ? AttachmentOption<Type, "optional"> : T extends BooleanOption<infer Type, OptionalType> ? BooleanOption<Type, "optional"> : T extends ChannelOption<infer Type, OptionalType> ? ChannelOption<Type, "optional"> : T extends IntegerOption<infer Type, OptionalType> ? IntegerOption<Type, "optional"> : T extends NumberOption<infer Type, OptionalType> ? NumberOption<Type, "optional"> : T extends MentionableOption<infer Type, OptionalType> ? MentionableOption<Type, "optional"> : T extends RoleOption<infer Type, OptionalType> ? RoleOption<Type, "optional"> : T extends StringOption<infer Type, OptionalType> ? StringOption<Type, "optional"> : T extends UserOption<infer Type, OptionalType> ? UserOption<Type, "optional"> : never;
-export type Option<Type, IsOptional extends OptionalType = "required"> = AttachmentOption<Type, IsOptional> | BooleanOption<Type, IsOptional> | ChannelOption<Type, IsOptional> | IntegerOption<Type, IsOptional> | NumberOption<Type, IsOptional> | MentionableOption<Type, IsOptional> | RoleOption<Type, IsOptional> | StringOption<Type, IsOptional> | UserOption<Type, IsOptional>;
+export type AsOptional<T extends Option<any, OptionalType>> = T extends AttachmentOption<infer Type, OptionalType, infer Validator> ? AttachmentOption<Type, "optional", Validator> : T extends BooleanOption<infer Type, OptionalType, infer Validator> ? BooleanOption<Type, "optional", Validator> : T extends ChannelOption<infer Type, OptionalType, infer Validator> ? ChannelOption<Type, "optional", Validator> : T extends IntegerOption<infer Type, OptionalType, infer Validator> ? IntegerOption<Type, "optional", Validator> : T extends NumberOption<infer Type, OptionalType, infer Validator> ? NumberOption<Type, "optional", Validator> : T extends MentionableOption<infer Type, OptionalType, infer Validator> ? MentionableOption<Type, "optional", Validator> : T extends RoleOption<infer Type, OptionalType, infer Validator> ? RoleOption<Type, "optional", Validator> : T extends StringOption<infer Type, OptionalType, infer Validator> ? StringOption<Type, "optional", Validator> : T extends UserOption<infer Type, OptionalType, infer Validator> ? UserOption<Type, "optional", Validator> : never;
+export type Option<Type, IsOptional extends OptionalType = "required", Validator extends z.ZodType<any, Type> = z.ZodType<Type, Type>> = AttachmentOption<Type, IsOptional, Validator> | BooleanOption<Type, IsOptional, Validator> | ChannelOption<Type, IsOptional, Validator> | IntegerOption<Type, IsOptional, Validator> | NumberOption<Type, IsOptional, Validator> | MentionableOption<Type, IsOptional, Validator> | RoleOption<Type, IsOptional, Validator> | StringOption<Type, IsOptional, Validator> | UserOption<Type, IsOptional, Validator>;
 export {};