xernerx 3.3.6 → 3.4.0

package/dist/utils/CommandUtil.js

@@ -1,4 +1,4 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, StringSelectMenuBuilder } from 'discord.js';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, StringSelectMenuBuilder, } from 'discord.js';
 import XernerxError from '../tools/XernerxError.js';
 export class MessageCommandUtil {
     client;
@@ -77,14 +77,14 @@ export class MessageCommandUtil {
     getCommands() {
         return this.client.commands.message;
     }
-    #getCommandName() { }
-    #selectMenuPaginator(embeds, options) { }
-    #buttonPaginator(embeds, options) { }
-    #buttonMenuPaginator(embeds, options) { }
+    getCommandName() { }
+    selectMenuPaginator(embeds, options) { }
+    buttonPaginator(embeds, options) { }
+    buttonMenuPaginator(embeds, options) { }
     isOwner() {
         return this.client.util.isOwner(this.message.author.id);
     }
-    #createModal() { }
+    createModal() { }
 }
 export class InteractionCommandUtil {
     client;
@@ -94,7 +94,9 @@ export class InteractionCommandUtil {
         this.interaction = interaction;
     }
     reply(content) {
-        return this.interaction.replied || this.interaction.deferred ? this.interaction.editReply(content) : this.interaction.reply(content);
+        return this.interaction.replied || this.interaction.deferred
+            ? this.interaction.editReply(content)
+            : this.interaction.reply(content);
     }
     async defer(time) {
         return new Promise((resolve) => setTimeout(resolve, time));
@@ -105,7 +107,7 @@ export class InteractionCommandUtil {
         else
             return this.client.commands.context;
     }
-    #getCommandName() { }
+    getCommandName() { }
     selectMenuPaginator(embeds, options) {
         if (!Array.isArray(embeds))
             throw new XernerxError(`Expected embeds to be of type array, received ${typeof embeds} instead.`);
@@ -131,7 +133,12 @@ export class InteractionCommandUtil {
             options.row = new ActionRowBuilder();
             if (!options.id)
                 options.id = `${this.interaction.id}-menu`;
-            options.component = new StringSelectMenuBuilder().setCustomId(options.id).setMaxValues(1).setMinValues(1).setPlaceholder('Select a page.').addOptions({ label: 'index', value: '0' });
+            options.component = new StringSelectMenuBuilder()
+                .setCustomId(options.id)
+                .setMaxValues(1)
+                .setMinValues(1)
+                .setPlaceholder('Select a page.')
+                .addOptions({ label: 'index', value: '0' });
             embeds.map((embed, i = 0) => {
                 options?.component?.addOptions({
                     label: embed.data.title || 'No Name',
@@ -147,7 +154,9 @@ export class InteractionCommandUtil {
             components: [options.row, ...options.components],
             ephemeral: !!options.ephemeral,
         };
-        (options.reply === undefined || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then(() => {
+        (options.reply === undefined || options.reply === true
+            ? this.interaction.util.reply(content)
+            : this.interaction.channel.send(content)).then(() => {
             const collector = this.interaction.channel
                 .createMessageComponentCollector({
                 filter: options?.filter,
@@ -193,7 +202,9 @@ export class InteractionCommandUtil {
             components: [options.row, ...options.components],
             ephemeral: !!options.ephemeral,
         };
-        (options.reply === undefined || options.reply === true ? this.interaction.util.reply(content) : this.interaction.channel.send(content)).then((message) => {
+        (options.reply === undefined || options.reply === true
+            ? this.interaction.util.reply(content)
+            : this.interaction.channel.send(content)).then((message) => {
             const collector = message.channel
                 .createMessageComponentCollector({
                 filter: options.filter,
@@ -217,7 +228,8 @@ export class InteractionCommandUtil {
                             break;
                         }
                         case 3: {
-                            embed = embeds[embeds.indexOf(embed) < embeds.length - 1 ? embeds.indexOf(embed) + 1 : embeds.length - 1];
+                            embed =
+                                embeds[embeds.indexOf(embed) < embeds.length - 1 ? embeds.indexOf(embed) + 1 : embeds.length - 1];
                             break;
                         }
                         case 4: {
@@ -240,9 +252,9 @@ export class InteractionCommandUtil {
             });
         });
     }
-    #buttonMenuPaginator(embeds, options) { }
+    buttonMenuPaginator(embeds, options) { }
     isOwner() {
         return this.client.util.isOwner(this.interaction.user.id);
     }
-    #createModal() { }
+    createModal() { }
 }

package/dist/validators/CommandValidations.d.ts

@@ -0,0 +1,7 @@
+import { Interaction } from 'discord.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/types.js';
+export default function commandValidation(action: XernerxMessage | Interaction, command: SlashCommandBuilder | MessageCommandBuilder | ContextCommandBuilder | any, client: XernerxClient, res?: boolean): boolean;

package/dist/validators/CommandValidations.js

@@ -0,0 +1,185 @@
+import { Message } from 'discord.js';
+import { CommandType } from '../types/enums.js';
+function getUser(from) {
+    if (from instanceof Message)
+        return from.author;
+    else
+        return from.user;
+}
+export default function commandValidation(action, command, client, res = false) {
+    let user = getUser(action);
+    if ((command.ignoreOwner || client.settings.ignoreOwner) && client.util.isOwner(user.id))
+        return res;
+    else if (inCooldown(user, client, command, action))
+        return true;
+    else if (command.owner && !client.util.isOwner(user.id)) {
+        res = true;
+        emit(client, action, command, 'Not an owner', client.settings.ownerId);
+    }
+    else if (command.channelType?.length > 0 || command.channelType) {
+        if (!Array.isArray(command.channelType))
+            command.channelType = [command.channelType];
+        if (!command?.channelType?.includes(action.channel?.type)) {
+            res = true;
+            emit(client, action, command, 'Not the correct channel', command.channelType);
+        }
+    }
+    else if (command.channels?.length > 0 && !command.channels.includes(action.channel?.id)) {
+        res = true;
+        emit(client, action, command, 'Not a whitelisted channel', command.channels);
+    }
+    else if (command.guilds?.length > 0 && !command.guilds.includes(action.guild?.id)) {
+        res = true;
+        emit(client, action, command, 'Not a whitelisted guild', command.guilds);
+    }
+    else if (command.channelType && command.channelType !== action.channel?.type) {
+        res = true;
+        emit(client, action, command, 'Not the correct type of channel', command.channelType);
+    }
+    else if (action?.guild && (command.userPermissions || client.settings.userPermissions)) {
+        const permissions = command.userPermissions ||
+            client?.settings?.userPermissions?.push(...handlerPermissions(client, command.commandType, 'user')), missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, command, 'Missing User Permissions', missing);
+        }
+    }
+    else if (action?.guild && (command.clientPermissions || client.settings.clientPermissions)) {
+        const permissions = command.clientPermissions ||
+            client?.settings?.clientPermissions?.push(...handlerPermissions(client, command.commandType, 'client')), missing = [];
+        if (Array.isArray(permissions))
+            permissions.map((permission) => {
+                if (!(action.member?.permissions).has(permission)) {
+                    missing.push(permission);
+                }
+            });
+        if (missing.length > 0) {
+            res = true;
+            emit(client, action, command, 'Missing Client Permissions', missing);
+        }
+    }
+    return res;
+}
+function emit(client, action, command, reason, extra) {
+    return client.emit('commandBlock', action, command, reason, extra);
+}
+function inCooldown(user, client, command, action) {
+    let res = false, downs = {};
+    const { cooldowns, messageCommands, slashCommands, contextCommands, commands } = client.cache;
+    if (command.commandType === CommandType.MessageCommand && client.handlerOptions.message.cooldown) {
+        if (messageCommands.has(user.id)) {
+            const usr = messageCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.message = usr;
+            res = true;
+        }
+        if (!messageCommands.has(user.id)) {
+            messageCommands.set(user.id, toCooldown(action, command, client.handlerOptions.message.cooldown, user.id));
+            setInterval(() => {
+                messageCommands.delete(user.id);
+            }, client.handlerOptions.message.cooldown);
+        }
+    }
+    if (command.commandType === CommandType.SlashCommand && client.handlerOptions.slash.cooldown) {
+        if (slashCommands.has(user.id)) {
+            const usr = slashCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.slash = usr;
+            res = true;
+        }
+        if (!slashCommands.has(user.id)) {
+            slashCommands.set(user.id, toCooldown(action, command, client.handlerOptions.slash.cooldown, user.id));
+            setInterval(() => {
+                slashCommands.delete(user.id);
+            }, client.handlerOptions.slash.cooldown);
+        }
+    }
+    if (command.commandType === CommandType.ContextCommand && client.handlerOptions.context.cooldown) {
+        if (contextCommands.has(user.id)) {
+            const usr = contextCommands.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.context = usr;
+            res = true;
+        }
+        if (!contextCommands.has(user.id)) {
+            contextCommands.set(user.id, toCooldown(action, command, client.handlerOptions.context.cooldown, user.id));
+            setInterval(() => {
+                contextCommands.delete(user.id);
+            }, client.handlerOptions.context.cooldown);
+        }
+    }
+    if (client.settings?.cooldown?.default) {
+        if (cooldowns.has(user.id)) {
+            const usr = cooldowns.get(user.id);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.default = usr;
+            res = true;
+        }
+        if (!cooldowns.has(user.id)) {
+            cooldowns.set(user.id, toCooldown(action, command, client.settings.cooldown.default, user.id));
+            setInterval(() => {
+                cooldowns.delete(user.id);
+            }, client.settings.cooldown.default);
+        }
+    }
+    if (command.cooldown) {
+        const name = user.id + '-' + (command.data?.name || command?.name) + '-' + command.commandType;
+        if (commands.has(name)) {
+            const usr = commands.get(name);
+            usr.timeRemaining = usr.endsAt - Date.now();
+            downs.command = usr;
+            res = true;
+        }
+        if (!commands.has(name)) {
+            commands.set(name, toCooldown(action, command, command.cooldown, name));
+            setInterval(() => {
+                commands.delete(name);
+            }, command.cooldown);
+        }
+    }
+    if (Object.keys(downs).length > 0)
+        client.emit('commandCooldown', action, command, downs);
+    return res;
+}
+function toCooldown(action, command, cooldown, name) {
+    let user = getUser(action);
+    return {
+        name,
+        id: user.id,
+        tag: user.tag,
+        commandType: command.commandType,
+        commandName: command?.data?.name || command?.name,
+        guildId: action?.guild?.id,
+        channelId: action?.channel?.id,
+        startsAt: Number(Date.now()),
+        endsAt: Number(Date.now()) + cooldown,
+    };
+}
+function handlerPermissions(client, commandType, type) {
+    let permissions = [];
+    if (commandType === CommandType.MessageCommand) {
+        if (type === 'user')
+            permissions = client.handlerOptions.message?.userPermissions || [];
+        else if (type === 'client')
+            permissions = client.handlerOptions.message?.clientPermissions || [];
+    }
+    else if (commandType === CommandType.SlashCommand) {
+        if (type === 'user')
+            permissions = client.handlerOptions.slash?.userPermissions || [];
+        else if (type === 'client')
+            permissions = client.handlerOptions.slash?.clientPermissions || [];
+    }
+    else if (commandType === CommandType.ContextCommand) {
+        if (type === 'user')
+            permissions = client.handlerOptions.context?.userPermissions || [];
+        else if (type === 'client')
+            permissions = client.handlerOptions.context?.clientPermissions || [];
+    }
+    return permissions;
+}

package/dist/validators/InhibitorValidations.d.ts

@@ -0,0 +1,11 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+export declare class InhibitorValidation {
+    private client;
+    private action;
+    private command;
+    private inhibited;
+    constructor(client: XernerxClient, action: XernerxMessage | XernerxInteraction, command: string);
+    inhibit(): Promise<Record<string, string | void> | undefined>;
+    private args;
+}

package/dist/validators/InhibitorValidations.js

@@ -0,0 +1,42 @@
+import { InhibitorType } from '../types/enums.js';
+export class InhibitorValidation {
+    client;
+    action;
+    command;
+    inhibited;
+    constructor(client, action, command) {
+        this.client = client;
+        this.action = action;
+        this.command = command;
+        this.inhibited = {};
+    }
+    async inhibit() {
+        for (const inhibitor of this.client.inhibitors) {
+            const inhibit = inhibitor[1];
+            if (inhibit)
+                this.inhibited[inhibit.name] = await inhibit.check(this.action, this.args(this.action, inhibit.type));
+        }
+        for (const inhibit of Object.values(this.inhibited)) {
+            if (inhibit)
+                return this.inhibited;
+        }
+    }
+    args(action, type) {
+        if (type === InhibitorType.Channel)
+            return action.channel;
+        if (type === InhibitorType.User)
+            return action.author || action.user;
+        if (type === InhibitorType.Guild)
+            return action.guild;
+        if (type === InhibitorType.Member)
+            return action.member;
+        // if (type === InhibitorType.Command)
+        // 	return this.client.util.getAllCommands().filter(this.command.name);
+        // if (type === InhibitorType.MessageCommand)
+        // 	return this.client.util.getAllMessageCommands().find(this.command.name);
+        // if (type === InhibitorType.SlashCommand)
+        // 	return this.client.util.getAllSlashCommands().find(this.command.name);
+        // if (type === InhibitorType.ContextCommand)
+        // 	return this.client.util.getAllContextCommands().find(this.command.name);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "3.3.6",
+	"version": "3.4.0",
 	"type": "module",
 	"description": "A bot framework for discord.js.",
 	"main": "dist/main.js",
@@ -11,22 +11,23 @@
 	],
 	"author": "Dummi",
 	"license": "MIT",
-	"homepage": "https://thedummi.github.io/xernerx/home.html",
+	"homepage": "https://xernerx.github.io/xernerx/home.html",
 	"packageManager": "npm@8.5.5",
 	"scripts": {
-		"checks": "npm i && npm fund && npm audit fix --force &&  npm link && tsc -w",
+		"start": "npm i && npm fund && npm audit fix --force &&  npm link && npm run package && tsc -w",
 		"patch": "git add . && npm run commit && npm version patch && npm publish && git push",
 		"minor": "git add . && npm run commit && npm version minor && npm publish && git push",
 		"major": "git add . && npm run commit && npm version major && npm publish && git push",
 		"site": "git add docs && npm run commit && git push",
-		"commit": "node scripts/commit.js"
+		"commit": "node ../.scripts/commit.js",
+		"package": "node ../.scripts/rewritePackage.js"
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/TheDummi/xernerx.git"
+		"url": "git+https://github.com/xernerx/xernerx.git"
 	},
 	"bugs": {
-		"url": "https://github.com/TheDummi/xernerx/issues"
+		"url": "https://github.com/xernerx/xernerx/issues"
 	},
 	"dependencies": {
 		"@sapphire/shapeshift": "^3.8.1",

package/dist/build/ExtensionBuilder.d.ts

@@ -1,7 +0,0 @@
-/**
- * A class constructor you can use to make any extension work.
- */
-export default class ExtensionBuilder {
-    name: string;
-    constructor(name: string);
-}

package/dist/build/ExtensionBuilder.js

@@ -1,9 +0,0 @@
-/**
- * A class constructor you can use to make any extension work.
- */
-export default class ExtensionBuilder {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}

package/dist/build/Inhibitor.d.ts

@@ -1,18 +0,0 @@
-import { InhibitorOptions } from "../interfaces/HandlerInterfaces.js";
-import { XernerxClient } from "../main.js";
-/**
- * @description - The inhibitor builder for inhibitors.
- * @param {String} id - The unique ID of the inhibitor.
- * @param {InhibitorOptions} options - The inhibitor options.
- */
-export declare class Inhibitor {
-    id: string;
-    name: string;
-    type: string;
-    client: XernerxClient | object;
-    constructor(id: string, options: InhibitorOptions);
-    /**
-     *
-     */
-    check(): Promise<void>;
-}

package/dist/build/XernerxExtension.d.ts

@@ -1,7 +0,0 @@
-/**
- * A class constructor you can use to make any extension work.
- */
-export default class XernerxExtension {
-    name: string;
-    constructor(name: string);
-}

package/dist/build/XernerxExtension.js

@@ -1,9 +0,0 @@
-/**
- * A class constructor you can use to make any extension work.
- */
-export default class XernerxExtension {
-    name;
-    constructor(name) {
-        this.name = name;
-    }
-}

package/dist/handlers/WebhookHandler.d.ts

@@ -1,12 +0,0 @@
-import { XernerxClient } from "../main.js";
-interface WebhookOptions {
-    token: string;
-    logging: boolean;
-}
-export default class WebhookHandler {
-    client: XernerxClient;
-    constructor(client: XernerxClient);
-    post(options: WebhookOptions): import("topgg-autoposter/dist/structs/BasePoster.js").BasePoster;
-    vote(options: WebhookOptions): void;
-}
-export {};

package/dist/handlers/WebhookHandler.js

@@ -1,36 +0,0 @@
-"use strict";
-import { AutoPoster } from 'topgg-autoposter';
-import SDK from '@top-gg/sdk';
-import { Style } from 'dumfunctions';
-import express from 'express';
-export default class WebhookHandler {
-    client;
-    constructor(client) {
-        this.client = client;
-        this.vote = this.vote;
-        this.post = this.post;
-    }
-    post(options) {
-        const auto = AutoPoster(options.token, this.client);
-        auto
-            .on('posted', post => {
-            if (options.logging)
-                console.info(Style.log(`Xernerx | Successfully posted bot stats to Top.gg!`, { color: Style.TextColor.Cyan }));
-            return this.client.emit('webhookPost', post);
-        })
-            .on('error', error => {
-            if (options.logging)
-                console.info(Style.log(`Xernerx | An error occurred while posting stats to Top.gg, ${error}.`, { color: Style.BackgroundColor.Red }));
-            return this.client.emit('webhookError', error);
-        });
-        return auto;
-    }
-    vote(options) {
-        const app = express();
-        const webhook = new SDK.Webhook(options.token);
-        app.post("/dblwebhook", webhook.listener(vote => {
-            console.log(vote);
-        }));
-        app.listen(80);
-    }
-}

package/dist/interfaces/ClientInterfaces.d.ts

@@ -1,65 +0,0 @@
-import { CacheFactory, Collection, MessageMentionOptions, Partials, PresenceData, RESTOptions, SweeperOptions, WebSocketOptions } from "discord.js";
-import CommandHandler from "../handlers/CommandHandler.js";
-import EventHandler from "../handlers/EventHandler.js";
-import InhibitorHandler from "../handlers/InhibitorHandler.js";
-import { ContextCommandOptions, MessageCommandOptions, SlashCommandOptions, EventLoadOptions, InhibitorLoadOptions } from "./HandlerInterfaces.js";
-import MessageCommandBuilder from "../build/MessageCommandBuilder.js";
-import ContextCommandBuilder from "../build/ContextCommandBuilder.js";
-import SlashCommandBuilder from "../build/SlashCommandBuilder.js";
-import ExtensionBuilder from "../build/ExtensionBuilder.js";
-export interface DiscordOptions {
-    shards?: number | number[] | "auto";
-    closeTimeout?: number;
-    shardCount?: number;
-    makeCache?: CacheFactory;
-    allowedMentions?: MessageMentionOptions;
-    partials?: Array<Partials>;
-    failIfNotExists?: boolean;
-    presence?: PresenceData;
-    intents: number[];
-    waitGuildTimeout?: number;
-    sweepers?: SweeperOptions;
-    ws?: WebSocketOptions;
-    rest?: RESTOptions;
-    jsonTransformer?: (obj: unknown) => unknown;
-}
-export interface ClientOptions {
-    ownerId?: string | string[];
-    clientPermissions?: bigint[];
-    userPermissions?: bigint[];
-    ignoreOwner?: boolean;
-    logging?: boolean;
-    cooldown?: {
-        default?: number;
-        cache?: number;
-    };
-}
-export interface HandlerOptions {
-    message?: MessageCommandOptions;
-    slash?: SlashCommandOptions;
-    context?: ContextCommandOptions;
-    events?: EventLoadOptions;
-    inhibitors?: InhibitorLoadOptions;
-}
-export interface Commands {
-    message: Collection<string, MessageCommandBuilder>;
-    slash: Collection<string, SlashCommandBuilder>;
-    context: Collection<string, ContextCommandBuilder>;
-}
-export interface Cache {
-    messages: Collection<string, object>;
-    cooldowns: Collection<string, object>;
-    messageCommands: Collection<string, object>;
-    slashCommands: Collection<string, object>;
-    contextCommands: Collection<string, object>;
-    commands: Collection<string, object>;
-}
-export interface Modules {
-    commandHandler: CommandHandler;
-    eventHandler: EventHandler;
-    inhibitorHandler: InhibitorHandler;
-}
-export interface ExtensionOptions {
-    extensions: Array<ExtensionBuilder>;
-    logging?: boolean;
-}

package/dist/interfaces/CommandInterfaces.d.ts

@@ -1,94 +0,0 @@
-import { ChannelType, ContextMenuCommandType } from "discord.js";
-import { ContextCommandType } from "../types/enums.js";
-export interface MessageCommandOptions {
-    name: string;
-    regex?: string;
-    aliases?: string[];
-    description?: string;
-    prefix?: string | string[];
-    info?: string;
-    category?: string;
-    owner?: boolean;
-    channelType?: ChannelType | ChannelType[];
-    separator?: string;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    commandType?: string;
-    args: object[];
-}
-export interface ContextCommandOptions {
-    name: string;
-    type: ContextMenuCommandType | number | ContextCommandType;
-    description?: string;
-    info?: string;
-    category?: string;
-    owner?: boolean;
-    channelType?: ChannelType;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    defaultMemberPermissions?: bigint | number | bigint | null | undefined;
-    DMPermission?: undefined | null | boolean;
-    nameLocalization?: {
-        locale: "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "sv-SE" | "th" | "tr" | "uk" | "vi";
-        localizedName: null | string;
-    };
-    nameLocalizations?: null | Partial<Record<"en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "sv-SE" | "th" | "tr" | "uk" | "vi", null | string>>;
-    commandType?: string;
-    defer?: {
-        reply?: boolean;
-        ephemeral?: boolean;
-        fetchReply?: boolean;
-    };
-}
-export interface SlashArg {
-    type: "string" | "number" | "boolean" | "user" | "channel" | "role" | "mentionable" | "integer";
-    name: string;
-    choices: Array<{
-        name: string;
-        value: string;
-    }>;
-    required: boolean;
-    description: string;
-}
-export interface SlashSubcommand {
-    name: string;
-    description: string;
-    args: Array<SlashArg>;
-}
-export interface SlashGroup {
-    name: string;
-    description: string;
-    subcommands: Array<SlashSubcommand>;
-}
-export interface SlashCommandOptions {
-    name: string;
-    description: string;
-    info?: string;
-    category?: string;
-    owner?: boolean;
-    channelType?: ChannelType;
-    separator?: string;
-    cooldown?: number;
-    ignoreOwner?: boolean;
-    channels?: string[];
-    guilds?: string[];
-    userPermissions?: bigint[];
-    clientPermissions?: bigint[];
-    args?: Array<SlashArg>;
-    subcommands?: Array<SlashSubcommand>;
-    groups?: Array<SlashGroup>;
-    commandType?: string;
-    defer?: {
-        reply?: boolean;
-        ephemeral?: boolean;
-        fetchReply?: boolean;
-    };
-}

package/dist/interfaces/CommandInterfaces.js

@@ -1 +0,0 @@
-export {};