xernerx 3.6.0 → 4.0.1

package/dist/build/ContextCommandBuilder.d.ts

@@ -0,0 +1,47 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessageContextInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
+import { ContextCommandOptions } from '../types/interfaces.js';
+export default class ContextCommandBuilder {
+    id: string;
+    data: ContextMenuCommandBuilder;
+    name: string;
+    type: 'message' | 'user';
+    description: string | null | undefined;
+    info: string | null | undefined;
+    category: string | null | undefined;
+    cooldown: number | null | undefined;
+    ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    permissions:
+        | {
+              user?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              client?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    defer:
+        | {
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetchReply?: boolean | undefined;
+          }
+        | undefined;
+    client: typeof XernerxClient;
+    constructor(id: string, options: ContextCommandOptions);
+    exec(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction): Promise<void>;
+}

package/dist/build/ContextCommandBuilder.js

@@ -0,0 +1,78 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+export default class ContextCommandBuilder {
+    id;
+    data;
+    name;
+    type;
+    description;
+    info;
+    category;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new 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 = z
+            .object({
+                name: z.string(),
+                type: z.enum(['user', 'message']),
+                description: z.string().or(z.null()).default(null),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                cooldown: z.number().or(z.null()).default(null),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetch: z.boolean().default(false),
+                    })
+                    .default({}),
+            })
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = XernerxClient;
+    }
+    async exec(interaction) {}
+}

package/dist/{cjs/build → build}/EventBuilder.d.ts

@@ -1,5 +1,6 @@
 import XernerxClient from '../client/XernerxClient.js';
-import { EventOptions } from '../types/options.js';
+import { EventBuilderOptions } from '../types/interfaces.js';
+import { EventType } from '../types/types.js';
 /**
  * @description - The event builder for  events.
  * @param {String} id - The unique ID of the event.
@@ -7,15 +8,15 @@ import { EventOptions } from '../types/options.js';
  */
 export default class EventBuilder {
     id: string;
-    name: string;
-    emitter: string;
-    type: string;
+    name: EventType;
+    emitter: 'client' | 'process' | string;
+    type: 'discord' | string;
     once: boolean;
     client: typeof XernerxClient;
-    constructor(id: string, options: EventOptions);
+    constructor(id: string, options: EventBuilderOptions);
     /**
      * @description run your custom event here.
      * TODO - update description
      */
-    run(): Promise<void>;
+    run<T extends Array<T>>(...args: T): Promise<void>;
 }

package/dist/build/EventBuilder.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+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 EventBuilder {
+    id;
+    name;
+    emitter;
+    type;
+    once;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            emitter: z.string().optional(),
+            type: z.string().optional(),
+            once: 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 = XernerxClient;
+    }
+    /**
+     * @description run your custom event here.
+     * TODO - update description
+     */
+    async run(...args) {}
+}

package/dist/build/InhibitorBuilder.d.ts

@@ -0,0 +1,17 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { InhibitorBuilderOptions } from '../types/interfaces.js';
+import { InhibitorType, XernerxInteraction } from '../types/types.js';
+import { XernerxMessage } from '../types/extenders.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 InhibitorBuilder {
+    id: string;
+    name: string;
+    type: InhibitorType;
+    client: typeof XernerxClient;
+    constructor(id: string, options: InhibitorBuilderOptions);
+    check(action: XernerxInteraction | XernerxMessage, args: any): Promise<void>;
+}

package/dist/build/InhibitorBuilder.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+// import { InhibitorOptions, MessageArgumentOptions, SlashArgumentOptions } 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 InhibitorBuilder {
+    id;
+    name;
+    type;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        z.object({
+            name: z.string(),
+            type: z.string(),
+        }).parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.client = XernerxClient;
+    }
+    async check(action, args) {}
+}

package/dist/build/MessageCommandBuilder.d.ts

@@ -0,0 +1,43 @@
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessage } from '../types/extenders.js';
+import { MessageCommandArguments, MessageCommandOptions } from '../types/interfaces.js';
+export default class MessageCommandBuilder {
+    id: string;
+    name: string;
+    regex: RegExp | undefined;
+    prefix: string | string[] | undefined;
+    description: string | null | undefined;
+    info: string | null | undefined;
+    separator: string | undefined;
+    args: import('../types/interfaces.js').MessageCommandArgumentOptions[] | undefined;
+    flags: import('../types/interfaces.js').MessageCommandFlagOptions[] | undefined;
+    category: string | null | undefined;
+    cooldown: number | null | undefined;
+    ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    permissions:
+        | {
+              user?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              client?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    client: typeof XernerxClient;
+    constructor(id: string, options: MessageCommandOptions);
+    conditions(message: XernerxMessage, args: MessageCommandArguments): Promise<void>;
+    exec(message: XernerxMessage, args: MessageCommandArguments): Promise<void>;
+}

package/dist/build/MessageCommandBuilder.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+export default class MessageCommandBuilder {
+    id;
+    name;
+    regex;
+    prefix;
+    description;
+    info;
+    separator;
+    args;
+    flags;
+    category;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.regex = options.regex;
+        this.args = options.args;
+        this.flags = options.flags;
+        options = z
+            .object({
+                name: z.string(),
+                description: z.string().or(z.null()).default(null),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                cooldown: z.number().or(z.null()).default(null),
+                prefix: z.array(z.string()).or(z.string()).default([]),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+            })
+            .parse(options);
+        this.name = options.name;
+        this.prefix = options.prefix;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.separator = options.separator;
+        this.permissions = options.permissions;
+        this.client = XernerxClient;
+    }
+    async conditions(message, args) {}
+    async exec(message, args) {}
+}

package/dist/{cjs/build → build}/SlashCommandBuilder.d.ts

@@ -1,21 +1,15 @@
-import * as Discord from 'discord.js';
-import { Interaction } from 'discord.js';
-import { SlashCommandOptions } from '../types/options.js';
+import Discord from 'discord.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.
- */
+import { XernerxSlashInteraction } from '../types/extenders.js';
+import { SlashCommandArguments, SlashCommandOptions } from '../types/interfaces.js';
 export default class SlashCommandBuilder {
     id: string;
     data: Discord.SlashCommandBuilder;
     name: string;
     description: string;
-    info: string | undefined;
-    category: string | undefined;
-    channelType: Discord.ChannelType | undefined;
-    cooldown: number | undefined;
+    info: string | null | undefined;
+    category: string | null | undefined;
+    cooldown: number | null | undefined;
     ignore:
         | {
               owner?: boolean | undefined;
@@ -32,14 +26,13 @@ export default class SlashCommandBuilder {
               guilds?: string[] | undefined;
           }
         | undefined;
-    permissions: {
-        client?: string[] | undefined;
-        users?: string[] | undefined;
-        dm?: boolean | undefined;
-    };
-    args?: object[];
-    subcommands?: object[];
-    groups?: object[];
+    permissions:
+        | {
+              user?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              client?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
     defer:
         | {
               reply?: boolean | undefined;
@@ -49,17 +42,9 @@ export default class SlashCommandBuilder {
         | undefined;
     client: typeof XernerxClient;
     constructor(id: string, options: SlashCommandOptions);
-    /**
-     * TODO - update description
-     * @param interaction
-     */
-    conditions(interaction: Interaction): Promise<void>;
-    /**
-     * TODO - update description
-     * @param interaction
-     */
-    exec(interaction: Interaction): Promise<void>;
-    private addArgs;
+    conditions(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
+    exec(interaction: XernerxSlashInteraction, args: SlashCommandArguments): Promise<void>;
+    private addArguments;
     private addSubcommands;
     private addSubcommandGroups;
 }

package/dist/build/SlashCommandBuilder.js

@@ -0,0 +1,122 @@
+import Discord, { SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from 'discord.js';
+import { z } from 'zod';
+import XernerxClient from '../client/XernerxClient.js';
+export default class SlashCommandBuilder {
+    id;
+    data;
+    name;
+    description;
+    info;
+    category;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    defer;
+    client;
+    constructor(id, options) {
+        this.id = id;
+        this.data = new Discord.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 = z
+            .object({
+                name: z.string(),
+                description: z.string(),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                number: z.number().or(z.null()).default(null),
+                channelType: z.array(z.number()).or(z.null()).default(null),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetch: z.boolean().default(false),
+                    })
+                    .default({}),
+            })
+            .parse(options);
+        this.name = options.name;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = XernerxClient;
+    }
+    async conditions(interaction, args) {}
+    async exec(interaction, args) {}
+    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 SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
+            if (subcommand.args?.length > 0) this.addArguments(sub, subcommand.args);
+            method.addSubcommand(sub);
+        }
+    }
+    addSubcommandGroups(groups) {
+        for (const group of groups) {
+            let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
+            if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
+            this.data.addSubcommandGroup(subcommandGroup);
+        }
+    }
+}

package/dist/build copy/ContextCommandBuilder.d.ts

@@ -0,0 +1,37 @@
+import { 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 ContextCommandBuilder {
+    id: string;
+    data: ContextMenuCommandBuilder;
+    name: any;
+    type: any;
+    description: any;
+    info: any;
+    category: any;
+    channelType: any;
+    cooldown: any;
+    ignore: any;
+    strict: any;
+    permissions: any;
+    defer: any;
+    client: typeof XernerxClient;
+    constructor(id: string, options: ContextCommandOptions);
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     * TODO - update description
+     */
+    conditions(interaction: Interaction, args: any): Promise<void>;
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     * TODO - update description
+     */
+    exec(interaction: Interaction, args: any): Promise<void>;
+}

package/dist/build copy/ContextCommandBuilder.js

@@ -0,0 +1,88 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import { z } from 'zod';
+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 ContextCommandBuilder {
+    id;
+    data;
+    name;
+    type;
+    description;
+    info;
+    category;
+    channelType;
+    cooldown;
+    ignore;
+    strict;
+    permissions;
+    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.permissions?.users) this.data.setDefaultMemberPermissions(options.permissions?.users);
+        if (options.permissions?.dm === false) this.data.setDMPermission(options.permissions?.dm);
+        if (options.nameLocalizations) this.data.setNameLocalizations(options.nameLocalizations);
+        z.object({
+            description: z.string(),
+            info: z.string(),
+            category: z.string(),
+            channelType: z.array(z.number()).or(z.number()),
+            cooldown: z.number(),
+            ignore: z.object({
+                owner: z.boolean(),
+                users: z.array(z.string()),
+                channels: z.array(z.string()),
+                guilds: z.array(z.string()),
+            }),
+            strict: z.object({
+                owner: z.boolean(),
+                users: z.array(z.string()),
+                channels: z.array(z.string()),
+                guilds: z.array(z.string()),
+            }),
+            permissions: z.object({
+                client: z.array(z.string()),
+                users: z.array(z.string()),
+                dm: z.boolean(),
+            }),
+            defer: z.object({
+                reply: z.boolean(),
+                ephemeral: z.boolean(),
+                fetch: z.boolean(),
+            }),
+        })
+            .deepPartial()
+            .parse(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.description = options.description;
+        this.info = options.info;
+        this.category = options.category;
+        this.channelType = options.channelType;
+        this.cooldown = options.cooldown;
+        this.ignore = options.ignore;
+        this.strict = options.strict;
+        this.permissions = options.permissions;
+        this.defer = options.defer;
+        this.client = XernerxClient;
+    }
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description make any preconditions here.
+     * TODO - update description
+     */
+    async conditions(interaction, args) {}
+    /**
+     * @param {Interaction} interaction - The Discord interaction event data.
+     * @description Make your custom command here.
+     * TODO - update description
+     */
+    async exec(interaction, args) {}
+}