xernerx 3.3.7 → 3.4.1

package/dist/build/ContextCommandBuilder.d.ts

@@ -1,6 +1,6 @@
 import { ChannelType, ContextMenuCommandBuilder, Interaction } from 'discord.js';
-import { XernerxClient } from '../main.js';
 import { ContextCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description The command builder for context commands.
  * @param {String} id - The unique ID of the command.
@@ -9,6 +9,8 @@ import { ContextCommandOptions } from '../types/options.js';
 export default class ContextCommandBuilder {
     id: string;
     data: ContextMenuCommandBuilder;
+    name: string;
+    type: number;
     description?: string;
     info?: string;
     category?: string;

package/dist/build/ContextCommandBuilder.js

@@ -1,6 +1,6 @@
 import { ContextMenuCommandBuilder } from 'discord.js';
 import { s } from '@sapphire/shapeshift';
-import { XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description The command builder for context commands.
  * @param {String} id - The unique ID of the command.
@@ -9,6 +9,8 @@ import { XernerxClient } from '../main.js';
 export default class ContextCommandBuilder {
     id;
     data;
+    name;
+    type;
     description;
     info;
     category;
@@ -55,6 +57,8 @@ export default class ContextCommandBuilder {
                 fetchReply: s.boolean.optional,
             }).optional,
         }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
         this.description = options.description;
         this.info = options.info;
         this.category = options.category;

package/dist/build/EventBuilder.d.ts

@@ -1,4 +1,4 @@
-import { XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 import { EventOptions } from '../types/options.js';
 /**
  * @description - The event builder for  events.

package/dist/build/EventBuilder.js

@@ -1,5 +1,5 @@
 import { s } from '@sapphire/shapeshift';
-import { XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The event builder for  events.
  * @param {String} id - The unique ID of the event.

package/dist/build/InhibitorBuilder.d.ts

@@ -1,4 +1,5 @@
-import { InhibitorType, XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorType } from '../main.js';
 import { InhibitorOptions, MessageArgOptions, SlashArgOptions } from '../types/options.js';
 import { XernerxInteraction, XernerxMessage } from '../types/types.js';
 /**

package/dist/build/InhibitorBuilder.js

@@ -1,5 +1,5 @@
 import { s } from '@sapphire/shapeshift';
-import { XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The inhibitor builder for inhibitors.
  * @param {String} id - The unique ID of the inhibitor.

package/dist/build/MessageCommandBuilder.d.ts

@@ -1,6 +1,6 @@
 import { Message, ChannelType } from 'discord.js';
-import { XernerxClient } from '../main.js';
 import { MessageArgOptions, MessageCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The command builder for message commands.
  * @param {String} id - The unique ID of the command.

package/dist/build/MessageCommandBuilder.js

@@ -1,5 +1,5 @@
 import { s } from '@sapphire/shapeshift';
-import { XernerxClient } from '../main.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The command builder for message commands.
  * @param {String} id - The unique ID of the command.

package/dist/build/SlashCommandBuilder.d.ts

@@ -1,15 +1,16 @@
 import Discord, { ChannelType, Interaction } from 'discord.js';
-import { XernerxClient } from '../main.js';
 import { SlashCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The command builder for slash commands.
  * @param {String} id - The unique ID of the command.
  * @param {SlashCommandOptions} options - The command options.
  */
 export default class SlashCommandBuilder {
-    #private;
     id: string;
     data: Discord.SlashCommandBuilder;
+    name: string;
+    description: string;
     info?: string;
     category?: string;
     owner?: boolean;
@@ -33,4 +34,7 @@ export default class SlashCommandBuilder {
     constructor(id: string, options: SlashCommandOptions);
     conditions(interaction: Interaction): Promise<void>;
     exec(interaction: Interaction): Promise<void>;
+    private addArgs;
+    private addSubcommands;
+    private addSubcommandGroups;
 }

package/dist/build/SlashCommandBuilder.js

@@ -1,7 +1,7 @@
-import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, } from 'discord.js';
 import { s } from '@sapphire/shapeshift';
-import { XernerxClient } from '../main.js';
 import XernerxError from '../tools/XernerxError.js';
+import XernerxClient from '../client/XernerxClient.js';
 /**
  * @description - The command builder for slash commands.
  * @param {String} id - The unique ID of the command.
@@ -10,6 +10,8 @@ import XernerxError from '../tools/XernerxError.js';
 export default class SlashCommandBuilder {
     id;
     data;
+    name;
+    description;
     info;
     category;
     owner;
@@ -30,13 +32,13 @@ export default class SlashCommandBuilder {
         this.id = id;
         this.data = new Discord.SlashCommandBuilder().setName(options.name).setDescription(options.description);
         if (options.args && options?.args?.length > 0) {
-            this.#addArgs(this.data, options.args);
+            this.addArgs(this.data, options.args);
         }
         if (options.subcommands && options?.subcommands?.length > 0) {
-            this.#addSubcommands(this.data, options.subcommands);
+            this.addSubcommands(this.data, options.subcommands);
         }
         if (options.groups && options?.groups?.length > 0) {
-            this.#addSubcommandGroups(options.groups);
+            this.addSubcommandGroups(options.groups);
         }
         s.object({
             info: s.string.optional,
@@ -56,6 +58,8 @@ export default class SlashCommandBuilder {
                 fetchReply: s.boolean.optional,
             }).optional,
         });
+        this.name = options.name;
+        this.description = options.description;
         this.info = options.info;
         this.category = options.category;
         this.owner = options.owner;
@@ -74,12 +78,14 @@ export default class SlashCommandBuilder {
     }
     async conditions(interaction) { }
     async exec(interaction) { }
-    #addArgs(command, args) {
+    addArgs(command, args) {
         const types = ['boolean', 'integer', 'number', 'string', 'user', 'role', 'channel', 'mentionable'];
         for (const argument of args) {
             if (!types.includes(argument.type.toLowerCase()))
                 throw new XernerxError(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
-            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            let slashArgumentType = `${argument.type.slice(0, 1).toUpperCase()}${argument.type
+                .slice(1)
+                .toLowerCase()}`;
             command[`add${slashArgumentType}Option`]((option) => {
                 option
                     .setName(argument.name)
@@ -91,19 +97,21 @@ export default class SlashCommandBuilder {
             });
         }
     }
-    #addSubcommands(method, subcommands) {
+    addSubcommands(method, subcommands) {
         for (const subcommand of subcommands) {
             let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
             if (subcommand.args?.length > 0)
-                this.#addArgs(sub, subcommand.args);
+                this.addArgs(sub, subcommand.args);
             method.addSubcommand(sub);
         }
     }
-    #addSubcommandGroups(groups) {
+    addSubcommandGroups(groups) {
         for (const group of groups) {
-            let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+            let subcommandGroup = new SlashCommandSubcommandGroupBuilder()
+                .setName(group.name)
+                .setDescription(group.description);
             if (group.subcommands?.length > 0)
-                this.#addSubcommands(subcommandGroup, group.subcommands);
+                this.addSubcommands(subcommandGroup, group.subcommands);
             this.data.addSubcommandGroup(subcommandGroup);
         }
     }

package/dist/build/XContextCommandBuilder.d.ts

@@ -0,0 +1,40 @@
+import { ChannelType, ContextMenuCommandBuilder, Interaction } from 'discord.js';
+import { ContextCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class XContextCommandBuilder {
+    id: string;
+    data: ContextMenuCommandBuilder;
+    description?: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    client: XernerxClient | object;
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    conditions(interaction: Interaction): Promise<void>;
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    exec(interaction: Interaction): Promise<void>;
+}

package/dist/build/XContextCommandBuilder.js

@@ -0,0 +1,84 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import { s } from '@sapphire/shapeshift';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description The command builder for context commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {ContextCommandOptions} options - The command options.
+ */
+export default class XContextCommandBuilder {
+    id;
+    data;
+    description;
+    info;
+    category;
+    owner;
+    channelType;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new ContextMenuCommandBuilder();
+        if (options.name)
+            this.data.setName(options.name);
+        if (options.type)
+            this.data.setType(options.type);
+        if (options.defaultMemberPermissions)
+            this.data.setDefaultMemberPermissions(options.defaultMemberPermissions);
+        if (options.DMPermission)
+            this.data.setDMPermission(options.DMPermission);
+        if (options.nameLocalization)
+            this.data.setNameLocalization(options.nameLocalization.locale, options.nameLocalization.localizedName);
+        if (options.nameLocalizations)
+            this.data.setNameLocalizations(options.nameLocalizations);
+        s.object({
+            description: s.string.optional,
+            info: s.string.optional,
+            category: s.string.optional,
+            owner: s.boolean.optional,
+            channelType: s.union(s.number, s.array(s.number)).optional,
+            cooldown: s.number.optional,
+            ignoreOwner: s.boolean.optional,
+            channels: s.array(s.string).optional,
+            guilds: s.array(s.string).optional,
+            userPermissions: s.array(s.bigint).optional,
+            clientPermissions: s.array(s.bigint).optional,
+            defer: s.object({
+                reply: s.boolean.optional,
+                ephemeral: s.boolean.optional,
+                fetchReply: s.boolean.optional,
+            }).optional,
+        }).parse(options);
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.owner = options.owner;
+        this.channelType = options.channelType;
+        this.cooldown = options.cooldown;
+        this.ignoreOwner = options.ignoreOwner;
+        this.channels = options.channels;
+        this.guilds = options.guilds;
+        this.userPermissions = options.userPermissions;
+        this.clientPermissions = options.clientPermissions;
+        this.defer = options.defer;
+        this.client = XernerxClient;
+        this.conditions = this.conditions;
+        this.exec = this.exec;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     */
+    async conditions(interaction) { }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     */
+    async exec(interaction) { }
+}

package/dist/build/XEventBuilder.d.ts

@@ -0,0 +1,17 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { EventOptions } from '../types/options.js';
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class XEventBuilder {
+    id: string;
+    name: string;
+    emitter?: string;
+    type?: string;
+    once?: boolean;
+    client: XernerxClient | object;
+    constructor(id: string, options: EventOptions);
+    run(): Promise<void>;
+}

package/dist/build/XEventBuilder.js

@@ -0,0 +1,35 @@
+import { s } from '@sapphire/shapeshift';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+export default class XEventBuilder {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            emitter: s.string.optional,
+            type: s.string.optional,
+            once: s.boolean.optional,
+        }).parse(options);
+        this.name = options.name;
+        this.emitter = options.emitter || 'client';
+        this.type = options.type || 'discord';
+        this.once = options.once || false;
+        this.client = XernerxClient;
+        this.run = this.run;
+    }
+    async run() {
+        /**
+         * @description run your custom event here.
+         */
+    }
+}

package/dist/build/XInhibitorBuilder.d.ts

@@ -0,0 +1,20 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorType } from '../main.js';
+import { InhibitorOptions, MessageArgOptions, SlashArgOptions } from '../types/options.js';
+import { XernerxInteraction, XernerxMessage } from '../types/types.js';
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export default class XInhibitorBuilder {
+    id: string;
+    name: string;
+    type: InhibitorType;
+    client: XernerxClient | object;
+    constructor(id: string, options: InhibitorOptions);
+    /**
+     *
+     */
+    check(interaction: XernerxInteraction | XernerxMessage, args: SlashArgOptions | MessageArgOptions): Promise<void>;
+}

package/dist/build/XInhibitorBuilder.js

@@ -0,0 +1,28 @@
+import { s } from '@sapphire/shapeshift';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+export default class XInhibitorBuilder {
+    id;
+    name;
+    type;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            type: s.string,
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = XernerxClient;
+        this.check = this.check;
+    }
+    /**
+     *
+     */
+    async check(interaction, args) { }
+}

package/dist/build/XMessageCommandBuilder.d.ts

@@ -0,0 +1,42 @@
+import { Message, ChannelType } from 'discord.js';
+import { MessageArgOptions, MessageCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class XMessageCommandBuilder {
+    id: string;
+    name: string;
+    aliases?: string[];
+    description?: string;
+    info?: string;
+    category?: string;
+    prefix?: string | string[];
+    regex?: string;
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args?: Array<MessageArgOptions>;
+    client: XernerxClient | object;
+    constructor(id: string, options: MessageCommandOptions);
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    conditions(message: Message, args: MessageArgOptions): Promise<void>;
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    exec(message: Message, args: MessageArgOptions): Promise<void>;
+}

package/dist/build/XMessageCommandBuilder.js

@@ -0,0 +1,80 @@
+import { s } from '@sapphire/shapeshift';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for message commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {MessageCommandOptions} options - The command options.
+ */
+export default class XMessageCommandBuilder {
+    id;
+    name;
+    aliases;
+    description;
+    info;
+    category;
+    prefix;
+    regex;
+    owner;
+    channelType;
+    separator;
+    cooldown;
+    ignoreOwner;
+    channels;
+    guilds;
+    userPermissions;
+    clientPermissions;
+    args;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        s.object({
+            name: s.string,
+            aliases: s.union(s.array(s.string).unique, s.string).optional,
+            description: s.string.optional,
+            info: s.string.optional,
+            category: s.string.optional,
+            prefix: s.union(s.array(s.string).unique, s.string).optional,
+            owner: s.boolean.optional,
+            channelType: s.union(s.number, s.array(s.number)).optional,
+            separator: s.string.optional,
+            cooldown: s.number.optional,
+            ignoreOwner: s.boolean.optional,
+            channels: s.array(s.string).unique.optional,
+            guilds: s.array(s.string).unique.optional,
+            userPermissions: s.array(s.bigint).unique.optional,
+            clientPermissions: s.array(s.bigint).unique.optional,
+        }).parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.prefix = options.prefix ? (Array.isArray(options.prefix) ? options.prefix : [options.prefix]) : [];
+        this.regex = options.regex;
+        this.owner = options.owner || false;
+        this.channelType = options.channelType;
+        this.separator = options.separator || ' ';
+        this.cooldown = options.cooldown || 0;
+        this.ignoreOwner = options.ignoreOwner || false;
+        this.channels = options.channels || [];
+        this.guilds = options.guilds || [];
+        this.userPermissions = options.userPermissions || [];
+        this.clientPermissions = options.clientPermissions || [];
+        this.args = options.args || [];
+        this.client = XernerxClient;
+        this.conditions = this.conditions;
+        this.exec = this.exec;
+    }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description make any preconditions here.
+     */
+    async conditions(message, args) { }
+    /**
+     * @param {Message} message - The Discord message event data.
+     * @param {object} args - The arguments you created.
+     * @description Make your custom command here.
+     */
+    async exec(message, args) { }
+}

package/dist/build/XSlashCommandBuilder.d.ts

@@ -0,0 +1,36 @@
+import Discord, { ChannelType, Interaction } from 'discord.js';
+import { SlashCommandOptions } from '../types/options.js';
+import XernerxClient from '../client/XernerxClient.js';
+/**
+ * @description - The command builder for slash commands.
+ * @param {String} id - The unique ID of the command.
+ * @param {SlashCommandOptions} options - The command options.
+ */
+export default class SlashCommandBuilder {
+    #private;
+    id: string;
+    data: Discord.SlashCommandBuilder;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType | ChannelType[];
+    separator?: string;
+    cooldown?: number;
+    ignoreOwner?: boolean;
+    channels?: string[];
+    guilds?: string[];
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    args?: object[];
+    subcommands?: object[];
+    groups?: object[];
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    client: XernerxClient | object;
+    constructor(id: string, options: SlashCommandOptions);
+    conditions(interaction: Interaction): Promise<void>;
+    exec(interaction: Interaction): Promise<void>;
+}