bakit 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/{BakitClient-CgtDS6Hr.d.ts → BakitClient-CU9viQZL.d.ts}

@@ -1,7 +1,35 @@
 import * as discord_js from 'discord.js';
-import { ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Awaitable, Collection, RESTPostAPIApplicationCommandsJSONBody, Client, ClientOptions, IntentsBitField } from 'discord.js';
+import { Awaitable, ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Collection, RESTPostAPIApplicationCommandsJSONBody, Client, ClientOptions, IntentsBitField } from 'discord.js';
 import { SetOptional } from 'type-fest';
 
+type ConstructorLike = new (...args: unknown[]) => object;
+declare enum HookExecutionState {
+    Main = "MAIN",
+    Pre = "PRE",
+    Post = "POST",
+    Error = "ERROR"
+}
+type BaseMainHookMethod<Args extends unknown[]> = (...args: Args) => Awaitable<void>;
+type BaseErrorHookMethod<Args extends unknown[]> = (error: unknown, ...args: Args) => Awaitable<void>;
+interface BaseHook {
+    state: HookExecutionState;
+    method: BaseMainHookMethod<never> | BaseErrorHookMethod<never>;
+    entry: unknown;
+}
+declare class BaseEntry<Constructor extends ConstructorLike, Hook extends BaseHook, MainHookMethod extends BaseMainHookMethod<never>, ErrorHookMethod extends BaseErrorHookMethod<never>> {
+    protected target?: Constructor;
+    hooks: Record<HookExecutionState, Hook | undefined>;
+    main: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    pre: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    post: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    error: <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    constructor();
+    setTarget(target: Constructor): void;
+    createMainHookDecorator(state: HookExecutionState): <T extends MainHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    createErrorHookDecorator(state: HookExecutionState): <T extends ErrorHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
+    protected addHook<T extends Hook["method"]>(state: HookExecutionState, target: object, descriptor: TypedPropertyDescriptor<T>): void;
+}
+
 type ChatInputContextSendOptions = string | InteractionReplyOptions;
 type MessageContextSendOptions = string | MessageCreateOptions;
 type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
@@ -30,26 +58,10 @@ declare class MessageContext<Cached extends boolean = boolean, InGuild extends b
 }
 type Context<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
-type CommandConstructor = new (...args: unknown[]) => object;
-declare function use(command: RootCommandEntry): (target: CommandConstructor) => void;
-declare function getRoot(constructor: CommandConstructor): RootCommandEntry | undefined;
-declare function CommandFactory(options: CreateCommandOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
-declare const Command: typeof CommandFactory & {
-    use: typeof use;
-    getRoot: typeof getRoot;
-};
-
-declare enum CommandHookExecutionState {
-    Main = "main",
-    Pre = "pre",
-    Post = "post",
-    Error = "error"
-}
-type CommandHookMethod = (ctx: Context, ...args: any[]) => Awaitable<void>;
-interface CommandHook {
-    state: CommandHookExecutionState;
-    method: CommandHookMethod;
-    entry: CommandEntry;
+type MainCommandHookMethod = BaseMainHookMethod<[context: Context, ...args: unknown[]]>;
+type ErrorCommandHookMethod = BaseErrorHookMethod<[context: Context, ...args: unknown[]]>;
+interface CommandHook extends BaseHook {
+    method: MainCommandHookMethod | ErrorCommandHookMethod;
 }
 interface BaseCommandEntryOptions {
     name: string;
@@ -57,42 +69,26 @@ interface BaseCommandEntryOptions {
     nsfw?: boolean;
 }
 type CreateCommandOptions<T extends BaseCommandEntryOptions> = SetOptional<T, "description"> | string;
-declare const HOOKS_KEY: unique symbol;
-declare abstract class BaseCommandEntry {
+declare class BaseCommandEntry extends BaseEntry<ConstructorLike, CommandHook, MainCommandHookMethod, ErrorCommandHookMethod> {
     options: BaseCommandEntryOptions;
-    private static cache;
-    main: <T extends CommandHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    pre: <T extends CommandHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    post: <T extends CommandHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
-    error: <T extends CommandHookMethod>(target: object, _key: string, descriptor: TypedPropertyDescriptor<T>) => void;
     constructor(options: BaseCommandEntryOptions);
-    static getHooks(constructor: CommandConstructor): readonly CommandHook[];
-    static getHooks(constructor: CommandConstructor, init: true): CommandHook[];
-    private static createMainHookDecorator;
-    private static createErrorHookDecorator;
-    private static addHook;
 }
-declare abstract class BaseCommandGroupEntry extends BaseCommandEntry {
+declare class BaseCommandGroupEntry extends BaseCommandEntry {
     children: Collection<string, CommandGroupEntry | SubcommandEntry>;
     subcommand(options: CreateCommandOptions<BaseCommandEntryOptions>): SubcommandEntry;
 }
+declare class RootCommandEntry extends BaseCommandGroupEntry {
+    group(options: CreateCommandOptions<BaseCommandEntryOptions>): CommandGroupEntry;
+}
 declare class CommandGroupEntry extends BaseCommandGroupEntry {
-    options: BaseCommandEntryOptions;
     parent: RootCommandEntry;
     children: Collection<string, SubcommandEntry>;
     constructor(options: BaseCommandEntryOptions, parent: RootCommandEntry);
 }
-declare class RootCommandEntry extends BaseCommandGroupEntry {
-    options: BaseCommandEntryOptions;
-    constructor(options: BaseCommandEntryOptions);
-    group(options: CreateCommandOptions<BaseCommandEntryOptions>): CommandGroupEntry;
-}
 declare class SubcommandEntry extends BaseCommandEntry {
-    options: BaseCommandEntryOptions;
-    parent: RootCommandEntry | CommandGroupEntry;
-    constructor(options: BaseCommandEntryOptions, parent: RootCommandEntry | CommandGroupEntry);
+    parent: BaseCommandGroupEntry;
+    constructor(options: BaseCommandEntryOptions, parent: BaseCommandGroupEntry);
 }
-type CommandEntry = RootCommandEntry | CommandGroupEntry | SubcommandEntry;
 
 declare enum ArgumentType {
     String = "string",
@@ -148,15 +144,38 @@ declare const Arg: {
     member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
 };
 
+declare namespace CommandAPI {
+    function use(command: RootCommandEntry): (target: ConstructorLike) => void;
+    function getRoot(constructor: ConstructorLike): RootCommandEntry | undefined;
+}
+declare function CommandFactory(options: CreateCommandOptions<BaseCommandEntryOptions> | string): RootCommandEntry;
+declare const Command: typeof CommandFactory & typeof CommandAPI;
+
 declare class CommandRegistry {
-    static constructors: Collection<string, CommandConstructor>;
+    static constructors: Collection<string, ConstructorLike>;
     static instances: Collection<string, object>;
-    static add(constructor: CommandConstructor): void;
-    static buildSlashCommand(constructor: CommandConstructor): RESTPostAPIApplicationCommandsJSONBody;
-    static loadDirectory(pattern: string, parallel?: boolean): Promise<CommandConstructor[]>;
+    /**
+     * Add a command to the registry.
+     * @param constructor The command class you want to add.
+     */
+    static add(constructor: ConstructorLike): void;
+    /**
+     * Load and add all commands which matched provided glob pattern to the registry.
+     * @param pattern glob pattern to load.
+     * @param parallel load all matched results in parallel, enabled by default.
+     * @returns All loaded command constructors.
+     */
+    static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
+    /**
+     * Build a command into application command data.
+     * @param constructor The command class you want to build.
+     * @returns a REST JSON version of the application command data.
+     */
+    static buildSlashCommand(constructor: ConstructorLike): RESTPostAPIApplicationCommandsJSONBody;
+    private static getMainHookArguments;
+    private static buildSlashCommandSubcommands;
     private static buildSlashCommandOptions;
-    private static buildSubcommand;
-    private static buildSlashCommandOption;
+    private static attachSlashCommandOption;
 }
 
 declare enum CommandSyntaxErrorType {
@@ -195,10 +214,11 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     private handleInteraction;
     private handleChatInputHooks;
     private handleMessageHooks;
+    private handleChildMessageHooks;
     private runMessageHooks;
     private runChatInputHooks;
+    private runHooks;
     private getChatInputTargetHooks;
-    private createHookRecord;
 }
 
-export { Arg as A, BakitClient as B, CommandHookExecutionState as C, CommandSyntaxError as D, type GetSyntaxErrorMessageFunction as G, HOOKS_KEY as H, type IntegerArgumentOptions as I, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, type BakitClientOptions as a, ArgumentType as b, type BaseArgumentOptions as c, type ArgumentOptions as d, type CommandHookMethod as e, type CommandHook as f, type BaseCommandEntryOptions as g, type CreateCommandOptions as h, BaseCommandEntry as i, BaseCommandGroupEntry as j, CommandGroupEntry as k, SubcommandEntry as l, type CommandEntry as m, type CommandConstructor as n, CommandFactory as o, Command as p, CommandRegistry as q, type ChatInputContextSendOptions as r, type MessageContextSendOptions as s, type ContextSendOptions as t, BaseContext as u, ChatInputContext as v, MessageContext as w, type Context as x, CommandSyntaxErrorType as y, type CommandSyntaxErrorOptions as z };
+export { Arg as A, BaseEntry as B, type ConstructorLike as C, type Context as D, type ErrorCommandHookMethod as E, CommandSyntaxErrorType as F, type GetSyntaxErrorMessageFunction as G, type CommandSyntaxErrorOptions as H, type IntegerArgumentOptions as I, CommandSyntaxError as J, type MemberArgumentOptions as M, type NumberArgumentOptions as N, RootCommandEntry as R, type StringArgumentOptions as S, type UserArgumentOptions as U, type BaseHook as a, type BaseMainHookMethod as b, type BaseErrorHookMethod as c, BakitClient as d, type BakitClientOptions as e, ArgumentType as f, type BaseArgumentOptions as g, type ArgumentOptions as h, type MainCommandHookMethod as i, type CommandHook as j, type BaseCommandEntryOptions as k, type CreateCommandOptions as l, BaseCommandEntry as m, BaseCommandGroupEntry as n, CommandGroupEntry as o, SubcommandEntry as p, CommandAPI as q, CommandFactory as r, Command as s, CommandRegistry as t, type ChatInputContextSendOptions as u, type MessageContextSendOptions as v, type ContextSendOptions as w, BaseContext as x, ChatInputContext as y, MessageContext as z };

package/dist/command/index.d.ts

@@ -1,3 +1,3 @@
-export { A as Arg, d as ArgumentOptions, b as ArgumentType, c as BaseArgumentOptions, i as BaseCommandEntry, g as BaseCommandEntryOptions, j as BaseCommandGroupEntry, u as BaseContext, v as ChatInputContext, r as ChatInputContextSendOptions, p as Command, n as CommandConstructor, m as CommandEntry, o as CommandFactory, k as CommandGroupEntry, f as CommandHook, C as CommandHookExecutionState, e as CommandHookMethod, q as CommandRegistry, x as Context, t as ContextSendOptions, h as CreateCommandOptions, H as HOOKS_KEY, I as IntegerArgumentOptions, M as MemberArgumentOptions, w as MessageContext, s as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, l as SubcommandEntry, U as UserArgumentOptions } from '../BakitClient-CgtDS6Hr.js';
+export { A as Arg, h as ArgumentOptions, f as ArgumentType, g as BaseArgumentOptions, m as BaseCommandEntry, k as BaseCommandEntryOptions, n as BaseCommandGroupEntry, x as BaseContext, y as ChatInputContext, u as ChatInputContextSendOptions, s as Command, q as CommandAPI, r as CommandFactory, o as CommandGroupEntry, j as CommandHook, t as CommandRegistry, D as Context, w as ContextSendOptions, l as CreateCommandOptions, E as ErrorCommandHookMethod, I as IntegerArgumentOptions, i as MainCommandHookMethod, M as MemberArgumentOptions, z as MessageContext, v as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, p as SubcommandEntry, U as UserArgumentOptions } from '../BakitClient-CU9viQZL.js';
 import 'discord.js';
 import 'type-fest';

package/dist/command/index.js

@@ -106,138 +106,115 @@ var Arg = {
 
 // src/command/CommandEntry.ts
 import { Collection } from "discord.js";
-var CommandHookExecutionState = /* @__PURE__ */ ((CommandHookExecutionState2) => {
-  CommandHookExecutionState2["Main"] = "main";
-  CommandHookExecutionState2["Pre"] = "pre";
-  CommandHookExecutionState2["Post"] = "post";
-  CommandHookExecutionState2["Error"] = "error";
-  return CommandHookExecutionState2;
-})(CommandHookExecutionState || {});
-var HOOKS_KEY = Symbol("hooks");
-var BaseCommandEntry = class _BaseCommandEntry {
-  constructor(options) {
-    this.options = options;
-  }
-  static cache = /* @__PURE__ */ new WeakMap();
-  main = _BaseCommandEntry.createMainHookDecorator("main" /* Main */, this);
-  pre = _BaseCommandEntry.createMainHookDecorator("pre" /* Pre */, this);
-  post = _BaseCommandEntry.createMainHookDecorator("post" /* Post */, this);
-  error = _BaseCommandEntry.createErrorHookDecorator("error" /* Error */, this);
-  static getHooks(constructor, init = false) {
-    let hooks = this.cache.get(constructor) ?? Reflect.getMetadata(HOOKS_KEY, constructor);
-    if (!hooks) {
-      hooks = [];
-      if (init) {
-        Reflect.defineMetadata(HOOKS_KEY, hooks, constructor);
-        this.cache.set(constructor, hooks);
-      }
-    }
-    return init ? hooks : Object.freeze([...hooks]);
-  }
-  static createMainHookDecorator(state, entry) {
+
+// src/base/BaseEntry.ts
+var BaseEntry = class {
+  target;
+  hooks = {
+    ["MAIN" /* Main */]: void 0,
+    ["ERROR" /* Error */]: void 0,
+    ["POST" /* Post */]: void 0,
+    ["PRE" /* Pre */]: void 0
+  };
+  main;
+  pre;
+  post;
+  error;
+  constructor() {
+    this.main = this.createMainHookDecorator("MAIN" /* Main */);
+    this.pre = this.createMainHookDecorator("PRE" /* Pre */);
+    this.post = this.createMainHookDecorator("POST" /* Post */);
+    this.error = this.createMainHookDecorator("ERROR" /* Error */);
+  }
+  setTarget(target) {
+    this.target = target;
+  }
+  createMainHookDecorator(state) {
     return (target, _key, descriptor) => {
-      this.addHook(target, state, descriptor.value, entry);
+      this.addHook(state, target, descriptor);
     };
   }
-  static createErrorHookDecorator(state, entry) {
+  createErrorHookDecorator(state) {
     return (target, _key, descriptor) => {
-      this.addHook(target, state, descriptor.value, entry);
+      this.addHook(state, target, descriptor);
     };
   }
-  static addHook(target, state, method, entry) {
-    const { constructor } = target;
-    const hooks = _BaseCommandEntry.getHooks(constructor, true);
-    if (typeof method !== "function") {
-      throw new Error("CommandEntry decorator must be used with a class method.");
+  addHook(state, target, descriptor) {
+    if (target.constructor !== this.target) {
+      throw new Error("Hook is used at unknown constructor.");
     }
-    if (hooks.some((hook) => hook.state === state && hook.entry === entry)) {
-      throw new Error(`Hook "${state}" is already defined for entry "${entry.options.name}".`);
-    }
-    if ("parent" in entry) {
-      const parentHook = hooks.find(
-        (hook) => hook.entry === entry.parent && hook.state === "main" /* Main */
-      );
-      if (parentHook) {
-        const parentArgs = Arg.getMethodArguments(parentHook.method);
-        if (parentArgs.at(-1)?.tuple) {
-          throw new Error(
-            `Cannot add hook "${state}" to entry "${entry.options.name}" because its parent "${entry.parent.options.name}" has a tuple argument.`
-          );
-        }
-      }
+    const { value: method } = descriptor;
+    if (typeof method !== "function") {
+      throw new Error("Invalid target method for hook.");
     }
-    hooks.push({
+    const hook = {
       state,
-      entry,
-      method
-    });
+      method,
+      entry: this
+    };
+    this.hooks[state] = hook;
+  }
+};
+
+// src/command/CommandEntry.ts
+var BaseCommandEntry = class extends BaseEntry {
+  constructor(options) {
+    super();
+    this.options = options;
   }
 };
 var BaseCommandGroupEntry = class extends BaseCommandEntry {
   children = new Collection();
   subcommand(options) {
-    if (typeof options === "string") {
-      options = { name: options };
+    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    if (this.children.has(fullOptions.name)) {
+      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    if (this.children.has(options.name)) {
-      throw new Error(`Entry with name "${options.name}" already exists.`);
-    }
-    if (!(this instanceof CommandGroupEntry) && !(this instanceof RootCommandEntry)) {
-      throw new Error(`Invalid parent "${this.constructor.name}"`);
+    const subcommand = new SubcommandEntry(fullOptions, this);
+    this.children.set(fullOptions.name, subcommand);
+    return subcommand;
+  }
+};
+var RootCommandEntry = class extends BaseCommandGroupEntry {
+  group(options) {
+    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    if (this.children.has(fullOptions.name)) {
+      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
-    const entry = new SubcommandEntry(options, this);
-    this.children.set(entry.options.name, entry);
-    return entry;
+    const group = new CommandGroupEntry(fullOptions, this);
+    this.children.set(fullOptions.name, group);
+    return group;
   }
 };
 var CommandGroupEntry = class extends BaseCommandGroupEntry {
   constructor(options, parent) {
     super(options);
-    this.options = options;
     this.parent = parent;
   }
 };
-var RootCommandEntry = class extends BaseCommandGroupEntry {
-  constructor(options) {
-    super(options);
-    this.options = options;
-  }
-  group(options) {
-    if (typeof options === "string") {
-      options = { name: options };
-    }
-    if (!options.description) {
-      options.description = options.name;
-    }
-    if (this.children.has(options.name)) {
-      throw new Error(`Entry with name "${options.name}" already exists.`);
-    }
-    const entry = new CommandGroupEntry(options, this);
-    this.children.set(entry.options.name, entry);
-    return entry;
-  }
-};
 var SubcommandEntry = class extends BaseCommandEntry {
   constructor(options, parent) {
     super(options);
-    this.options = options;
     this.parent = parent;
   }
 };
 
 // src/command/Command.ts
-var ROOT_KEY = Symbol("root");
-function use(command) {
-  return (target) => {
-    Reflect.defineMetadata(ROOT_KEY, command, target);
-  };
-}
-function getRoot(constructor) {
-  return Reflect.getMetadata(ROOT_KEY, constructor);
-}
+var CommandAPI;
+((CommandAPI2) => {
+  const ROOT_KEY = Symbol("root");
+  function use(command) {
+    return (target) => {
+      command.setTarget(target);
+      Reflect.defineMetadata(ROOT_KEY, command, target);
+    };
+  }
+  CommandAPI2.use = use;
+  function getRoot(constructor) {
+    return Reflect.getMetadata(ROOT_KEY, constructor);
+  }
+  CommandAPI2.getRoot = getRoot;
+})(CommandAPI || (CommandAPI = {}));
 function CommandFactory(options) {
   if (typeof options === "string") {
     options = { name: options };
@@ -247,10 +224,7 @@ function CommandFactory(options) {
   }
   return new RootCommandEntry(options);
 }
-var Command = Object.assign(CommandFactory, {
-  use,
-  getRoot
-});
+var Command = Object.assign(CommandFactory, CommandAPI);
 
 // src/command/CommandRegistry.ts
 import {
@@ -264,6 +238,10 @@ import { pathToFileURL } from "url";
 var CommandRegistry = class _CommandRegistry {
   static constructors = new Collection2();
   static instances = new Collection2();
+  /**
+   * Add a command to the registry.
+   * @param constructor The command class you want to add.
+   */
   static add(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
@@ -273,20 +251,13 @@ var CommandRegistry = class _CommandRegistry {
     this.constructors.set(options.name, constructor);
     this.instances.set(options.name, new constructor());
   }
-  static buildSlashCommand(constructor) {
-    const builder = new SlashCommandBuilder();
-    const root = Command.getRoot(constructor);
-    if (!root) {
-      throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    builder.setName(options.name);
-    builder.setDescription(options.description || "");
-    builder.setNSFW(Boolean(options.nsfw));
-    this.buildSlashCommandOptions(builder, constructor);
-    return builder.toJSON();
-  }
-  static async loadDirectory(pattern, parallel = true) {
+  /**
+   * Load and add all commands which matched provided glob pattern to the registry.
+   * @param pattern glob pattern to load.
+   * @param parallel load all matched results in parallel, enabled by default.
+   * @returns All loaded command constructors.
+   */
+  static async load(pattern, parallel = true) {
     const files = await glob(pattern);
     const loaders = files.map(async (file) => {
       const fileURL = pathToFileURL(file).toString();
@@ -303,72 +274,102 @@ var CommandRegistry = class _CommandRegistry {
     }
     return result;
   }
-  static buildSlashCommandOptions(builder, constructor) {
+  /**
+   * Build a command into application command data.
+   * @param constructor The command class you want to build.
+   * @returns a REST JSON version of the application command data.
+   */
+  static buildSlashCommand(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
       throw new Error(`No root found for "${constructor.name}"`);
     }
-    const hooks = new Collection2(
-      BaseCommandEntry.getHooks(constructor).filter((hook) => hook.state === "main" /* Main */).map((hook) => [hook.entry, hook])
-    );
-    const rootHook = hooks.get(root);
-    if (!root.children.size && hooks.size) {
-      if (!rootHook) {
-        return;
-      }
-      for (const arg of Arg.getMethodArguments(rootHook.method)) {
-        this.buildSlashCommandOption(builder, arg);
-      }
-      return;
+    const { options } = root;
+    const builder = new SlashCommandBuilder().setName(options.name).setDescription(options.description).setNSFW(Boolean(options.nsfw));
+    const args = this.getMainHookArguments(root);
+    if (root.children.size) {
+      this.buildSlashCommandSubcommands(builder, root, args);
+    } else {
+      this.buildSlashCommandOptions(builder, args);
     }
-    for (const child of root.children.values()) {
-      const hook = hooks.get(child);
-      const inheritedArgs = [];
-      if (rootHook) {
-        inheritedArgs.push(...Arg.getMethodArguments(rootHook.method));
-      }
-      if (child instanceof SubcommandEntry) {
-        this.buildSubcommand(builder, child, hook, inheritedArgs);
-      } else if (child instanceof CommandGroupEntry) {
-        if (hook) {
-          inheritedArgs.push(...Arg.getMethodArguments(hook.method));
-        }
+    return builder.toJSON();
+  }
+  static getMainHookArguments(entry) {
+    const { hooks } = entry;
+    const mainHook = hooks["MAIN" /* Main */];
+    return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
+  }
+  static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
+    const { children } = entry;
+    for (const child of children.values()) {
+      if (child instanceof CommandGroupEntry && parent instanceof SlashCommandBuilder) {
         const { options } = child;
         const group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
-        for (const subChild of child.children.values()) {
-          this.buildSubcommand(group, subChild, hooks.get(subChild), inheritedArgs);
-        }
-        builder.addSubcommandGroup(group);
+        this.buildSlashCommandSubcommands(group, child, [
+          ...inheritedArgs,
+          ...this.getMainHookArguments(child)
+        ]);
+        parent.addSubcommandGroup(group);
+      } else if (child instanceof SubcommandEntry) {
+        const { options } = child;
+        const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
+        this.buildSlashCommandOptions(subcommand, [
+          ...inheritedArgs,
+          ...this.getMainHookArguments(child)
+        ]);
+        parent.addSubcommand(subcommand);
       }
     }
   }
-  static buildSubcommand(parent, entry, hook, inheritedArgs) {
-    const { options } = entry;
-    const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
-    const args = [...inheritedArgs];
-    if (hook) {
-      args.push(...Arg.getMethodArguments(hook.method));
-    }
-    for (const arg of args) {
-      this.buildSlashCommandOption(subcommand, arg);
+  static buildSlashCommandOptions(builder, args) {
+    const argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional");
+    const orderedArgs = [...argGroup.required || [], ...argGroup.optional || []];
+    for (const arg of orderedArgs) {
+      this.attachSlashCommandOption(builder, arg);
     }
-    parent.addSubcommand(subcommand);
   }
-  static buildSlashCommandOption(builder, arg) {
+  static attachSlashCommandOption(builder, arg) {
     const setupOption = (option) => {
       return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
     };
     switch (arg.type) {
       case "string" /* String */: {
-        builder.addStringOption((option) => setupOption(option));
+        builder.addStringOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxLength) {
+            option.setMaxLength(arg.maxLength);
+          }
+          if (arg.minLength) {
+            option.setMinLength(arg.minLength);
+          }
+          return option;
+        });
         break;
       }
       case "integer" /* Integer */: {
-        builder.addIntegerOption((option) => setupOption(option));
+        builder.addIntegerOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxValue) {
+            option.setMaxValue(arg.maxValue);
+          }
+          if (arg.minValue) {
+            option.setMinValue(arg.minValue);
+          }
+          return option;
+        });
         break;
       }
       case "number" /* Number */: {
-        builder.addNumberOption((option) => setupOption(option));
+        builder.addNumberOption((data) => {
+          const option = setupOption(data);
+          if (arg.maxValue) {
+            option.setMaxValue(arg.maxValue);
+          }
+          if (arg.minValue) {
+            option.setMinValue(arg.minValue);
+          }
+          return option;
+        });
         break;
       }
       case "user" /* User */:
@@ -465,11 +466,10 @@ export {
   BaseContext,
   ChatInputContext,
   Command,
+  CommandAPI,
   CommandFactory,
   CommandGroupEntry,
-  CommandHookExecutionState,
   CommandRegistry,
-  HOOKS_KEY,
   MessageContext,
   RootCommandEntry,
   SubcommandEntry