xernerx 4.14.0 → 4.15.0

package/dist/cjs/build/XernerxContextCommand.js

@@ -0,0 +1,124 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const zod_1 = require("zod");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class XernerxContextCommand {
+    constructor(id, options) {
+        this.id = id;
+        this.data = new discord_js_1.ContextMenuCommandBuilder();
+        this.data.setName(options.name);
+        this.data.setNameLocalizations(options.nameLocalizations || null);
+        this.data.setType(options.type === 'user' ? 2 : 3);
+        this.data.setDMPermission(options.permissions?.dm || null);
+        options = zod_1.z
+            .object({
+            name: zod_1.z.string(),
+            type: zod_1.z.enum(['user', 'message']),
+            description: zod_1.z.string().or(zod_1.z.null()).default(null),
+            usage: zod_1.z.string().or(zod_1.z.null()).default(null),
+            info: zod_1.z.string().or(zod_1.z.null()).default(null),
+            category: zod_1.z.string().or(zod_1.z.null()).default(null),
+            cooldown: zod_1.z.number().or(zod_1.z.null()).default(null),
+            global: zod_1.z.boolean().default(true),
+            channel: zod_1.z
+                .array(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.null())
+                .default(null),
+            ignore: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            strict: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+            defer: zod_1.z
+                .object({
+                reply: zod_1.z.boolean().optional(),
+                ephemeral: zod_1.z.boolean().optional(),
+                fetch: zod_1.z.boolean().optional(),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
+        this.global = options.global;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = this.client;
+        this.util = this.util;
+    }
+    /**
+     * @description the execution of the command
+     * @param interaction - Interaction event emitted on command
+     * @param args - The arguments parsed with the command, if any
+     */
+    async exec(interaction, args) {
+        new XernerxLog_js_1.default(this.client).error(`${this.id} doesn't have an execution rule.`);
+        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+    }
+}
+exports.default = XernerxContextCommand;

package/dist/cjs/build/XernerxEvent.js

@@ -0,0 +1,34 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+/**
+ * @description - The event builder for  events.
+ * @param {String} id - The unique ID of the event.
+ * @param {EventOptions} options - The event options.
+ */
+class XernerxEvent {
+    constructor(id, options) {
+        this.id = id;
+        zod_1.z.object({
+            name: zod_1.z.string(),
+            emitter: zod_1.z.string().optional(),
+            type: zod_1.z.string().optional(),
+            once: zod_1.z.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 = this.client;
+    }
+    /**
+     * @description run your custom event here.
+     * @param any - there can be all kinds of parameters on events.
+     */
+    async run(...args) {
+        return new XernerxLog_js_1.default(this.client).error(`${this.id} doesn't have a run rule.`);
+    }
+}
+exports.default = XernerxEvent;

package/dist/cjs/build/XernerxInhibitor.js

@@ -0,0 +1,30 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+/**
+ * @description - The inhibitor builder for inhibitors.
+ * @param {String} id - The unique ID of the inhibitor.
+ * @param {InhibitorOptions} options - The inhibitor options.
+ */
+class XernerxInhibitor {
+    constructor(id, options) {
+        this.id = id;
+        zod_1.z.object({
+            name: zod_1.z.string(),
+            type: zod_1.z.string(),
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = this.client;
+    }
+    pre(interaction, args) { }
+    /**
+     * @description The check rule
+     * @param interaction - The interaction with the inhibitor, can be message and interaction
+     * @param args - The arguments parsed with this command
+     */
+    async check(interaction, args, command) { }
+    async post(interaction, args, command) { }
+}
+exports.default = XernerxInhibitor;

package/dist/cjs/build/XernerxMessageCommand.js

@@ -0,0 +1,122 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class XernerxMessageCommand {
+    constructor(id, options) {
+        this.id = id;
+        this.regex = options.regex;
+        this.args = options.args;
+        this.flags = options.flags;
+        options = zod_1.z
+            .object({
+            name: zod_1.z.string(),
+            aliases: zod_1.z.array(zod_1.z.string()).default([]),
+            description: zod_1.z.string().or(zod_1.z.null()).default(null),
+            usage: zod_1.z.string().or(zod_1.z.null()).default(null),
+            info: zod_1.z.string().or(zod_1.z.null()).default(null),
+            category: zod_1.z.string().or(zod_1.z.null()).default(null),
+            cooldown: zod_1.z.number().or(zod_1.z.null()).default(null),
+            global: zod_1.z.boolean().default(true),
+            channel: zod_1.z
+                .array(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.null())
+                .default(null),
+            prefix: zod_1.z.array(zod_1.z.string()).or(zod_1.z.string()).default([]),
+            ignore: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            strict: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.aliases = options.aliases;
+        this.prefix = options.prefix;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
+        this.global = options.global;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.separator = options.separator;
+        this.permissions = options.permissions;
+        this.client = this.client;
+        this.util = this.util;
+    }
+    /**
+     * @description Checks for conditions before running the command
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    async conditions(message, { args, flags }) { }
+    /**
+     * @description Runs the execution rule
+     * @param message - The message event emitted on this command
+     * @param options - The args and flags parsed on this command
+     */
+    async exec(message, { args, flags }) {
+        new XernerxLog_js_1.default(this.client).error(`${this.id} doesn't have an execution rule.`);
+        return await this.client.emit('commandError', message, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+    }
+}
+exports.default = XernerxMessageCommand;

package/dist/cjs/build/XernerxSlashCommand.js

@@ -0,0 +1,180 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = __importStar(require("discord.js"));
+const zod_1 = require("zod");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class XernerxSlashCommand {
+    constructor(id, options) {
+        this.id = id;
+        this.data = new discord_js_1.default.SlashCommandBuilder();
+        this.data.setName(options.name);
+        this.data.setNameLocalizations(options.nameLocalizations || null);
+        this.data.setDescription(options.description);
+        this.data.setDescriptionLocalizations(options.descriptionLocalizations || null);
+        this.data.setDMPermission(options.permissions?.dm || null);
+        if (options.args && options?.args?.length > 0) {
+            this.addArguments(this.data, options.args);
+        }
+        if (options.subcommands && options?.subcommands?.length > 0) {
+            this.addSubcommands(this.data, options.subcommands);
+        }
+        if (options.groups && options?.groups?.length > 0) {
+            this.addSubcommandGroups(options.groups);
+        }
+        options = zod_1.z
+            .object({
+            name: zod_1.z.string(),
+            description: zod_1.z.string(),
+            usage: zod_1.z.string().or(zod_1.z.null()).default(null),
+            info: zod_1.z.string().or(zod_1.z.null()).default(null),
+            category: zod_1.z.string().or(zod_1.z.null()).default(null),
+            number: zod_1.z.number().or(zod_1.z.null()).default(null),
+            global: zod_1.z.boolean().default(true),
+            channel: zod_1.z
+                .array(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.enum([
+                'GuildText',
+                'DM',
+                'GuildVoice',
+                'GroupDM',
+                'GuildCategory',
+                'GuildAnnouncement',
+                'AnnouncementThread',
+                'PublicThread',
+                'PrivateThread',
+                'GuildStageVoice',
+                'GuildDirectory',
+                'GuildForum',
+                'GuildNews',
+                'GuildNewsThread',
+                'GuildPublicThread',
+                'GuildPrivateThread',
+            ]))
+                .or(zod_1.z.null())
+                .default(null),
+            ignore: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            strict: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+                voice: zod_1.z.boolean().default(false),
+            })
+                .default({}),
+            permissions: zod_1.z
+                .object({
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(true),
+            })
+                .default({}),
+            defer: zod_1.z
+                .object({
+                reply: zod_1.z.boolean().optional(),
+                ephemeral: zod_1.z.boolean().optional(),
+                fetch: zod_1.z.boolean().optional(),
+            })
+                .default({}),
+        })
+            .parse(options);
+        this.name = options.name;
+        this.description = options.description;
+        this.usage = options.usage;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.channel = options.channel ? (Array.isArray(options.channel) ? options.channel : [options.channel]) : null;
+        this.global = options.global;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = this.client;
+        this.util = this.util;
+    }
+    /**
+     * @description autocomplete let's you add choices to string option arguments
+     * @param interaction - The interaction event emitted on this command
+     * @param focused - The command option that is in focus
+     * @param options - The full list of options on the command
+     */
+    async autocomplete(interaction, focused, options) { }
+    /**
+     * @description Checks for conditions before running the command
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    async conditions(interaction, { args, subcommand, group }) { }
+    /**
+     * @description Runs the execution rule
+     * @param interaction - The interaction event emitted on this command
+     * @param options - The args, group and subcommand parsed on this command
+     */
+    async exec(interaction, { args, subcommand, group }) {
+        new XernerxLog_js_1.default(this.client).error(`${this.id} doesn't have an execution rule.`);
+        return await this.client.emit('commandError', interaction, `${this.id} doesn't have an execution rule.`, this, this.filetype);
+    }
+    addArguments(command, args) {
+        for (const argument of args) {
+            let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
+            command[`add${slashCommandArgumentType}Option`]((option) => {
+                option
+                    .setName(argument.name)
+                    .setDescription(argument.description)
+                    .setRequired(argument.required || false);
+                if (slashCommandArgumentType === 'String') {
+                    if (argument.choices)
+                        option.setChoices(...argument.choices.map((choices) => {
+                            return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
+                        }));
+                    option.setAutocomplete(argument.autocomplete || false);
+                }
+                return option;
+            });
+        }
+    }
+    addSubcommands(method, subcommands) {
+        for (const subcommand of subcommands) {
+            let sub = new discord_js_1.SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+            if (subcommand.args && subcommand?.args?.length > 0)
+                this.addArguments(sub, subcommand.args);
+            method.addSubcommand(sub);
+        }
+    }
+    addSubcommandGroups(groups) {
+        for (const group of groups) {
+            let subcommandGroup = new discord_js_1.SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+            if (group.subcommands?.length > 0)
+                this.addSubcommands(subcommandGroup, group.subcommands);
+            this.data.addSubcommandGroup(subcommandGroup);
+        }
+    }
+}
+exports.default = XernerxSlashCommand;

package/dist/cjs/client/XernerxClient.js

@@ -0,0 +1,105 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const zod_1 = require("zod");
+const CommandHandler_js_1 = __importDefault(require("../handlers/CommandHandler.js"));
+const EventHandler_js_1 = __importDefault(require("../handlers/EventHandler.js"));
+const InhibitorHandler_js_1 = __importDefault(require("../handlers/InhibitorHandler.js"));
+const IntegrationHandler_js_1 = __importDefault(require("../handlers/IntegrationHandler.js"));
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+const ClientUtil_js_1 = __importDefault(require("../utils/ClientUtil.js"));
+const ExtensionHandler_js_1 = __importDefault(require("../handlers/ExtensionHandler.js"));
+const deploy_js_1 = __importDefault(require("../functions/deploy.js"));
+const Cooldowns_js_1 = __importDefault(require("../models/Cooldowns.js"));
+class XernerxClient extends discord_js_1.Client {
+    constructor(discordOptions, xernerxOptions, config) {
+        super(discordOptions);
+        this.settings = zod_1.z
+            .object({
+            local: zod_1.z.string(),
+            global: zod_1.z.boolean().default(false).optional(),
+            ownerId: zod_1.z.string().or(zod_1.z.array(zod_1.z.string())).default([]),
+            ceaseless: zod_1.z.boolean().default(false),
+            permissions: zod_1.z
+                .object({
+                client: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                user: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+                dm: zod_1.z.boolean().default(false),
+            })
+                .optional(),
+            ignore: zod_1.z
+                .object({
+                owner: zod_1.z.boolean().default(false),
+                self: zod_1.z.boolean().default(true),
+                bots: zod_1.z.boolean().default(true),
+                system: zod_1.z.boolean().default(true),
+                users: zod_1.z.array(zod_1.z.string()).default([]),
+                channels: zod_1.z.array(zod_1.z.string()).default([]),
+                guilds: zod_1.z.array(zod_1.z.string()).default([]),
+            })
+                .optional(),
+            log: zod_1.z
+                .object({
+                ready: zod_1.z.boolean().default(false),
+                info: zod_1.z.boolean().default(false),
+                warn: zod_1.z.boolean().default(false),
+                error: zod_1.z.boolean().default(false),
+                table: zod_1.z.array(zod_1.z.string()).or(zod_1.z.null()).default(null),
+            })
+                .or(zod_1.z.boolean())
+                .optional(),
+            cooldown: zod_1.z
+                .object({
+                command: zod_1.z.number().default(0),
+                cache: zod_1.z.number().default(0),
+                collections: zod_1.z.array(zod_1.z.string()).default(['commands']),
+            })
+                .optional(),
+        })
+            .parse(xernerxOptions);
+        this.config = config || null;
+        this.commands = {
+            message: new discord_js_1.Collection(),
+            slash: new discord_js_1.Collection(),
+            context: new discord_js_1.Collection(),
+        };
+        this.events = new discord_js_1.Collection();
+        this.inhibitors = new discord_js_1.Collection();
+        this.util = new ClientUtil_js_1.default(this);
+        this.stats = {
+            guildCount: this.guilds.cache.size,
+            userCount: 0,
+            shardId: 0,
+            shardCount: this.options.shardCount || 1,
+            voteCount: 0,
+        };
+        this.dbl = {};
+        this.cache = {
+            messages: new discord_js_1.Collection(),
+            cooldowns: new discord_js_1.Collection(),
+        };
+        this.cooldowns = new Cooldowns_js_1.default(this, xernerxOptions.cooldown?.collections);
+        this.modules = {
+            options: {},
+            commandHandler: new CommandHandler_js_1.default(this),
+            eventHandler: new EventHandler_js_1.default(this),
+            inhibitorHandler: new InhibitorHandler_js_1.default(this),
+            integrationHandler: new IntegrationHandler_js_1.default(this),
+            extensionHandler: new ExtensionHandler_js_1.default(this),
+        };
+        return this;
+    }
+    async connect(token) {
+        const login = this.login(token);
+        (0, deploy_js_1.default)(this);
+        if (this.settings.ceaseless) {
+            process.on('unhandledRejection', (error) => {
+                new XernerxLog_js_1.default(this).error('An uncaught error happpened, this is triggered from the ceaseless setting.', error);
+            });
+        }
+        new XernerxLog_js_1.default(this).ready();
+        return login;
+    }
+}
+exports.default = XernerxClient;

package/dist/cjs/client/XernerxShardClient.js

@@ -0,0 +1,56 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+const dumfunctions_1 = require("dumfunctions");
+const XernerxLog_js_1 = __importDefault(require("../tools/XernerxLog.js"));
+class XernerxShardClient extends discord_js_1.ShardingManager {
+    constructor(file, discordOptions, xernerxOptions, data = {}) {
+        super(file, discordOptions);
+        this.stats = { guildCount: 0, userCount: 0, shardCount: 0, voteCount: 0, shards: {} };
+        this.user = null;
+        this.on('shardCreate', async (shard) => {
+            shard
+                .on('ready', async () => {
+                await new Promise((resolve) => setTimeout(resolve, 250));
+                const stats = (await shard.fetchClientValue('stats'));
+                this.stats.shards[String(shard.id)] = stats;
+                this.user = (await shard.fetchClientValue('user'));
+                this.stats.guildCount += stats.guildCount;
+                this.stats.userCount += stats.userCount;
+                this.stats.shardCount++;
+                this.stats.voteCount = stats.voteCount;
+                shard.send({ type: 'xernerx', data: { shardId: shard.id, sharded: true } });
+                shard.send({ type: 'client', data });
+                await new XernerxLog_js_1.default({ settings: xernerxOptions }).info(`Launched shard ${dumfunctions_1.Style.log(String(shard.id), { color: dumfunctions_1.Style.TextColor.Cyan })} for ${dumfunctions_1.Style.log(this.user?.tag, { color: dumfunctions_1.Style.TextColor.Blue })}! ${xernerxOptions?.timeout ? `Automatically killing in ${dumfunctions_1.Style.log(String(xernerxOptions.timeout), { color: dumfunctions_1.Style.TextColor.Cyan })}ms.` : ''}`);
+            })
+                .on('error', (error) => {
+                new XernerxLog_js_1.default({ settings: xernerxOptions }).info(`An error occurred in ${dumfunctions_1.Style.log(String(shard.id), { color: dumfunctions_1.Style.TextColor.Cyan })} for ${dumfunctions_1.Style.log(String(this.user?.tag), { color: dumfunctions_1.Style.TextColor.Blue })}! ${error}`);
+            });
+            if (xernerxOptions?.timeout)
+                setTimeout(() => {
+                    new XernerxLog_js_1.default({ settings: xernerxOptions }).warn(`Automatically killing shard ${dumfunctions_1.Style.log(String(shard.id), { color: dumfunctions_1.Style.TextColor.Cyan })} on ${dumfunctions_1.Style.log(String(shard.manager.user?.tag), {
+                        color: dumfunctions_1.Style.TextColor.Blue,
+                    })}!`);
+                    shard.kill();
+                }, xernerxOptions.timeout);
+        });
+        const spawn = this.spawn();
+        this.spawner = spawn;
+        spawn.then(async (shards) => {
+            const collector = setInterval(() => {
+                const index = shards.size - 1;
+                if (shards.get(index)?.ready) {
+                    clearInterval(collector);
+                    new XernerxLog_js_1.default({ settings: xernerxOptions }).info(`All Shards launched for ${dumfunctions_1.Style.log(String(this.user?.tag), {
+                        color: dumfunctions_1.Style.TextColor.Blue,
+                    })} with a total of ${dumfunctions_1.Style.log(String(this.stats.shardCount), { color: dumfunctions_1.Style.TextColor.Cyan })} shard${this.stats.shardCount > 1 ? 's' : ''}, watching ${dumfunctions_1.Style.log(String(this.stats.guildCount), {
+                        color: dumfunctions_1.Style.TextColor.Cyan,
+                    })} guild${this.stats.guildCount > 1 ? 's' : ''}, and ${dumfunctions_1.Style.log(String(this.stats.userCount), { color: dumfunctions_1.Style.TextColor.Cyan })} user${this.stats.userCount > 1 ? 's' : ''}!`);
+                }
+            }, 1000);
+        });
+        return this;
+    }
+}
+exports.default = XernerxShardClient;