@pikokr/command.ts 3.0.0-dev.a94f324 → 3.0.0-dev.ca01eb5

package/.prettierrc

@@ -3,5 +3,6 @@
   "trailingComma": "all",
   "bracketSpacing": true,
   "endOfLine": "lf",
-  "singleQuote": true
+  "singleQuote": true,
+  "printWidth": 180
 }

package/README.md

@@ -2,6 +2,6 @@
 
 Command framework for discord.js
 
-# 진행상황 / Progress
+[Discord](https://discord.gg/EEhcPzsGHV) [가이드](https://pikokr.notion.site/a60262db37724fd38e4b7fc83be7e52d)
 
-https://pikokr.notion.site/b11137d4e879413a849fdf453c74bf39?v=f12235b64e4d438182b32e436f6b3bb9
+[V2 문서](https://command-ts-docs-ezojnktwv-pikokr.vercel.app/)

package/dist/builtinModules/BuiltinCommandConverters.d.ts

@@ -1,6 +1,14 @@
 import { BuiltInModule } from './BuiltInModule';
-import { Message } from 'discord.js';
+import { Client, GuildMember, Message, User } from 'discord.js';
+import { CommandClient } from '../structures';
 export declare class BuiltinCommandConverters extends BuiltInModule {
+    private cts;
+    client: Client;
+    constructor(cts: CommandClient);
     message(msg: Message): Message;
     string(msg: Message, arg: string): string;
+    getUserIDByMention(mention: string): `${bigint}` | undefined;
+    user(value: string): User | null;
+    member(value: string, msg: Message): GuildMember | undefined;
+    number(value: string): number | undefined;
 }

package/dist/builtinModules/BuiltinCommandConverters.js

@@ -14,12 +14,47 @@ const BuiltInModule_1 = require("./BuiltInModule");
 const command_1 = require("../command");
 const discord_js_1 = require("discord.js");
 class BuiltinCommandConverters extends BuiltInModule_1.BuiltInModule {
+    constructor(cts) {
+        super();
+        this.cts = cts;
+        this.client = cts.client;
+    }
     message(msg) {
         return msg;
     }
     string(msg, arg) {
         return arg;
     }
+    getUserIDByMention(mention) {
+        if (!mention)
+            return;
+        if (mention.startsWith('<@') && mention.endsWith('>')) {
+            mention = mention.slice(2, -1);
+            if (mention.startsWith('!')) {
+                mention = mention.slice(1);
+            }
+            return mention;
+        }
+    }
+    user(value) {
+        const id = this.getUserIDByMention(value);
+        if (!id)
+            return null;
+        const user = this.client.users.cache.get(id);
+        return user || null;
+    }
+    member(value, msg) {
+        var _a;
+        const id = this.getUserIDByMention(value);
+        if (!id)
+            return;
+        const user = (_a = msg.guild) === null || _a === void 0 ? void 0 : _a.members.cache.get(id);
+        return user || undefined;
+    }
+    number(value) {
+        const n = Number(value);
+        return isNaN(n) ? undefined : n;
+    }
 }
 __decorate([
     command_1.argumentConverter(discord_js_1.Message, false),
@@ -33,4 +68,22 @@ __decorate([
     __metadata("design:paramtypes", [discord_js_1.Message, String]),
     __metadata("design:returntype", void 0)
 ], BuiltinCommandConverters.prototype, "string", null);
+__decorate([
+    command_1.argumentConverter(discord_js_1.User),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], BuiltinCommandConverters.prototype, "user", null);
+__decorate([
+    command_1.argumentConverter(discord_js_1.GuildMember),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, discord_js_1.Message]),
+    __metadata("design:returntype", Object)
+], BuiltinCommandConverters.prototype, "member", null);
+__decorate([
+    command_1.argumentConverter(Number),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], BuiltinCommandConverters.prototype, "number", null);
 exports.BuiltinCommandConverters = BuiltinCommandConverters;

package/dist/builtinModules/BuiltinSlashCommandConverters.d.ts

@@ -0,0 +1,9 @@
+import { BuiltInModule } from './BuiltInModule';
+import { Client, CommandInteraction } from 'discord.js';
+import { CommandClient } from '../structures';
+export declare class BuiltinSlashCommandConverters extends BuiltInModule {
+    private cts;
+    client: Client;
+    constructor(cts: CommandClient);
+    message(interaction: CommandInteraction): CommandInteraction;
+}

package/dist/builtinModules/BuiltinSlashCommandConverters.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltinSlashCommandConverters = void 0;
+const BuiltInModule_1 = require("./BuiltInModule");
+const command_1 = require("../command");
+const discord_js_1 = require("discord.js");
+class BuiltinSlashCommandConverters extends BuiltInModule_1.BuiltInModule {
+    constructor(cts) {
+        super();
+        this.cts = cts;
+        this.client = cts.client;
+    }
+    message(interaction) {
+        return interaction;
+    }
+}
+__decorate([
+    command_1.slashArgumentConverter(discord_js_1.CommandInteraction),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.CommandInteraction]),
+    __metadata("design:returntype", void 0)
+], BuiltinSlashCommandConverters.prototype, "message", null);
+exports.BuiltinSlashCommandConverters = BuiltinSlashCommandConverters;

package/dist/builtinModules/CommandHandler.d.ts

@@ -1,9 +1,11 @@
 import { BuiltInModule } from './BuiltInModule';
 import { Registry } from '../structures';
-import { Message } from 'discord.js';
+import { Interaction, Message } from 'discord.js';
 export declare class CommandHandler extends BuiltInModule {
     private registry;
-    private client;
+    private readonly client;
     constructor(registry: Registry);
     message(msg: Message): Promise<boolean | undefined>;
+    private command;
+    interaction(i: Interaction): Promise<void>;
 }

package/dist/builtinModules/CommandHandler.js

@@ -33,74 +33,167 @@ class CommandHandler extends BuiltInModule_1.BuiltInModule {
     message(msg) {
         return __awaiter(this, void 0, void 0, function* () {
             const error = (error) => this.client.client.emit('commandError', error, msg);
-            const prefixList = typeof this.client.options.command.prefix === 'string'
-                ? this.client.options.command.prefix
-                : typeof this.client.options.command.prefix === 'function'
-                    ? yield this.client.options.command.prefix(msg)
-                    : this.client.options.command.prefix;
-            let prefix;
-            if (typeof prefixList === 'object') {
-                const res = prefixList.find((x) => msg.content.includes(x));
-                if (!res)
+            try {
+                const prefixList = typeof this.client.options.command.prefix === 'string'
+                    ? this.client.options.command.prefix
+                    : typeof this.client.options.command.prefix === 'function'
+                        ? yield this.client.options.command.prefix(msg)
+                        : this.client.options.command.prefix;
+                let prefix;
+                if (typeof prefixList === 'object') {
+                    const res = prefixList.find((x) => msg.content.includes(x));
+                    if (!res)
+                        return;
+                    prefix = res;
+                }
+                else {
+                    if (!msg.content.includes(prefixList))
+                        return;
+                    prefix = prefixList;
+                }
+                if (!msg.content.startsWith(prefix))
                     return;
-                prefix = res;
-            }
-            else {
-                if (!msg.content.includes(prefixList))
+                const args = msg.content.slice(prefix.length).split(' ');
+                const command = args.shift();
+                if (!command)
                     return;
-                prefix = prefixList;
-            }
-            if (!msg.content.startsWith(prefix))
-                return;
-            const args = msg.content.slice(prefix.length).split(' ');
-            const command = args.shift();
-            if (!command)
-                return;
-            let cmd = null;
-            for (const c of this.registry.commands) {
-                if (c.name === command) {
-                    cmd = c;
-                    break;
+                let cmd = null;
+                for (const c of this.registry.commands) {
+                    if (c.name === command) {
+                        cmd = c;
+                        break;
+                    }
+                    if ((typeof c.aliases === 'function' ? yield c.aliases(msg) : c.aliases).includes(command)) {
+                        cmd = c;
+                        break;
+                    }
                 }
-                if ((typeof c.aliases === 'function'
-                    ? yield c.aliases(msg)
-                    : c.aliases).includes(command)) {
-                    cmd = c;
-                    break;
+                if (!cmd)
+                    return error(new CommandNotFound_1.CommandNotFound(command));
+                msg.data = {
+                    cts: this.client,
+                    command: cmd,
+                    prefix: prefix,
+                };
+                const module = this.registry.modules.find((x) => x.commands.includes(cmd));
+                if (!module)
+                    return;
+                const argList = [];
+                for (const check of cmd.checks) {
+                    if (!(yield check(msg)))
+                        return error(new error_1.CommandCheckFailed(msg, cmd));
                 }
-            }
-            if (!cmd)
-                return error(new CommandNotFound_1.CommandNotFound(command));
-            const module = this.registry.modules.find((x) => x.commands.includes(cmd));
-            if (!module)
-                return;
-            const argList = [];
-            for (let i = 0; i < cmd.argTypes.length; i++) {
-                const argType = cmd.argTypes[i];
-                const converter = this.registry.argumentConverters.find((x) => x.type === argType.type);
-                if (!converter)
-                    return error(new error_1.ArgumentConverterNotFound(argType, msg));
-                if (converter.withoutParameter) {
-                    argList.push(yield converter.execute(module, msg));
-                    continue;
+                for (let i = 0; i < cmd.argTypes.length; i++) {
+                    const argType = cmd.argTypes[i];
+                    const converter = this.registry.argumentConverters.find((x) => x.type === argType.type);
+                    if (argType.rest) {
+                        const i = args.join(' ');
+                        if (!i)
+                            break;
+                        argList.push(i);
+                        break;
+                    }
+                    if (!converter)
+                        return error(new error_1.ArgumentConverterNotFound(argType, msg));
+                    if (converter.withoutParameter) {
+                        argList.push(yield converter.execute(module, msg));
+                        continue;
+                    }
+                    const arg = args.shift();
+                    if (argType.optional && !arg) {
+                        break;
+                    }
+                    if (!arg) {
+                        return error(new error_1.ArgumentNotProvided(i, cmd, msg));
+                    }
+                    const executed = yield converter.execute(module, msg, arg);
+                    if (!executed === undefined) {
+                        return error(new error_1.ArgumentNotProvided(i, cmd, msg));
+                    }
+                    argList.push(executed);
                 }
-                const arg = args.shift();
-                if (argType.optional && !arg) {
-                    break;
+                try {
+                    yield cmd.execute(module, argList);
                 }
-                if (!arg) {
-                    return error(new error_1.ArgumentNotProvided(i, msg));
+                catch (e) {
+                    return error(e);
                 }
-                argList.push(yield converter.execute(module, msg, arg));
             }
+            catch (e) {
+                return error(e);
+            }
+        });
+    }
+    command(i) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const error = (error) => this.client.client.emit('slashCommandError', error, i);
             try {
-                cmd.execute(module, argList);
+                const cmd = this.registry.slashCommands.find((x) => x.commandBuilder.name === i.commandName);
+                const module = this.registry.modules.find((x) => x.slashCommands.includes(cmd));
+                if (!module)
+                    return;
+                const argList = [];
+                if (!cmd)
+                    return i.reply({
+                        content: 'Unknown command.',
+                        ephemeral: true,
+                    });
+                i.data = {
+                    cts: this.client,
+                    command: cmd,
+                };
+                for (const check of cmd.checks) {
+                    if (!(yield check(i)))
+                        return error(new error_1.SlashCommandCheckFailed(i, cmd));
+                }
+                for (let j = 0; j < cmd.params.length; j++) {
+                    const argType = cmd.params[j];
+                    const converter = this.registry.slashArgumentConverters.find((x) => x.type === argType.type);
+                    if (argType.name) {
+                        switch (argType.type) {
+                            case String:
+                                argList.push(i.options.getString(argType.name, false) || undefined);
+                                break;
+                            case discord_js_1.Role:
+                                argList.push(i.options.getRole(argType.name, false) || undefined);
+                                break;
+                            case discord_js_1.User:
+                                argList.push(i.options.getUser(argType.name, false) || undefined);
+                                break;
+                            case discord_js_1.GuildMember:
+                                argList.push(i.options.getMember(argType.name, false) || undefined);
+                                break;
+                            case Boolean:
+                                argList.push(i.options.getBoolean(argType.name, false) || undefined);
+                                break;
+                            case Number:
+                                argList.push(i.options.getNumber(argType.name, false) || i.options.getInteger(argType.name, false) || undefined);
+                        }
+                        continue;
+                    }
+                    if (!converter)
+                        return error(new error_1.SlashArgumentConverterNotFound(argType, i));
+                    argList.push(yield converter.execute(module, i));
+                }
+                try {
+                    yield cmd.execute(module, argList);
+                }
+                catch (e) {
+                    return error(e);
+                }
             }
             catch (e) {
                 return error(e);
             }
         });
     }
+    interaction(i) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (i.isCommand()) {
+                yield this.command(i);
+            }
+        });
+    }
 }
 __decorate([
     listener_1.listener('messageCreate'),
@@ -108,4 +201,10 @@ __decorate([
     __metadata("design:paramtypes", [discord_js_1.Message]),
     __metadata("design:returntype", Promise)
 ], CommandHandler.prototype, "message", null);
+__decorate([
+    listener_1.listener('interactionCreate'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [discord_js_1.Interaction]),
+    __metadata("design:returntype", Promise)
+], CommandHandler.prototype, "interaction", null);
 exports.CommandHandler = CommandHandler;

package/dist/builtinModules/index.d.ts

@@ -1,2 +1,3 @@
 export * from './CommandHandler';
 export * from './BuiltinCommandConverters';
+export * from './BuiltinSlashCommandConverters';

package/dist/builtinModules/index.js

@@ -12,3 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CommandHandler"), exports);
 __exportStar(require("./BuiltinCommandConverters"), exports);
+__exportStar(require("./BuiltinSlashCommandConverters"), exports);

package/dist/command/ArgumentConverter.d.ts

@@ -1,5 +1,5 @@
 import { Module } from '../structures';
-import { Message } from 'discord.js';
+import { CommandInteraction, Message } from 'discord.js';
 export declare class ArgumentConverter {
     type: object;
     private run;
@@ -7,3 +7,9 @@ export declare class ArgumentConverter {
     execute(module: Module, msg: Message, arg?: string): any;
     constructor(type: object, run: Function, withoutParameter: boolean);
 }
+export declare class SlashArgumentConverter {
+    type: object;
+    private run;
+    execute(module: Module, interaction: CommandInteraction): any;
+    constructor(type: object, run: Function);
+}

package/dist/command/ArgumentConverter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentConverter = void 0;
+exports.SlashArgumentConverter = exports.ArgumentConverter = void 0;
 class ArgumentConverter {
     constructor(type, run, withoutParameter) {
         this.type = type;
@@ -12,3 +12,13 @@ class ArgumentConverter {
     }
 }
 exports.ArgumentConverter = ArgumentConverter;
+class SlashArgumentConverter {
+    constructor(type, run) {
+        this.type = type;
+        this.run = run;
+    }
+    execute(module, interaction) {
+        return this.run.apply(module, [interaction]);
+    }
+}
+exports.SlashArgumentConverter = SlashArgumentConverter;

package/dist/command/Command.d.ts

@@ -1,14 +1,20 @@
 import { Module } from '../structures';
-import { Message } from 'discord.js';
+import { CommandInteraction, Message } from 'discord.js';
 export declare type Argument = {
     optional: boolean;
     type: any;
+    rest: boolean;
 };
+export declare type CheckFunction = (msg: Message) => boolean | Promise<boolean>;
+export declare type SlashCheckFunction = (i: CommandInteraction) => boolean | Promise<boolean>;
 export declare class Command {
     private run;
     argTypes: Argument[];
     name: string;
     aliases: string[] | ((msg: Message) => string[]);
+    module: Module;
+    key: symbol | string;
     execute(module: Module, args: any[]): any;
-    constructor(run: Function, argTypes: Argument[], name: string, aliases: string[] | ((msg: Message) => string[]));
+    get checks(): CheckFunction[];
+    constructor(run: Function, argTypes: Argument[], name: string, aliases: string[] | ((msg: Message) => string[]), module: Module, key: symbol | string);
 }

package/dist/command/Command.js

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
+const constants_1 = require("../constants");
 class Command {
-    constructor(run, argTypes, name, aliases) {
+    constructor(run, argTypes, name, aliases, module, key) {
         this.run = run;
         this.argTypes = argTypes;
         this.name = name;
         this.aliases = aliases;
+        this.module = module;
+        this.key = key;
     }
     execute(module, args) {
         return this.run.apply(module, args);
     }
+    get checks() {
+        return Reflect.getMetadata(constants_1.KCommandChecks, this.module, this.key) || [];
+    }
 }
 exports.Command = Command;

package/dist/command/cooldown/adapter.d.ts

@@ -0,0 +1,10 @@
+import { Collection } from 'discord.js';
+export interface CoolDownAdapter {
+    get(id: string): Promise<number | undefined>;
+    set(id: string, value: number): Promise<void>;
+}
+export declare class DefaultCoolDownAdapter implements CoolDownAdapter {
+    map: Collection<string, number>;
+    get(id: string): Promise<number | undefined>;
+    set(id: string, value: number): Promise<void>;
+}

package/dist/command/cooldown/adapter.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCoolDownAdapter = void 0;
+const discord_js_1 = require("discord.js");
+class DefaultCoolDownAdapter {
+    constructor() {
+        this.map = new discord_js_1.Collection();
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.map.get(id);
+        });
+    }
+    set(id, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.map.set(id, value);
+            return;
+        });
+    }
+}
+exports.DefaultCoolDownAdapter = DefaultCoolDownAdapter;

package/dist/command/cooldown/decorator.d.ts

@@ -0,0 +1,2 @@
+import { CoolDownType } from './type';
+export declare const coolDown: (type: CoolDownType, seconds: number) => MethodDecorator;

package/dist/command/cooldown/decorator.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coolDown = void 0;
+const utils_1 = require("../utils");
+const type_1 = require("./type");
+const discord_js_1 = require("discord.js");
+const error_1 = require("./error");
+const coolDown = (type, seconds) => utils_1.createCheckDecorator((msg) => __awaiter(void 0, void 0, void 0, function* () {
+    const a = msg.data.cts.coolDownAdapter;
+    const getKey = () => {
+        var _a;
+        switch (type) {
+            case type_1.CoolDownType.USER:
+                return msg.author.id;
+            case type_1.CoolDownType.GUILD:
+                return (msg.guild || msg.author).id;
+            case type_1.CoolDownType.CHANNEL:
+                return msg.channel.id;
+            case type_1.CoolDownType.MEMBER:
+                return `${(_a = msg.guild) === null || _a === void 0 ? void 0 : _a.id}.${msg.author.id}`;
+            case type_1.CoolDownType.ROLE:
+                return (msg.channel instanceof discord_js_1.DMChannel ? msg.channel : msg.member.roles.highest).id;
+            case type_1.CoolDownType.CATEGORY:
+                return (msg.channel.parent || msg.channel).id;
+        }
+    };
+    const key = getKey();
+    const data = yield a.get(key);
+    const now = Date.now();
+    if (!data || !(now - data < seconds * 1000)) {
+        yield a.set(key, now);
+        return true;
+    }
+    throw new error_1.CoolDownError(new Date(data + seconds * 1000));
+}), (i) => __awaiter(void 0, void 0, void 0, function* () {
+    const a = i.data.cts.coolDownAdapter;
+    const getKey = () => {
+        var _a;
+        switch (type) {
+            case type_1.CoolDownType.USER:
+                return i.user.id;
+            case type_1.CoolDownType.GUILD:
+                return (i.guild || i.user).id;
+            case type_1.CoolDownType.CHANNEL:
+                return i.channel.id;
+            case type_1.CoolDownType.MEMBER:
+                return `${(_a = i.guild) === null || _a === void 0 ? void 0 : _a.id}.${i.user.id}`;
+            case type_1.CoolDownType.ROLE:
+                return (i.channel instanceof discord_js_1.DMChannel ? i.channel : i.member.roles.highest).id;
+            case type_1.CoolDownType.CATEGORY:
+                return (i.channel.parent || i.channel).id;
+        }
+    };
+    const key = getKey();
+    const data = yield a.get(key);
+    const now = Date.now();
+    if (!data || !(now - data < seconds * 1000)) {
+        yield a.set(key, now);
+        return true;
+    }
+    throw new error_1.CoolDownError(new Date(data + seconds * 1000));
+}));
+exports.coolDown = coolDown;

package/dist/command/cooldown/error.d.ts

@@ -0,0 +1,4 @@
+export declare class CoolDownError extends Error {
+    endsAt: Date;
+    constructor(endsAt: Date);
+}

package/dist/command/cooldown/error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoolDownError = void 0;
+class CoolDownError extends Error {
+    constructor(endsAt) {
+        super();
+        this.endsAt = endsAt;
+    }
+}
+exports.CoolDownError = CoolDownError;

package/dist/command/cooldown/index.d.ts

@@ -0,0 +1,5 @@
+export * from './decorator';
+export * from './adapter';
+export * from './decorator';
+export * from './error';
+export * from './type';

package/dist/command/cooldown/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./type"), exports);