gralonium 0.2.0

package/README.md

@@ -0,0 +1,62 @@
+## Install
+```bash
+npm install gralonium
+```
+
+## Features
+
+* Unified command pipeline for prefix and slash commands
+* Modular command/event/interaction loaders
+* Guards and plugin hooks
+* Built-in cooldowns and permission gates
+* Centralized framework error events (`frameworkError`)
+* Optional debug mode and rate-limit retry for send operations
+
+## Example
+
+```js
+const { Gralonium, GatewayIntentBits, Partials } = require("gralonium");
+
+const client = new Gralonium({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent
+  ],
+  partials: [Partials.Channel],
+  prefix: ".",
+  debug: true,
+  bindProcessHandlers: true,
+  retryOnRateLimit: true
+});
+
+await client.load("./files");
+
+client.on("frameworkError", (err, ctx) => {
+  console.error(err, ctx?.command?.data?.name);
+});
+
+client.login("TOKEN");
+```
+
+## Breaking changes
+* Client construction now validates required framework/runtime options (`intents`, `prefix`).
+* Prefix parsing now resolves routing first and then parses args from raw message content, improving quote/space fidelity.
+* Component utilities (`Paginator`, `Confirmator`) now require `setMessage()` and use message-scoped collectors.
+* `Context#send()` now blocks autocomplete replies and supports optional bounded retry for 429 responses.
+
+## Migration notes
+
+* Prefer `const { Gralonium } = require("gralonium")`.
+* Ensure your client options always include `intents` and `prefix`.
+* If you use `Paginator`/`Confirmator`, always call `.setMessage(sentMessage)` before `.start()`.
+* Use `retryOnRateLimit: true` only when you want bounded automatic retries for send operations.
+
+## Notes
+
+* Unified execution for slash and prefix command handlers is implemented in `Utils.executeCommand()`.
+* Use `frameworkError` to centralize framework/runtime errors.
+
+## Disclaimer
+
+Not affiliated with Discord or discord.js.

package/lib/classes/Client.d.ts

@@ -0,0 +1,44 @@
+import { Client, ClientOptions, CommandInteraction, Message, Snowflake } from "discord.js";
+import { Context } from "./Context.js";
+import { Loader, Plugin } from "./Loader.js";
+import { HelpCommand } from "./HelpCommand.js";
+import { Cooldowns } from "./Cooldowns.js";
+
+export interface EnireRestrictions {
+  userIDs: Set<Snowflake>;
+  guildIDs: Set<Snowflake>;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+
+export interface EnireOptions extends ClientOptions {
+  autoSync?: boolean;
+  context?: typeof Context;
+  guildOnly?: boolean;
+  owners?: Snowflake[];
+  prefix: string | string[] | ((ctx: Context) => MaybePromise<string | string[]>);
+  replyOnEdit?: boolean;
+  helpCommand?: typeof HelpCommand;
+  restrictions?: EnireRestrictions;
+  debug?: boolean;
+  bindProcessHandlers?: boolean;
+  retryOnRateLimit?: boolean;
+}
+
+export declare class RedBot extends Client {
+  cooldowns: Cooldowns;
+  loader: Loader;
+  ops: EnireOptions;
+  constructor(options: EnireOptions);
+  addGlobalPlugins(plugins: Plugin[]): this;
+  getContext(data: CommandInteraction | Message): Context;
+  load(dir: string, reload?: boolean): Promise<import("./Loader.js").ModuleData<import("./builders/InteractionBuilder.js").InteractionBuilder | import("./builders/CommandBuilder.js").CommandBuilder | import("./builders/EventBuilder.js").EventBuilder | import("./builders/GroupBuilder.js").GroupBuilder, any[]>[]>;
+  sync(guildIDs?: string[]): Promise<void>;
+  handleFrameworkError(error: unknown, ctx?: Context | null): void;
+  login(token: string): Promise<string>;
+  destroy(): this;
+}
+
+export { RedBot as Enire };
+export { RedBot as Erine };
+export { RedBot as Gralonium };

package/lib/classes/Client.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gralonium = exports.Erine = exports.Enire = exports.RedBot = void 0;
+
+const discord_js_1 = require("discord.js");
+const Context_js_1 = require("./Context.js");
+const Loader_js_1 = require("./Loader.js");
+const Cooldowns_js_1 = require("./Cooldowns.js");
+const Utils_js_1 = require("./Utils.js");
+
+class RedBot extends discord_js_1.Client {
+  static #processHandlersBound = false;
+  static #boundClients = new Set();
+
+  cooldowns = new Cooldowns_js_1.Cooldowns(this);
+  loader = new Loader_js_1.Loader({ client: this });
+  ops;
+  #coreListenersBound = false;
+
+  constructor(options) {
+    if (!options || typeof options !== "object") {
+      throw new TypeError("Client options are required.");
+    }
+
+    if (options.intents === undefined) {
+      throw new TypeError("Missing required client option: intents.");
+    }
+
+    if (!("prefix" in options)) {
+      throw new TypeError("Missing required framework option: prefix.");
+    }
+
+    super(options);
+    this.ops = options;
+
+    if (this.ops.guildOnly === undefined) this.ops.guildOnly = true;
+    if (typeof this.ops.debug !== "boolean") this.ops.debug = false;
+  }
+
+  addGlobalPlugins(plugins) {
+    this.loader.globalPlugins.push(...plugins);
+    return this;
+  }
+
+  getContext(data) {
+    return new (this.ops.context || Context_js_1.Context)(this, data);
+  }
+
+  async load(dir, reload = false) {
+    if (!dir) throw new SyntaxError("Missing module path in Gralonium#load!");
+    return this.loader.load(dir, reload);
+  }
+
+  async sync(guildIDs) {
+    await this.loader.sync(guildIDs);
+  }
+
+  #debug(message) {
+    if (!this.ops.debug) return;
+    this.emit("debug", `[gralonium] ${message}`);
+  }
+
+  handleFrameworkError(error, ctx = null) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const summary = `${normalized.name}: ${normalized.message}`;
+    this.#debug(summary);
+
+    this.emit("frameworkError", normalized, ctx);
+    if (this.listenerCount("error") > 0) {
+      this.emit("error", normalized);
+    }
+  }
+
+  #bindCoreListeners() {
+    if (this.#coreListenersBound) return;
+
+    this.on("messageCreate", async (message) => {
+      try {
+        await Utils_js_1.Utils.handleMessage(this, message, false);
+      } catch (error) {
+        this.handleFrameworkError(error, error?.ctx ?? null);
+      }
+    });
+
+    if (this.ops.replyOnEdit === true) {
+      this.on("messageUpdate", async (_oldMessage, newMessage) => {
+        try {
+          await Utils_js_1.Utils.handleMessage(this, newMessage, true);
+        } catch (error) {
+          this.handleFrameworkError(error, error?.ctx ?? null);
+        }
+      });
+    }
+
+    this.on("interactionCreate", async (interaction) => {
+      try {
+        await Utils_js_1.Utils.handleInteraction(this, interaction);
+      } catch (error) {
+        this.handleFrameworkError(error, error?.ctx ?? null);
+      }
+    });
+
+    this.#coreListenersBound = true;
+  }
+
+  static #bindProcessHandlers() {
+    if (RedBot.#processHandlersBound) return;
+
+    const dispatch = (error) => {
+      for (const client of RedBot.#boundClients) {
+        client.handleFrameworkError(error);
+      }
+    };
+
+    process.on("uncaughtException", dispatch);
+    process.on("unhandledRejection", dispatch);
+
+    RedBot.#processHandlersBound = true;
+  }
+
+  #registerHelpCommand() {
+    if (!this.ops.helpCommand) return;
+
+    const help = new this.ops.helpCommand();
+    if (!this.loader.commands.normal) this.loader.commands.normal = new discord_js_1.Collection();
+
+    this.loader.commands.normal.set("help", {
+      data: help.data,
+      params: help.params,
+      plugins: help.plugins,
+      code: help.code.bind(help),
+    });
+  }
+
+  async login(token) {
+    if (this.ops.bindProcessHandlers !== false) {
+      RedBot.#bindProcessHandlers();
+      RedBot.#boundClients.add(this);
+    }
+
+    this.#bindCoreListeners();
+    this.#registerHelpCommand();
+
+    if (this.ops.debug) {
+      this.rest.on("rateLimited", (details) => {
+        this.#debug(`Rate limited: ${JSON.stringify(details)}`);
+      });
+    }
+
+    return super.login(token);
+  }
+
+  destroy() {
+    RedBot.#boundClients.delete(this);
+    return super.destroy();
+  }
+}
+
+exports.RedBot = RedBot;
+exports.Enire = RedBot;
+exports.Erine = RedBot;
+exports.Gralonium = RedBot;

package/lib/classes/Context.d.ts

@@ -0,0 +1,25 @@
+import { Command, Types } from "../classes/Loader.js";
+import * as P from "./builders/ParamsBuilder.js";
+import { Enire } from "./Client.js";
+import * as DJS from "discord.js";
+
+export declare class Context {
+  bot: Enire;
+  args: string[] | null;
+  data: DJS.Message | DJS.CommandInteraction;
+  prefix: string;
+  isEditedMessage: boolean;
+  command: Command<Types.Normal> | null;
+  parent: Command<Types.Group> | null;
+  params: P.BaseParam[] | null;
+  constructor(bot: Enire, data: DJS.Message | DJS.CommandInteraction);
+  get message(): DJS.Message | null;
+  get interaction(): DJS.CommandInteraction | null;
+  get author(): DJS.User;
+  get channel(): DJS.TextBasedChannel | null;
+  get member(): DJS.GuildMember | DJS.APIInteractionGuildMember | null;
+  get guild(): DJS.Guild | null;
+  send(payload: string | DJS.MessagePayload | DJS.MessageCreateOptions | DJS.InteractionReplyOptions | DJS.InteractionEditReplyOptions): Promise<DJS.Message<boolean>>;
+  react(...emojis: string[]): Promise<DJS.MessageReaction | undefined>;
+  get<T>(param: string): T | null;
+}

package/lib/classes/Context.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+
+const tslib_1 = require("tslib");
+const DJS = tslib_1.__importStar(require("discord.js"));
+
+class Context {
+  bot;
+  args;
+  data;
+  prefix = "";
+  isEditedMessage = false;
+  command;
+  parent = null;
+  params;
+
+  constructor(bot, data) {
+    this.bot = bot;
+    this.data = data;
+    this.command = null;
+    this.params = this.data instanceof DJS.Message ? [] : [];
+    this.args = this.data instanceof DJS.Message ? [] : null;
+  }
+
+  get message() {
+    return this.data instanceof DJS.Message ? this.data : null;
+  }
+
+  get interaction() {
+    return this.data instanceof DJS.Message ? null : this.data;
+  }
+
+  get author() {
+    return this.data instanceof DJS.Message ? this.data.author : this.data.user;
+  }
+
+  get channel() {
+    return this.data.channel || null;
+  }
+
+  get member() {
+    return this.data.member || null;
+  }
+
+  get guild() {
+    return this.data.guild || null;
+  }
+
+  static #isRateLimitError(error) {
+    if (!error) return false;
+    if (error?.code === 429) return true;
+    if (error?.status === 429) return true;
+    return false;
+  }
+
+  static #extractRetryAfter(error) {
+    const retryAfterHeader = Number(error?.rawError?.retry_after ?? error?.retry_after ?? error?.data?.retry_after);
+    if (Number.isFinite(retryAfterHeader) && retryAfterHeader > 0) {
+      return Math.ceil(retryAfterHeader * 1000);
+    }
+
+    const resetAfter = Number(error?.requestBody?.json?.retry_after);
+    if (Number.isFinite(resetAfter) && resetAfter > 0) {
+      return Math.ceil(resetAfter * 1000);
+    }
+
+    return 0;
+  }
+
+  async #sendWithOptionalRetry(callable) {
+    try {
+      return await callable();
+    } catch (error) {
+      if (!this.bot.ops?.retryOnRateLimit || !Context.#isRateLimitError(error)) {
+        throw error;
+      }
+
+      const retryMs = Context.#extractRetryAfter(error);
+      // Bound retries to short windows to avoid hanging command execution paths.
+      if (!retryMs || retryMs > 10_000) {
+        throw error;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, retryMs));
+      return callable();
+    }
+  }
+
+  async send(payload) {
+    if (this.data instanceof DJS.Message) {
+      return this.#sendWithOptionalRetry(() => this.data.channel.send(payload));
+    }
+
+    if (this.data.isAutocomplete?.()) {
+      throw new Error("Autocomplete interactions cannot send message replies. Use interaction.respond() instead.");
+    }
+
+    const replyPayload =
+      typeof payload === "string"
+        ? { content: payload }
+        : payload && typeof payload === "object"
+        ? payload
+        : { content: String(payload ?? "") };
+
+    if (this.data.deferred || this.data.replied) {
+      return this.#sendWithOptionalRetry(() => this.data.editReply(replyPayload));
+    }
+
+    return this.#sendWithOptionalRetry(() => this.data.reply(replyPayload));
+  }
+
+  async react(...emojis) {
+    if (!(this.data instanceof DJS.Message)) return undefined;
+
+    let lastReaction;
+    for (const emoji of emojis) {
+      lastReaction = await this.data.react(emoji);
+    }
+
+    return lastReaction;
+  }
+
+  get(param) {
+    const lowered = param.toLowerCase();
+
+    if (this.params?.length) {
+      return this.params.find((entry) => entry.name.toLowerCase() === lowered)?.value ?? null;
+    }
+
+    if (this.data instanceof DJS.Message) return null;
+
+    const option = this.data.options?.data?.find((entry) => entry.name.toLowerCase() === lowered);
+    if (!option) return null;
+
+    return option.attachment ?? option.member ?? option.channel ?? option.role ?? option.user ?? option.value ?? null;
+  }
+}
+exports.Context = Context;

package/lib/classes/Cooldowns.d.ts

@@ -0,0 +1,25 @@
+import { Erine } from "./Client";
+import { Collection } from "discord.js";
+export declare enum Bucket {
+    Member = "MEMBER",
+    User = "USER",
+    Guild = "GUILD",
+    Channel = "CHANNEL"
+}
+export declare class Cooldowns {
+    bot: Erine;
+    track: Collection<string, {
+        startedAt: number;
+        expiresAt: number;
+    }>;
+    constructor(bot: Erine);
+    getCooldownSource(command: string, id: string, bucket: Bucket): Promise<number | undefined>;
+    setCooldownSource(command: string, id: string, bucket: Bucket, time: number): Promise<void>;
+    check(command: string, id: string, cooldown: number, bucket: Bucket): Promise<{
+        command: string;
+        id: string;
+        time: number;
+        bucket: Bucket;
+        left: number;
+    } | null>;
+}

package/lib/classes/Cooldowns.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cooldowns = exports.Bucket = void 0;
+const discord_js_1 = require("discord.js");
+
+var Bucket;
+(function (Bucket) {
+  Bucket["Member"] = "MEMBER";
+  Bucket["User"] = "USER";
+  Bucket["Guild"] = "GUILD";
+  Bucket["Channel"] = "CHANNEL";
+})(Bucket || (exports.Bucket = Bucket = {}));
+
+class Cooldowns {
+  bot;
+  track = new discord_js_1.Collection();
+
+  constructor(bot) {
+    this.bot = bot;
+  }
+
+  #key(command, id, bucket) {
+    return `${command}#${bucket}#${id}`;
+  }
+
+  async getCooldownSource(command, id, bucket) {
+    const key = this.#key(command, id, bucket);
+    const tracked = this.track.get(key);
+    if (!tracked) return undefined;
+
+    if (Date.now() >= tracked.expiresAt) {
+      this.track.delete(key);
+      return undefined;
+    }
+
+    return tracked.startedAt;
+  }
+
+  async setCooldownSource(command, id, bucket, time) {
+    const now = Date.now();
+    this.track.set(this.#key(command, id, bucket), {
+      startedAt: now,
+      expiresAt: now + time,
+    });
+  }
+
+  async check(command, id, cooldown, bucket) {
+    const key = this.#key(command, id, bucket);
+    const tracked = this.track.get(key);
+    if (!tracked) return null;
+
+    if (Date.now() >= tracked.expiresAt) {
+      this.track.delete(key);
+      return null;
+    }
+
+    const elapsed = Date.now() - tracked.startedAt;
+    if (elapsed >= cooldown) {
+      this.track.delete(key);
+      return null;
+    }
+
+    return {
+      command,
+      id,
+      time: cooldown,
+      bucket,
+      left: cooldown - elapsed,
+    };
+  }
+}
+exports.Cooldowns = Cooldowns;

package/lib/classes/Errors.d.ts

@@ -0,0 +1,135 @@
+import { Channel, ChannelType, Guild, PermissionResolvable, User } from "discord.js";
+import { BaseParam, ChannelParam } from "./builders/ParamsBuilder.js";
+import { Context } from "./Context.js";
+declare class GuildOnly extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+    get user(): User;
+}
+declare class NotOwner extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+    get user(): User;
+}
+declare class CommandNotFound extends Error {
+    ctx: Context;
+    provided: string;
+    constructor(context: Context, provided: string, message?: string);
+}
+declare class UnknownCommandError extends Error {
+    ctx: Context;
+    error: any;
+    constructor(context: Context, error: any, message?: string);
+}
+declare class MissingRequiredParam extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParam extends Error {
+    ctx: Context;
+    metadata: Record<string, any>;
+    constructor(context: Context, message?: string, metadata?: Record<string, any>);
+}
+declare class InvalidParamNumber extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamBoolean extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamChoice extends Error {
+    ctx: Context;
+    param: BaseParam;
+    choices: {
+        name: string;
+        value: any;
+    }[];
+    constructor(context: Context, param: BaseParam, choices: {
+        name: string;
+        value: any;
+    }[], message?: string);
+}
+declare class InvalidParamMember extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamChannel extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidParamRole extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class InvalidChannelType extends Error {
+    ctx: Context;
+    param: ChannelParam;
+    provided: ChannelType;
+    expected: ChannelType[];
+    constructor(context: Context, param: ChannelParam, provided: ChannelType, expected: ChannelType[], message?: string);
+}
+declare class InvalidParamAttachment extends Error {
+    ctx: Context;
+    param: BaseParam;
+    constructor(context: Context, param: BaseParam, message?: string);
+}
+declare class MissingPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    constructor(context: Context, perms: PermissionResolvable[], message?: string);
+}
+declare class MissingChannelPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    channel: Channel;
+    constructor(context: Context, perms: PermissionResolvable[], channel: Channel, message?: string);
+}
+declare class MissingBotPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    constructor(context: Context, perms: PermissionResolvable[], message?: string);
+}
+declare class MissingBotChannelPermission extends Error {
+    ctx: Context;
+    permissions: PermissionResolvable[];
+    channel: Channel;
+    constructor(context: Context, perms: PermissionResolvable[], channel: Channel, message?: string);
+}
+declare class NotNSFW extends Error {
+    ctx: Context;
+    constructor(context: Context, message?: string);
+}
+declare class NotInChannelType extends Error {
+    ctx: Context;
+    types: ChannelType[];
+    channel: Channel;
+    constructor(ctx: Context, types: ChannelType[], channel: Channel, message?: string);
+}
+declare class OnlyForIDs extends Error {
+    ctx: Context;
+    snowflakes: string[];
+    constructor(context: Context, snowflakes: string[], message?: string);
+}
+declare class CommandInCooldown extends Error {
+    ctx: Context;
+    timeLeft: number;
+    constructor(context: Context, timeLeft: number, message?: string);
+}
+declare class RestrictedUser extends Error {
+    ctx: Context;
+    user: User;
+    constructor(ctx: Context, user: User, message?: string);
+}
+declare class RestrictedGuild extends Error {
+    ctx: Context;
+    guild: Guild;
+    constructor(ctx: Context, guild: Guild, message?: string);
+}
+export { InvalidParam, GuildOnly, NotOwner, CommandNotFound, UnknownCommandError, MissingRequiredParam, InvalidParamNumber, InvalidParamChoice, MissingPermission, MissingChannelPermission, MissingBotPermission, MissingBotChannelPermission, InvalidParamBoolean, InvalidParamMember, InvalidParamChannel, InvalidParamRole, InvalidChannelType, InvalidParamAttachment, NotNSFW, NotInChannelType, OnlyForIDs, CommandInCooldown, RestrictedUser, RestrictedGuild };

package/lib/classes/Errors.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.RestrictedGuild=exports.RestrictedUser=exports.CommandInCooldown=exports.OnlyForIDs=exports.NotInChannelType=exports.NotNSFW=exports.InvalidParamAttachment=exports.InvalidChannelType=exports.InvalidParamRole=exports.InvalidParamChannel=exports.InvalidParamMember=exports.InvalidParamBoolean=exports.MissingBotChannelPermission=exports.MissingBotPermission=exports.MissingChannelPermission=exports.MissingPermission=exports.InvalidParamChoice=exports.InvalidParamNumber=exports.MissingRequiredParam=exports.UnknownCommandError=exports.CommandNotFound=exports.NotOwner=exports.GuildOnly=exports.InvalidParam=void 0;class GuildOnly extends Error{ctx;constructor(s,e="This command is only available in guilds."){super(e),this.ctx=s}get user(){return this.ctx.author}}exports.GuildOnly=GuildOnly;class NotOwner extends Error{ctx;constructor(s,e="Someone that is not register as owner tried to use this command."){super(e),this.ctx=s}get user(){return this.ctx.author}}exports.NotOwner=NotOwner;class CommandNotFound extends Error{ctx;provided;constructor(s,e,r="That command doesn't exist."){super(r),this.ctx=s,this.provided=e}}exports.CommandNotFound=CommandNotFound;class UnknownCommandError extends Error{ctx;error;constructor(s,e,r="An unknown error"){super(r),this.ctx=s,this.error=e}}exports.UnknownCommandError=UnknownCommandError;class MissingRequiredParam extends Error{ctx;param;constructor(s,e,r="You have to provide all required parameters."){super(r),this.ctx=s,this.param=e}}exports.MissingRequiredParam=MissingRequiredParam;class InvalidParam extends Error{ctx;metadata;constructor(s,e="Some parameter is invalid in arguments provided.",r={}){super(e),this.ctx=s,this.metadata=r}}exports.InvalidParam=InvalidParam;class InvalidParamNumber extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid number."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamNumber=InvalidParamNumber;class InvalidParamBoolean extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't boolean."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamBoolean=InvalidParamBoolean;class InvalidParamChoice extends Error{ctx;param;choices;constructor(s,e,r,t="Some parameter in that command isn't a valid choice."){super(t),this.ctx=s,this.param=e,this.choices=r}}exports.InvalidParamChoice=InvalidParamChoice;class InvalidParamMember extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid member."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamMember=InvalidParamMember;class InvalidParamChannel extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid channel."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamChannel=InvalidParamChannel;class InvalidParamRole extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid role."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamRole=InvalidParamRole;class InvalidChannelType extends Error{ctx;param;provided;expected;constructor(s,e,r,t,n="Some parameter in that command isn't a valid channel type allowed."){super(n),this.ctx=s,this.param=e,this.provided=r,this.expected=t}}exports.InvalidChannelType=InvalidChannelType;class InvalidParamAttachment extends Error{ctx;param;constructor(s,e,r="Some parameter in that command isn't a valid attachment."){super(r),this.ctx=s,this.param=e}}exports.InvalidParamAttachment=InvalidParamAttachment;class MissingPermission extends Error{ctx;permissions;constructor(s,e,r="The command author doesn't have permissions enough to execute this command."){super(r),this.ctx=s,this.permissions=e}}exports.MissingPermission=MissingPermission;class MissingChannelPermission extends Error{ctx;permissions;channel;constructor(s,e,r,t="The command author doesn't have permissions enough in a channel to execute this command."){super(t),this.ctx=s,this.permissions=e,this.channel=r}}exports.MissingChannelPermission=MissingChannelPermission;class MissingBotPermission extends Error{ctx;permissions;constructor(s,e,r="I don't have permissions enough to execute this command."){super(r),this.ctx=s,this.permissions=e}}exports.MissingBotPermission=MissingBotPermission;class MissingBotChannelPermission extends Error{ctx;permissions;channel;constructor(s,e,r,t="I don't have permissions enough in that channel to execute this command."){super(t),this.ctx=s,this.permissions=e,this.channel=r}}exports.MissingBotChannelPermission=MissingBotChannelPermission;class NotNSFW extends Error{ctx;constructor(s,e="This command can only be executed in a NSFW channel."){super(e),this.ctx=s}}exports.NotNSFW=NotNSFW;class NotInChannelType extends Error{ctx;types;channel;constructor(s,e,r,t="This command can only be executed in certain channel types."){super(t),this.ctx=s,this.types=e,this.channel=r}}exports.NotInChannelType=NotInChannelType;class OnlyForIDs extends Error{ctx;snowflakes;constructor(s,e,r="This command can only be used by specified users."){super(r),this.ctx=s,this.snowflakes=e}}exports.OnlyForIDs=OnlyForIDs;class CommandInCooldown extends Error{ctx;timeLeft;constructor(s,e,r="This command is in cooldown."){super(r),this.ctx=s,this.timeLeft=e}}exports.CommandInCooldown=CommandInCooldown;class RestrictedUser extends Error{ctx;user;constructor(s,e,r="Looks like this user is restricted from bot."){super(r),this.ctx=s,this.user=e}}exports.RestrictedUser=RestrictedUser;class RestrictedGuild extends Error{ctx;guild;constructor(s,e,r="Looks like this guild is restricted from bot."){super(r),this.ctx=s,this.guild=e}}exports.RestrictedGuild=RestrictedGuild;

package/lib/classes/HelpCommand.d.ts

@@ -0,0 +1,15 @@
+import { type Plugin, CommandBuilder, Context, CommandHelpingObject, GroupHelpingObject, ParamsBuilder } from "../main.js";
+export declare class HelpCommand {
+    data: CommandBuilder;
+    plugins: Plugin[];
+    params: ParamsBuilder;
+    code(ctx: Context): Promise<void>;
+    sendEmpty(ctx: Context): Promise<void>;
+    sendNotFound(ctx: Context): Promise<void>;
+    sendCommand(ctx: Context, command: CommandHelpingObject): Promise<void>;
+    sendGroup(ctx: Context, group: GroupHelpingObject): Promise<void>;
+    getCommand(ctx: Context, q: string): CommandHelpingObject | null;
+    getGroup(ctx: Context, q: string): GroupHelpingObject | null;
+    private doEmbed;
+    private c;
+}