@pikokr/command.ts 4.0.6 → 5.0.0-dev.572678b

package/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: 'CodeQL'
+
+on:
+  push:
+    branches: [dev]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [dev]
+  schedule:
+    - cron: '31 4 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['javascript']
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        with:
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+          # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v1
+
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 https://git.io/JvXDl
+
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+      #    and modify them (or add more) to build your code if your project
+      #    uses a compiled language
+
+      #- run: |
+      #   make bootstrap
+      #   make release
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v1

package/.github/workflows/docs.yml

@@ -76,4 +76,4 @@ jobs:
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
           git add .
           git commit -m "Docs build for ${BRANCH_OR_TAG} ${BRANCH_NAME}: ${SHA}" || true
-          git push
+          git push

package/.github/workflows/publish.stable.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 16.6
+          node-version: 16.16
       - run: yarn
       - uses: JS-DevTools/npm-publish@v1
         with:

package/.github/workflows/publish.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-node@v1
         with:
-          node-version: 16.6
+          node-version: 16.16
       - run: yarn
       - run: COMMIT_ID=$(git rev-parse --short HEAD) node publish-version.js
       - uses: JS-DevTools/npm-publish@v1

package/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+  "license-header-manager.additionalCommentStyles": [
+    {
+      "extension": ".ts",
+      "commentStart": "/*",
+      "commentEnd": "*/",
+      "commentMiddle": "*"
+    }
+  ]
+}

package/.vscode/templates/ts.lict

@@ -0,0 +1,5 @@
+File: %(File)
+
+Copyright (c) %(CreationYear)-%(CurrentYear) %(Username)
+
+Licensed under MIT License. Please see more defails in LICENSE file.

package/README.md

@@ -2,6 +2,7 @@
 
 [![.github/workflows/publish.yml](https://github.com/pikokr/command.ts/actions/workflows/publish.yml/badge.svg)](https://github.com/pikokr/command.ts/actions/workflows/publish.yml) <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
 [![All Contributors](https://img.shields.io/badge/all_contributors-2-orange.svg?style=flat-square)](#contributors-)
+
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 ![cts](https://user-images.githubusercontent.com/68010770/145200458-b14c5e4e-6927-4516-8d48-c68a384d2a20.png)
@@ -11,6 +12,7 @@ Command framework for discord.js
 [Discord](https://discord.gg/EEhcPzsGHV) / [문서](https://v3.cts.pikokr.dev) / [V2 문서](https://command-ts-docs-ezojnktwv-pikokr.vercel.app/)
 
 ## Contributors
+
 <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
 <!-- prettier-ignore-start -->
 <!-- markdownlint-disable -->

package/dist/index.d.ts

@@ -1,321 +1,159 @@
+import * as discord_js from 'discord.js';
+import { Collection, Snowflake, Interaction, ChatInputCommandInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, Client, UserApplicationCommandData, MessageApplicationCommandData, ChatInputApplicationCommandData, ApplicationCommandType, APIApplicationCommandOption } from 'discord.js';
+import EventEmitter from 'events';
 import * as tslog from 'tslog';
 import { Logger } from 'tslog';
-import { ApplicationCommandDataResolvable, Snowflake, MessageComponentInteraction, MessageComponentType, Collection, Message, CommandInteraction, Interaction, Client, ContextMenuInteraction, PermissionResolvable, GuildMember, Permissions } from 'discord.js';
 
-declare class Listener {
-    name: string;
-    execute: Function;
-    constructor(name: string, execute: Function);
-}
-
-declare const listener: (event: string) => (target: Module, propertyKey: string) => void;
-
-declare type ApplicationCommandOptions$1 = {
-    guild: Snowflake | Snowflake[];
-    optionTypes?: any[];
+declare type ModuleHookStore = Collection<string, Function[]>;
+declare const getModuleHookStore: (target: object) => ModuleHookStore;
+declare const moduleHook: (name: string) => MethodDecorator;
+
+declare type ComponentHookFn = (...args: any[]) => void | Promise<void>;
+declare type ComponentHookStore = Collection<string, ComponentHookFn[]>;
+declare const createComponentHook: (name: string, fn: ComponentHookFn) => MethodDecorator;
+
+declare class ComponentArgumentDecorator<Options = unknown> {
+    options: Options;
+    constructor(options: Partial<Options>);
+    defaultOptions(): Options;
+}
+
+declare class ComponentArgument {
+    type: unknown;
+    decorators: ComponentArgumentDecorator[];
+    constructor(type: unknown);
+}
+
+declare class BaseComponent<Options = unknown, OptionsArg = Options> {
+    options: Options;
+    method: Function;
+    hooks: ComponentHookStore;
+    argTypes: Collection<number, ComponentArgument>;
+    constructor(options: OptionsArg, method: Function, argTypes: unknown[]);
+    convertOptions(options: OptionsArg): Options;
+    executeHook(target: object, name: string, args: unknown[]): Promise<void>;
+    execute(target: object, args: unknown[], beforeCallArgs?: unknown[]): Promise<any>;
+}
+
+declare type ComponentStore = Collection<string | symbol, BaseComponent>;
+declare type ComponentArgumentStore = Collection<number, ComponentArgumentDecorator>;
+declare const getComponentStore: (target: object) => ComponentStore;
+declare const getComponent: (target: object, key: string | symbol) => BaseComponent<unknown, unknown> | undefined;
+declare const createComponentDecorator: <Options, OptionArgs>(type: {
+    new (options: OptionArgs, method: Function, argTypes: unknown[]): BaseComponent<Options, OptionArgs>;
+}) => (options: OptionArgs) => MethodDecorator;
+declare const getComponentArgumentStore: (target: object, key: string | symbol) => ComponentArgumentStore;
+declare const createArgumentDecorator: <Options>(type: {
+    new (options: Partial<Options>): ComponentArgumentDecorator<Options>;
+}) => (options: Options) => ParameterDecorator;
+
+declare type Options = {
+    component: typeof BaseComponent<unknown>;
+    type: Function;
+    parameterless: boolean;
 };
-declare const applicationCommand: (opt: Partial<ApplicationCommandOptions$1> & {
-    command: ApplicationCommandDataResolvable;
-}) => (target: Object, propertyKey: string) => void;
-declare const option: (key: string) => ParameterDecorator;
-
-declare type AppCommandArgument = {
-    type: any;
-    name?: string;
-};
-declare class AppCommand {
-    command: ApplicationCommandDataResolvable;
-    private run;
-    module: Module;
-    params: AppCommandArgument[];
-    guild: Snowflake | Snowflake[] | undefined;
-    private key;
-    get checks(): ApplicationCommandCheckFunction[];
-    execute(module: Module, args: any[]): any;
-    constructor(command: ApplicationCommandDataResolvable, run: Function, module: Module, params: AppCommandArgument[], guild: Snowflake | Snowflake[] | undefined, key: string | symbol);
-}
-
-declare type MessageComponentExecutor = (i: MessageComponentInteraction) => void | Promise<void>;
-declare class MessageComponentHandler {
-    componentId: string;
-    componentType: Exclude<MessageComponentType, 'ACTION_ROW'>;
-    execute: MessageComponentExecutor;
-    constructor(componentId: string, componentType: Exclude<MessageComponentType, 'ACTION_ROW'>, execute: MessageComponentExecutor);
-    run(module: Module, i: MessageComponentInteraction): void | Promise<void>;
+declare class ConverterComponent extends BaseComponent<Options, Options & {
+    parameterless?: boolean;
+}> {
 }
+declare const argConverter: (options: Options & {
+    parameterless?: boolean | undefined;
+}) => MethodDecorator;
 
-declare class Registry {
-    client: CommandClient;
-    constructor(client: CommandClient);
-    modules: Collection<symbol, Module>;
-    private get logger();
-    get commands(): Command[];
-    get argumentConverters(): ArgumentConverter[];
-    get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[];
-    get applicationCommands(): AppCommand[];
-    get messageComponentHandlers(): MessageComponentHandler[];
-    registerModule(module: Module): Module;
-    loadModulesIn(dir: string, absolute?: boolean): Promise<void>;
-    loadModule(file: string, absolute?: boolean): Promise<Module>;
-    syncCommands(): Promise<void>;
-    unregisterModule(module: Module): Promise<Module>;
-    unloadModule(module: Module): Promise<void>;
-    reloadModule(module: Module): Promise<boolean>;
-    reloadAll(): Promise<{
-        path: string;
-        success: boolean;
-        error?: Error | undefined;
-    }[]>;
-}
-
-interface CommandOptions$1 {
-    prefix: string | ((msg: any) => string | Promise<string | string[]> | string[]) | string[];
-    check: (msg: Message) => boolean | Promise<boolean>;
-}
-interface SlashCommandOptions {
-    check: (i: CommandInteraction) => boolean | Promise<boolean>;
-}
-interface ApplicationCommandOptions {
-    guild?: Snowflake | Snowflake[];
-    autoSync: boolean;
-    beforeRunCheck: (i: Interaction) => void | Promise<void>;
-}
-interface CommandClientOptions {
-    command: CommandOptions$1;
-    owners: 'auto' | Snowflake[];
-    slashCommands: SlashCommandOptions;
-    applicationCommands: ApplicationCommandOptions;
-}
-interface CommandClientOptionsParam {
-    command: Partial<CommandOptions$1>;
-    owners: 'auto' | string[];
-    slashCommands: Partial<SlashCommandOptions>;
-    applicationCommands: Partial<ApplicationCommandOptions>;
-}
-declare class CommandClient {
-    options: CommandClientOptions;
-    owners: string[];
-    registry: Registry;
-    client: Client;
-    coolDownAdapter: CoolDownAdapter;
-    logger: Logger;
-    private _isReady;
-    private fetchOwners;
-    ready(): Promise<void>;
-    constructor({ client, coolDownAdapter, logger, ...options }: Partial<CommandClientOptionsParam> & {
-        client: Client;
-        coolDownAdapter?: CoolDownAdapter;
-        logger?: Logger;
-    });
-}
-
-declare abstract class Module {
-    commandClient: CommandClient;
-    get logger(): tslog.Logger;
-    get commands(): Command[];
-    get listeners(): Listener[];
-    get argumentConverters(): ArgumentConverter[];
-    get applicationCommandArgumentConverters(): ApplicationCommandArgumentConverter[];
-    get applicationCommands(): AppCommand[];
-    get messageComponentHandlers(): MessageComponentHandler[];
-    get path(): string | undefined;
-    load(): void;
-    unload(): void;
-    beforeReload(): void;
-    afterReload(): void;
-}
-
-declare type Argument = {
-    optional: boolean;
-    type: any;
-    rest: boolean;
-};
-declare type CheckFunction = (msg: Message) => boolean | Promise<boolean>;
-declare type ApplicationCommandCheckFunction = (i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>;
-declare class Command {
-    private run;
-    argTypes: Argument[];
-    name: string;
-    aliases: string[] | ((msg: Message) => string[] | Promise<string[]>);
-    module: Module;
-    key: symbol | string;
-    execute(module: Module, args: any[]): any;
-    get checks(): CheckFunction[];
-    constructor(run: Function, argTypes: Argument[], name: string, aliases: string[] | ((msg: Message) => string[] | Promise<string[]>), module: Module, key: symbol | string);
-}
-
-declare type CommandOptions = {
-    name: string;
-    aliases: string[] | ((msg: Message) => string[]);
-    optionTypes?: any[];
-};
-declare const command: (options?: Partial<CommandOptions>) => (target: Object, propertyKey: string) => void;
-declare const argumentConverter: (type: object, requireParameter?: boolean) => (target: Object, propertyKey: string) => void;
-declare const applicationCommandArgumentConverter: (type: object) => (target: Object, propertyKey: string) => void;
-declare const optional: ParameterDecorator;
-declare const rest: ParameterDecorator;
+declare const createCheckDecorator: (fn: ComponentHookFn) => MethodDecorator;
 declare const ownerOnly: MethodDecorator;
-declare const guildOnly: MethodDecorator;
-declare const dmOnly: MethodDecorator;
-declare const requireUserPermissions: (permission: PermissionResolvable) => MethodDecorator;
-declare const requireClientPermissions: (permission: PermissionResolvable) => MethodDecorator;
-
-declare class ArgumentConverter {
-    type: object;
-    private run;
-    withoutParameter: boolean;
-    execute(module: Module, msg: Message, arg?: string): any;
-    constructor(type: object, run: Function, withoutParameter: boolean);
-}
-declare class ApplicationCommandArgumentConverter {
-    type: object;
-    private run;
-    execute(module: Module, interaction: CommandInteraction | ContextMenuInteraction): any;
-    constructor(type: object, run: Function);
-}
-
-declare const createCheckDecorator: (execute: ((msg: Message) => boolean | Promise<boolean>) | null, executeApplicationCommand?: ((i: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction) => boolean | Promise<boolean>) | undefined) => MethodDecorator;
 
-declare enum CoolDownType {
-    USER = 0,
-    CHANNEL = 1,
-    GUILD = 2,
-    ROLE = 3,
-    CATEGORY = 4,
-    MEMBER = 5
+declare class OwnerOnlyError {
 }
 
-declare const coolDown: (type: CoolDownType, seconds: number) => MethodDecorator;
-
-interface CoolDownAdapter {
-    get(id: string): Promise<number | undefined>;
-    set(id: string, value: number): Promise<void>;
-}
-declare class DefaultCoolDownAdapter implements CoolDownAdapter {
-    map: Collection<string, number>;
-    get(id: string): Promise<number | undefined>;
-    set(id: string, value: number): Promise<void>;
+declare class ListenerComponent extends BaseComponent<{
+    emitter: string;
+    event: string;
+}, {
+    emitter?: string;
+    event: string;
+}> {
+    defaultOptions(): {
+        emitter: string;
+    };
+    constructor(options: ListenerComponent['options'], method: Function, argTypes: unknown[]);
 }
+declare const listener: (options: {
+    emitter?: string | undefined;
+    event: string;
+}) => MethodDecorator;
 
-declare class CoolDownError extends Error {
-    endsAt: Date;
-    constructor(endsAt: Date);
-}
-
-declare module 'discord.js' {
-    interface Message {
-        data: {
-            command: Command | null;
-            prefix: string;
-            cts: CommandClient;
-        };
-    }
-    interface CommandInteraction {
-        data: {
-            command: AppCommand;
-            cts: CommandClient;
-        };
-    }
-    interface MessageComponentInteraction {
-        data: {
-            command: AppCommand;
-            cts: CommandClient;
-        };
-    }
-    interface ContextMenuInteraction {
-        data: {
-            command: AppCommand;
-            cts: CommandClient;
-        };
-    }
-}
-
-declare class InvalidTargetError extends Error {
-    constructor();
-}
-
-declare class ModuleLoadError extends Error {
-    error: Error;
-    constructor(file: string, error: Error);
-}
-declare class InvalidModuleError extends Error {
+declare class Extension {
+    protected get commandClient(): CommandClient;
+    protected get client(): discord_js.Client<boolean>;
+    protected _logger?: Logger;
+    protected get logger(): Logger;
+    protected convertArguments(component: typeof BaseComponent<unknown>, argList: unknown[], args: Collection<number, ComponentArgument>, getConverterArgs: (arg: ComponentArgument, index: number) => unknown[] | Promise<unknown[]>): Promise<void>;
 }
 
-declare class ArgumentNotProvided extends Error {
-    index: number;
-    command: Command;
-    msg: Message;
-    constructor(index: number, command: Command, msg: Message);
+declare class CTSExtension extends Extension {
+    protected get logger(): tslog.Logger;
 }
 
-declare class ArgumentConverterNotFound extends Error {
-    type: Argument;
-    msg: Message;
-    constructor(type: Argument, msg: Message);
-}
-declare class ApplicationCommandArgumentConverterNotFound extends Error {
-    type: AppCommandArgument;
-    interaction: CommandInteraction | ContextMenuInteraction;
-    constructor(type: AppCommandArgument, interaction: CommandInteraction | ContextMenuInteraction);
-}
-
-declare class CommandCheckFailed extends Error {
-    msg: Message;
-    command: Command;
-    constructor(msg: Message, command: Command);
-}
-declare class ApplicationCommandCheckFailed extends Error {
-    interaction: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction;
-    command: AppCommand;
-    constructor(interaction: CommandInteraction | MessageComponentInteraction | ContextMenuInteraction, command: AppCommand);
-}
-
-declare class UserPermissionRequired extends Error {
-    user: GuildMember;
-    permissions: Permissions;
-    constructor(user: GuildMember, permissions: Permissions);
-}
-declare class ClientPermissionRequired extends Error {
-    permissions: Permissions;
-    constructor(permissions: Permissions);
-}
-
-declare class OwnerOnlyCommandError extends Error {
-    constructor();
-}
-
-declare class GuildOnlyCommandError extends Error {
-    constructor();
-}
-
-declare class DMOnlyCommandError extends Error {
-    constructor();
-}
-
-declare class SlashCommandGlobalCheckError extends Error {
-    i: CommandInteraction;
-    constructor(i: CommandInteraction);
+declare type ApplicationCommandExtensionConfig = {
+    guilds?: Snowflake[];
+};
+declare class ApplicationCommandExtension extends CTSExtension {
+    config: ApplicationCommandExtensionConfig;
+    constructor(config: ApplicationCommandExtensionConfig);
+    interactionCreate(i: Interaction): Promise<void>;
+    load(): Promise<void>;
+    sync(): Promise<void>;
+    chatInteraction(i: ChatInputCommandInteraction): Promise<ChatInputCommandInteraction<discord_js.CacheType>>;
+    messageInteraction(i: MessageContextMenuCommandInteraction): Promise<MessageContextMenuCommandInteraction<discord_js.CacheType>>;
+    userInteraction(i: UserContextMenuCommandInteraction): Promise<UserContextMenuCommandInteraction<discord_js.CacheType>>;
+}
+
+declare class CommandClient extends EventEmitter {
+    discord: Client;
+    logger: Logger;
+    ctsLogger: Logger;
+    registry: Registry;
+    owners: Set<Snowflake>;
+    constructor(discord: Client, logger?: Logger);
+    fetchOwners(): Promise<void>;
+    enableApplicationCommandsExtension(config: ApplicationCommandExtensionConfig): Promise<void>;
+    getApplicationCommandsExtension(): ApplicationCommandExtension | undefined;
+    static getFromModule(ext: object): CommandClient;
 }
 
-declare class CommandNotFound extends Error {
-    commandName: string;
-    msg: Message;
-    args: string[];
-    constructor(commandName: string, msg: Message, args: string[]);
+declare class Registry {
+    client: CommandClient;
+    extensions: object[];
+    emitters: Collection<string, EventEmitter>;
+    logger: Logger;
+    constructor(logger: Logger, client: CommandClient);
+    getComponentsWithTypeGlobal<T extends typeof BaseComponent<Config>, Config>(type: T): InstanceType<T>[];
+    getComponentsWithType<T extends typeof BaseComponent<Config>, Config>(ext: object, type: T): InstanceType<T>[];
+    registerEventListeners(ext: object): void;
+    unregisterEventListeners(ext: object): void;
+    registerModule(ext: object): Promise<void>;
+    unregisterModule(ext: object): Promise<void>;
+    runModuleHook(ext: object, hookName: string, ...args: unknown[]): void;
+    registerEventEmitter(name: string, emitter: EventEmitter): void;
 }
 
-declare class BuiltInModule extends Module {
-    constructor();
+declare class ApplicationCommandComponent extends BaseComponent<(UserApplicationCommandData | MessageApplicationCommandData | Omit<ChatInputApplicationCommandData, 'options'>) & {
+    type: ApplicationCommandType;
+}> {
 }
+declare const applicationCommand: (options: (UserApplicationCommandData | MessageApplicationCommandData | Omit<ChatInputApplicationCommandData, "options">) & {
+    type: ApplicationCommandType;
+}) => MethodDecorator;
 
-declare class ButtonInteractionHandler extends MessageComponentHandler {
-    constructor(id: string, execute: MessageComponentExecutor);
-}
-declare const messageButton: (id: string) => MethodDecorator;
+declare const option: (options: APIApplicationCommandOption) => ParameterDecorator;
 
-declare class SelectMenuInteractionHandler extends MessageComponentHandler {
-    constructor(id: string, execute: MessageComponentExecutor);
+declare type TextCommandOptions = {
+    name: string;
+    description?: string;
+};
+declare class TextCommandComponent extends BaseComponent<TextCommandOptions> {
 }
-declare const messageSelectMenu: (id: string) => MethodDecorator;
+declare const command: (options: TextCommandOptions) => MethodDecorator;
 
-export { AppCommand, AppCommandArgument, ApplicationCommandArgumentConverter, ApplicationCommandArgumentConverterNotFound, ApplicationCommandCheckFailed, ApplicationCommandCheckFunction, ApplicationCommandOptions, Argument, ArgumentConverter, ArgumentConverterNotFound, ArgumentNotProvided, BuiltInModule, ButtonInteractionHandler, CheckFunction, ClientPermissionRequired, Command, CommandCheckFailed, CommandClient, CommandClientOptions, CommandClientOptionsParam, CommandNotFound, CommandOptions$1 as CommandOptions, CoolDownAdapter, CoolDownError, CoolDownType, DMOnlyCommandError, DefaultCoolDownAdapter, GuildOnlyCommandError, InvalidModuleError, InvalidTargetError, Listener, Module, ModuleLoadError, OwnerOnlyCommandError, Registry, SelectMenuInteractionHandler, SlashCommandGlobalCheckError, SlashCommandOptions, UserPermissionRequired, applicationCommand, applicationCommandArgumentConverter, argumentConverter, command, coolDown, createCheckDecorator, dmOnly, guildOnly, listener, messageButton, messageSelectMenu, option, optional, ownerOnly, requireClientPermissions, requireUserPermissions, rest };
+export { ApplicationCommandComponent, BaseComponent, CommandClient, ComponentArgument, ComponentArgumentDecorator, ComponentHookStore, ConverterComponent, Extension, ListenerComponent, OwnerOnlyError, Registry, TextCommandComponent, applicationCommand, argConverter, command, createArgumentDecorator, createCheckDecorator, createComponentDecorator, createComponentHook, getComponent, getComponentArgumentStore, getComponentStore, getModuleHookStore, listener, moduleHook, option, ownerOnly };