reciple 9.9.0 → 10.0.1-dev.0

package/dist/classes/client/ModuleLoader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleLoader.mjs","names":["client: Client","modules: AnyModule[]","path","scanned: string[]","directories: string[]","modules: string[]","globby: typeof import('globby')|null","globby"],"sources":["../../../src/classes/client/ModuleLoader.ts"],"sourcesContent":["import { type Awaitable } from 'discord.js';\nimport path from 'node:path';\nimport { mkdir, readdir, stat } from 'node:fs/promises';\nimport micromatch from 'micromatch';\nimport { globby, isDynamicPattern } from 'globby';\nimport { CommandType, RecipleError, type Client } from '@reciple/core';\nimport type { AnyModule, AnyModuleData } from '../../helpers/types.js';\nimport { colors, recursiveDefaults } from '@reciple/utils';\nimport { BaseModule } from '../modules/BaseModule.js';\nimport { BaseModuleValidator } from '../validation/BaseModuleValidator.js';\nimport { ModuleType } from '../../helpers/constants.js';\nimport { PostconditionModule } from '../modules/PostconditionModule.js';\nimport { PreconditionModule } from '../modules/PreconditionModule.js';\nimport { EventModule } from '../modules/events/EventModule.js';\nimport { MessageCommandModule } from '../modules/commands/MessageCommandModule.js';\nimport { SlashCommandModule } from '../modules/commands/SlashCommandModule.js';\nimport { ContextMenuCommandModule } from '../modules/commands/ContextMenuCommandModule.js';\nimport { CommandModuleValidator } from '../validation/CommandModuleValidator.js';\nimport { EventModuleValidator } from '../validation/EventModuleValidator.js';\nimport { PreconditionModuleValidator } from '../validation/PreconditionModule.js';\nimport { PostconditionModuleValidator } from '../validation/PostconditionModule.js';\nimport type { Logger } from 'prtyprnt';\nimport { EventEmitter } from 'node:events';\n\nexport class ModuleLoader extends EventEmitter<ModuleLoader.Events> {\n    public readonly logger: Logger;\n\n    constructor(public readonly client: Client) {\n        super();\n\n        this.logger = this.client.logger.clone({\n            label: 'ModuleLoader'\n        });\n    }\n\n    public async findModules(ignoreErrors: boolean = false): Promise<AnyModule[]> {\n        const modulePaths = await ModuleLoader.scanForModules(this.client.config?.modules);\n        const modules: AnyModule[] = [];\n\n        this.emit('modulesResolving', modulePaths);\n\n        for (const path of modulePaths) {\n            try {\n                this.emit('moduleResolving', path);\n                const resolved = await ModuleLoader.resolveModulePath(path);\n\n                Object.assign(resolved, { client: this.client, __$filepath: path });\n                modules.push(resolved);\n\n                this.emit('moduleResolved', resolved);\n            } catch (error) {\n                if (ignoreErrors) continue;\n\n                this.emitOrThrow('moduleResolveError', new RecipleError({\n                    message: `Failed to load module: ${colors.cyan(path)}`,\n                    cause: error\n                }));\n            }\n        }\n\n        this.emit('modulesResolved', modules);\n        return modules;\n    }\n\n    public static async scanForDirectories(config?: Pick<ModuleLoader.Config, 'directories'|'ignore'> & { cwd?: string; createDirectories?: boolean; }) {\n        const cwd = config?.cwd ?? process.cwd();\n\n        let scanned: string[] = [];\n        let directories: string[] = [];\n\n        for (const directory of config?.directories ?? []) {\n            if (isDynamicPattern(directory, { cwd })) {\n                const matches = await globby(directory, {\n                    cwd,\n                    ignore: config?.ignore,\n                    onlyDirectories: true,\n                    baseNameMatch: true,\n                    absolute: true\n                });\n\n                scanned.push(...matches);\n                continue;\n            }\n\n            scanned.push(path.join(cwd, directory));\n        }\n\n        for (const directory of scanned) {\n            const stats = await stat(directory).catch(() => undefined);\n\n            if (!stats && config?.createDirectories !== false) {\n                await mkdir(directory, { recursive: true });\n            }\n\n            directories.push(directory);\n        }\n\n        return directories;\n    }\n\n    public static async scanForModules(config?: ModuleLoader.Config & { cwd?: string; createDirectories?: boolean; }): Promise<string[]> {\n        const directories = await ModuleLoader.scanForDirectories(config);\n\n        let modules: string[] = [];\n\n        for (const directory of directories) {\n            let files = await readdir(directory);\n\n            if (config?.ignore?.length) {\n                files = micromatch.not(files, config.ignore, {\n                    cwd: directory,\n                    matchBase: true,\n                    dot: true\n                });\n            }\n\n            files = files.map(f => path.join(directory, f));\n\n            for (const file of files) {\n                if (config?.filter ? !(await config?.filter(file)) : ModuleLoader.fileTypes.every(type => !file.endsWith(`.${type}`))) continue;\n                modules.push(file);\n            }\n        }\n\n        if (config?.sort) modules.sort(config.sort);\n\n        return modules;\n    }\n\n    public static async resolveModulePath(filepath: string, options?: { cwd?: string; }): Promise<AnyModule> {\n        const stats = await stat(filepath).catch(() => undefined);\n        if (!stats) throw new RecipleError(`Module not found: ${filepath}`);\n\n        const data = recursiveDefaults<AnyModule|AnyModuleData|undefined>(await import(`file://${path.resolve(options?.cwd ?? process.cwd(), filepath)}`));\n        if (BaseModule.isModule(data)) return data;\n\n        switch (data?.moduleType) {\n            case ModuleType.Command:\n                CommandModuleValidator.isValid(data);\n                switch (data.type) {\n                    case CommandType.Message: return MessageCommandModule.from(data);\n                    case CommandType.Slash: return SlashCommandModule.from(data);\n                    case CommandType.ContextMenu: return ContextMenuCommandModule.from(data);\n                    default: throw new RecipleError(`Unknown command type from module: ${colors.cyan(filepath)}`);\n                }\n            case ModuleType.Event:\n                EventModuleValidator.isValid(data);\n                return EventModule.from(data);\n            case ModuleType.Precondition:\n                PreconditionModuleValidator.isValid(data);\n                return PreconditionModule.from(data);\n            case ModuleType.Postcondition:\n                PostconditionModuleValidator.isValid(data);\n                return PostconditionModule.from(data);\n            case ModuleType.Base:\n            default:\n                BaseModuleValidator.isValid(data);\n                return BaseModule.from(data);\n        }\n    }\n\n    public static async resolveSourceDirectories(options: ModuleLoader.ResolveSourceDirectoryOptions): Promise<string[]> {\n        const dir = path.isAbsolute(options.baseUrl) ? options.baseUrl : path.resolve(path.join(options.cwd ?? process.cwd(), options.baseUrl));\n\n        const root = path.resolve(path.join(dir, options.rootDir));\n        const out = path.resolve(path.join(dir, options.outDir));\n\n        return options.directories.map(directory => path.resolve(directory).replace(out, root));\n    }\n\n    private emitOrThrow<K extends keyof Pick<ModuleLoader.Events, 'moduleResolveError'>>(event: K, error: RecipleError) {\n        if (this.client.listenerCount(event) > 0) {\n            // @ts-expect-error\n            return this.emit(event, error);\n        }\n\n        throw error;\n    }\n}\n\nexport namespace ModuleLoader {\n    export let globby: typeof import('globby')|null = null;\n\n    export const fileTypes = [\n        'js',\n        'mjs',\n        'jsx'\n    ];\n\n    export interface Config {\n        directories?: string[];\n        ignore?: string[];\n        filter?: (filepath: string) => Awaitable<boolean>;\n        sort?: (a: string, b: string) => number;\n    }\n\n    export interface Events {\n        moduleResolveError: [error: RecipleError];\n        moduleResolved: [module: AnyModule];\n        moduleResolving: [filepath: string];\n        modulesResolved: [modules: AnyModule[]];\n        modulesResolving: [files: string[]];\n    }\n\n    export interface ResolveSourceDirectoryOptions {\n        directories: string[];\n        baseUrl: string;\n        rootDir: string;\n        outDir: string;\n        cwd?: string;\n    }\n\n    export async function getGlobby(): Promise<typeof import('globby')> {\n        if (globby) return globby;\n\n        return globby = await import('globby');\n    }\n}\n"],"mappings":"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"}

package/dist/classes/managers/ModuleManager.d.mts

@@ -0,0 +1,55 @@
+import { BaseModule } from "../modules/BaseModule.mjs";
+import { AnyModule } from "../../helpers/types.mjs";
+import { BaseManager, Client } from "@reciple/core";
+import { EventEmitter } from "node:events";
+
+//#region src/classes/managers/ModuleManager.d.ts
+interface ModuleManager extends BaseManager<string, AnyModule, BaseModule.Resolvable>, EventEmitter<ModuleManager.Events> {}
+declare class ModuleManager {
+  readonly client: Client;
+  readonly holds: typeof BaseModule;
+  constructor(client: Client);
+  enableModules({
+    modules,
+    removeFromCacheOnError
+  }?: ModuleManager.EventExecuteData & {
+    removeFromCacheOnError?: boolean;
+  }): Promise<AnyModule[]>;
+  readyModules({
+    modules,
+    removeFromCacheOnError
+  }?: ModuleManager.EventExecuteData & {
+    removeFromCacheOnError?: boolean;
+  }): Promise<AnyModule[]>;
+  disableModules({
+    modules,
+    removeFromCache
+  }?: ModuleManager.EventExecuteData & {
+    removeFromCache?: boolean;
+  }): Promise<AnyModule[]>;
+  add(module: AnyModule): void;
+  remove(module: AnyModule): void;
+  private emitOrThrow;
+}
+declare namespace ModuleManager {
+  interface Events {
+    modulePreEnable: [module: AnyModule];
+    moduleEnable: [module: AnyModule];
+    moduleEnableError: [module: AnyModule, error: Error];
+    enabledModules: [modules: AnyModule[]];
+    modulePreReady: [module: AnyModule];
+    moduleReady: [module: AnyModule];
+    moduleReadyError: [module: AnyModule, error: Error];
+    readyModules: [modules: AnyModule[]];
+    modulePreDisable: [module: AnyModule];
+    moduleDisable: [module: AnyModule];
+    moduleDisableError: [module: AnyModule, error: Error];
+    disabledModules: [modules: AnyModule[]];
+  }
+  interface EventExecuteData {
+    modules?: AnyModule[];
+  }
+}
+//#endregion
+export { ModuleManager };
+//# sourceMappingURL=ModuleManager.d.mts.map

package/dist/classes/managers/ModuleManager.mjs

@@ -0,0 +1,107 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "../modules/BaseModule.mjs";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { BaseManager, RecipleError } from "@reciple/core";
+import { mix } from "ts-mixer";
+import { EventEmitter } from "node:events";
+
+//#region src/classes/managers/ModuleManager.ts
+let ModuleManager = class ModuleManager$1 {
+	holds = BaseModule;
+	constructor(client) {
+		this.client = client;
+	}
+	async enableModules({ modules, removeFromCacheOnError } = { modules: Array.from(this.cache.values()) }) {
+		const enabledModules = [];
+		for (const module of modules ?? []) {
+			this.emit("modulePreEnable", module);
+			await module.onEnable({ client: this.client }).catch((e) => {
+				if (removeFromCacheOnError) this.cache.delete(module.id);
+				this.emitOrThrow("moduleEnableError", module, e);
+			});
+			this.emit("moduleEnable", module);
+			this.add(module);
+			enabledModules.push(module);
+		}
+		this.emit("enabledModules", enabledModules);
+		return enabledModules;
+	}
+	async readyModules({ modules, removeFromCacheOnError } = { modules: Array.from(this.cache.values()) }) {
+		const readyModules = [];
+		if (!this.client.isReady()) throw new RecipleError(RecipleError.Code.ClientNotReady());
+		for (const module of modules ?? []) {
+			this.emit("modulePreReady", module);
+			await module.onReady({ client: this.client }).catch((e) => {
+				if (removeFromCacheOnError !== false) this.remove(module);
+				this.emitOrThrow("moduleReadyError", module, e);
+			});
+			this.emit("moduleReady", module);
+			this.cache.set(module.id, module);
+			readyModules.push(module);
+		}
+		this.emit("readyModules", readyModules);
+		return readyModules;
+	}
+	async disableModules({ modules, removeFromCache } = { modules: Array.from(this.cache.values()) }) {
+		const disabledModules = [];
+		for (const module of modules ?? []) {
+			this.emit("modulePreDisable", module);
+			await module.onDisable({ client: this.client }).catch((e) => {
+				if (removeFromCache !== false) this.remove(module);
+				this.emitOrThrow("moduleDisableError", module, e);
+			});
+			this.emit("moduleDisable", module);
+			if (removeFromCache !== false) this.remove(module);
+			disabledModules.push(module);
+		}
+		this.emit("disabledModules", disabledModules);
+		return disabledModules;
+	}
+	add(module) {
+		this.cache.set(module.id, module);
+		switch (module.moduleType) {
+			case ModuleType.Command:
+				this.client.commands?.add(module);
+				break;
+			case ModuleType.Event:
+				this.client.eventListeners.register(module);
+				break;
+			case ModuleType.Precondition:
+				this.client.preconditions?.cache.set(module.id, module);
+				break;
+			case ModuleType.Postcondition:
+				this.client.postconditions?.cache.set(module.id, module);
+				break;
+			case ModuleType.Base:
+			default: break;
+		}
+	}
+	remove(module) {
+		this.cache.delete(module.id);
+		switch (module.moduleType) {
+			case ModuleType.Command:
+				this.client.commands?.cache.delete(module.id);
+				break;
+			case ModuleType.Event:
+				this.client.eventListeners.unregister(module);
+				break;
+			case ModuleType.Precondition:
+				this.client.preconditions?.cache.delete(module.id);
+				break;
+			case ModuleType.Postcondition:
+				this.client.postconditions?.cache.delete(module.id);
+				break;
+			case ModuleType.Base:
+			default: break;
+		}
+	}
+	emitOrThrow(event, ...args) {
+		if (this.client.listenerCount(event) > 0) return this.emit(event, ...args);
+		throw args[1];
+	}
+};
+ModuleManager = __decorate([mix(BaseManager, EventEmitter)], ModuleManager);
+
+//#endregion
+export { ModuleManager };
+//# sourceMappingURL=ModuleManager.mjs.map

package/dist/classes/managers/ModuleManager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleManager.mjs","names":["ModuleManager","client: Client","enabledModules: AnyModule[]","readyModules: AnyModule[]","disabledModules: AnyModule[]"],"sources":["../../../src/classes/managers/ModuleManager.ts"],"sourcesContent":["import { mix } from 'ts-mixer';\nimport { BaseModule } from '../modules/BaseModule.js';\nimport { BaseManager, RecipleError, type Client } from '@reciple/core';\nimport { EventEmitter } from 'node:events';\nimport type { AnyModule } from '../../helpers/types.js';\nimport { ModuleType } from '../../helpers/constants.js';\n\nexport interface ModuleManager extends BaseManager<string, AnyModule, BaseModule.Resolvable>, EventEmitter<ModuleManager.Events> {}\n\n@mix(BaseManager, EventEmitter)\nexport class ModuleManager {\n    public readonly holds = BaseModule;\n\n    constructor(public readonly client: Client) {}\n\n    public async enableModules({ modules, removeFromCacheOnError }: ModuleManager.EventExecuteData & { removeFromCacheOnError?: boolean; } = { modules: Array.from(this.cache.values()) }): Promise<AnyModule[]> {\n        const enabledModules: AnyModule[] = [];\n\n        for (const module of modules ?? []) {\n            this.emit('modulePreEnable', module);\n\n            await module.onEnable({ client: this.client }).catch(e => {\n                if (removeFromCacheOnError) this.cache.delete(module.id);\n                this.emitOrThrow('moduleEnableError', module, e);\n            });\n\n            this.emit('moduleEnable', module);\n            this.add(module);\n            enabledModules.push(module);\n        }\n\n        this.emit('enabledModules', enabledModules);\n        return enabledModules;\n    }\n\n    public async readyModules({ modules, removeFromCacheOnError }: ModuleManager.EventExecuteData & { removeFromCacheOnError?: boolean; } = { modules: Array.from(this.cache.values()) }): Promise<AnyModule[]> {\n        const readyModules: AnyModule[] = [];\n\n        if (!this.client.isReady()) throw new RecipleError(RecipleError.Code.ClientNotReady());\n\n        for (const module of modules ?? []) {\n            this.emit('modulePreReady', module);\n\n            await module.onReady({ client: this.client }).catch(e => {\n                if (removeFromCacheOnError !== false) this.remove(module);\n                this.emitOrThrow('moduleReadyError', module, e);\n            });\n\n            this.emit('moduleReady', module);\n            this.cache.set(module.id, module);\n            readyModules.push(module);\n        }\n\n        this.emit('readyModules', readyModules);\n        return readyModules;\n    }\n\n    public async disableModules({ modules, removeFromCache }: ModuleManager.EventExecuteData & { removeFromCache?: boolean; } = { modules: Array.from(this.cache.values()) }): Promise<AnyModule[]> {\n        const disabledModules: AnyModule[] = [];\n\n        for (const module of modules ?? []) {\n            this.emit('modulePreDisable', module);\n\n            await module.onDisable({ client: this.client }).catch(e => {\n                if (removeFromCache !== false) this.remove(module);\n                this.emitOrThrow('moduleDisableError', module, e);\n            });\n\n            this.emit('moduleDisable', module);\n            if (removeFromCache !== false) this.remove(module);\n            disabledModules.push(module);\n        }\n\n        this.emit('disabledModules', disabledModules);\n        return disabledModules;\n    }\n\n    public add(module: AnyModule): void {\n        this.cache.set(module.id, module);\n        switch (module.moduleType) {\n            case ModuleType.Command:\n                this.client.commands?.add(module);\n                break;\n            case ModuleType.Event:\n                this.client.eventListeners.register(module);\n                break;\n            case ModuleType.Precondition:\n                this.client.preconditions?.cache.set(module.id, module);\n                break;\n            case ModuleType.Postcondition:\n                this.client.postconditions?.cache.set(module.id, module);\n                break;\n            case ModuleType.Base:\n            default:\n                break;\n        }\n    }\n\n    public remove(module: AnyModule): void {\n        this.cache.delete(module.id);\n        switch (module.moduleType) {\n            case ModuleType.Command:\n                this.client.commands?.cache.delete(module.id);\n                break;\n            case ModuleType.Event:\n                this.client.eventListeners.unregister(module);\n                break;\n            case ModuleType.Precondition:\n                this.client.preconditions?.cache.delete(module.id);\n                break;\n            case ModuleType.Postcondition:\n                this.client.postconditions?.cache.delete(module.id);\n                break;\n            case ModuleType.Base:\n            default:\n                break;\n        }\n    }\n\n    private emitOrThrow<K extends keyof Pick<ModuleManager.Events, 'moduleDisableError'|'moduleEnableError'|'moduleReadyError'>>(event: K, ...args: ModuleManager.Events[K]) {\n        if (this.client.listenerCount(event) > 0) {\n            return this.emit(event, ...(args as never));\n        }\n\n        throw args[1];\n    }\n}\n\nexport namespace ModuleManager {\n    export interface Events {\n        modulePreEnable: [module: AnyModule];\n        moduleEnable: [module: AnyModule];\n        moduleEnableError: [module: AnyModule, error: Error];\n        enabledModules: [modules: AnyModule[]];\n\n        modulePreReady: [module: AnyModule];\n        moduleReady: [module: AnyModule];\n        moduleReadyError: [module: AnyModule, error: Error];\n        readyModules: [modules: AnyModule[]];\n\n        modulePreDisable: [module: AnyModule];\n        moduleDisable: [module: AnyModule];\n        moduleDisableError: [module: AnyModule, error: Error];\n        disabledModules: [modules: AnyModule[]];\n    }\n\n    export interface EventExecuteData {\n        modules?: AnyModule[];\n    }\n}\n"],"mappings":"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"}

package/dist/classes/modules/BaseModule.d.mts

@@ -0,0 +1,34 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { AnyModule } from "../../helpers/types.mjs";
+import { Client } from "@reciple/core";
+
+//#region src/classes/modules/BaseModule.d.ts
+declare class BaseModule implements BaseModule.Data {
+  private readonly __$filepath;
+  readonly id: string;
+  readonly moduleType: ModuleType.Base;
+  client: Client;
+  onEnable(data: BaseModule.EventData<boolean>): Promise<void>;
+  onReady(data: BaseModule.EventData<true>): Promise<void>;
+  onDisable(data: BaseModule.EventData<boolean>): Promise<void>;
+  static isModule(data: unknown): data is AnyModule;
+  static from(data: BaseModule.Resolvable): BaseModule;
+  static getFilepath(module: AnyModule): string;
+}
+declare namespace BaseModule {
+  type Resolvable = BaseModule | Data;
+  const constructor: typeof BaseModule;
+  interface Data {
+    id?: string;
+    moduleType?: ModuleType.Base;
+    onEnable?(data: BaseModule.EventData<false>): Promise<void>;
+    onReady?(data: BaseModule.EventData<true>): Promise<void>;
+    onDisable?(data: BaseModule.EventData<boolean>): Promise<void>;
+  }
+  interface EventData<Ready extends boolean = boolean> {
+    client: Client<Ready>;
+  }
+}
+//#endregion
+export { BaseModule };
+//# sourceMappingURL=BaseModule.d.mts.map

package/dist/classes/modules/BaseModule.mjs

@@ -0,0 +1,33 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { DiscordSnowflake } from "@sapphire/snowflake";
+import { hasMixin } from "ts-mixer";
+
+//#region src/classes/modules/BaseModule.ts
+var BaseModule = class BaseModule {
+	__$filepath = "";
+	id = DiscordSnowflake.generate().toString();
+	moduleType = ModuleType.Base;
+	client;
+	async onEnable(data) {}
+	async onReady(data) {}
+	async onDisable(data) {}
+	static isModule(data) {
+		return data instanceof BaseModule || hasMixin(data, BaseModule);
+	}
+	static from(data) {
+		if (data instanceof BaseModule || hasMixin(data, BaseModule)) return data;
+		const ModuleInstance = class extends BaseModule {};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+	static getFilepath(module) {
+		return module.__$filepath || "";
+	}
+};
+(function(_BaseModule) {
+	_BaseModule.constructor = BaseModule;
+})(BaseModule || (BaseModule = {}));
+
+//#endregion
+export { BaseModule };
+//# sourceMappingURL=BaseModule.mjs.map

package/dist/classes/modules/BaseModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseModule.mjs","names":[],"sources":["../../../src/classes/modules/BaseModule.ts"],"sourcesContent":["import type { Client } from '@reciple/core';\nimport { DiscordSnowflake } from '@sapphire/snowflake';\nimport { ModuleType } from '../../helpers/constants.js';\nimport { hasMixin } from 'ts-mixer';\nimport type { AnyModule } from '../../helpers/types.js';\n\nexport class BaseModule implements BaseModule.Data {\n    private readonly __$filepath: string = '';\n\n    public readonly id: string = DiscordSnowflake.generate().toString();\n    public readonly moduleType: ModuleType.Base = ModuleType.Base;\n\n    public client!: Client;\n\n    public async onEnable(data: BaseModule.EventData<boolean>): Promise<void> {}\n\n    public async onReady(data: BaseModule.EventData<true>): Promise<void> {}\n\n    public async onDisable(data: BaseModule.EventData<boolean>): Promise<void> {}\n\n    public static isModule(data: unknown): data is AnyModule {\n        return data instanceof BaseModule || hasMixin(data, BaseModule);\n    }\n\n    public static from(data: BaseModule.Resolvable): BaseModule {\n        if (data instanceof BaseModule || hasMixin(data, BaseModule)) return data;\n\n        const ModuleInstance = class extends BaseModule {};\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n\n    public static getFilepath(module: AnyModule): string {\n        return (module as BaseModule).__$filepath || '';\n    }\n}\n\nexport namespace BaseModule {\n    export type Resolvable = BaseModule|Data;\n\n    export const constructor = BaseModule;\n\n    export interface Data {\n        id?: string;\n        moduleType?: ModuleType.Base;\n        onEnable?(data: BaseModule.EventData<false>): Promise<void>;\n        onReady?(data: BaseModule.EventData<true>): Promise<void>;\n        onDisable?(data: BaseModule.EventData<boolean>): Promise<void>;\n    }\n\n    export interface EventData<Ready extends boolean = boolean> {\n        client: Client<Ready>;\n    }\n}\n"],"mappings":";;;;;AAMA,IAAa,aAAb,MAAa,WAAsC;CAC/C,AAAiB,cAAsB;CAEvC,AAAgB,KAAa,iBAAiB,UAAU,CAAC,UAAU;CACnE,AAAgB,aAA8B,WAAW;CAEzD,AAAO;CAEP,MAAa,SAAS,MAAoD;CAE1E,MAAa,QAAQ,MAAiD;CAEtE,MAAa,UAAU,MAAoD;CAE3E,OAAc,SAAS,MAAkC;AACrD,SAAO,gBAAgB,cAAc,SAAS,MAAM,WAAW;;CAGnE,OAAc,KAAK,MAAyC;AACxD,MAAI,gBAAgB,cAAc,SAAS,MAAM,WAAW,CAAE,QAAO;EAErE,MAAM,iBAAiB,cAAc,WAAW;AAChD,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;CAG/B,OAAc,YAAY,QAA2B;AACjD,SAAQ,OAAsB,eAAe;;;;2BAOtB"}

package/dist/classes/modules/PostconditionModule.d.mts

@@ -0,0 +1,20 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "./BaseModule.mjs";
+import { CommandPostcondition, CommandPrecondition, CommandType } from "@reciple/core";
+
+//#region src/classes/modules/PostconditionModule.d.ts
+interface PostconditionModule<D = any> extends Omit<BaseModule, 'moduleType'>, CommandPostcondition<D> {}
+declare abstract class PostconditionModule<D = any> implements PostconditionModule<D> {
+  moduleType: ModuleType.Postcondition;
+  abstract execute<T extends CommandType>(data: CommandPostcondition.ExecuteData<T>, preconditionTrigger?: CommandPrecondition.ResultData<T, any>): Promise<CommandPostcondition.ResultDataResolvable<T, D>>;
+  static from<D = any>(data: PostconditionModule.Resolvable<D>): PostconditionModule<D>;
+}
+declare namespace PostconditionModule {
+  type Resolvable<D = any> = PostconditionModule<D> | PostconditionModule.Data<D>;
+  interface Data<D = any> extends Omit<BaseModule.Data, 'moduleType'>, Omit<CommandPostcondition.Data<D>, 'id'> {
+    moduleType: ModuleType.Postcondition;
+  }
+}
+//#endregion
+export { PostconditionModule };
+//# sourceMappingURL=PostconditionModule.d.mts.map

package/dist/classes/modules/PostconditionModule.mjs

@@ -0,0 +1,24 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "./BaseModule.mjs";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { CommandPostcondition } from "@reciple/core";
+import { hasMixin, mix } from "ts-mixer";
+
+//#region src/classes/modules/PostconditionModule.ts
+var _PostconditionModule;
+let PostconditionModule = _PostconditionModule = class PostconditionModule$1 {
+	moduleType = ModuleType.Postcondition;
+	static from(data) {
+		if (data instanceof _PostconditionModule || hasMixin(data, _PostconditionModule)) return data;
+		const ModuleInstance = class extends _PostconditionModule {
+			execute = data.execute;
+		};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+};
+PostconditionModule = _PostconditionModule = __decorate([mix(BaseModule, CommandPostcondition)], PostconditionModule);
+
+//#endregion
+export { PostconditionModule };
+//# sourceMappingURL=PostconditionModule.mjs.map

package/dist/classes/modules/PostconditionModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostconditionModule.mjs","names":["PostconditionModule"],"sources":["../../../src/classes/modules/PostconditionModule.ts"],"sourcesContent":["import { CommandPostcondition, type CommandPrecondition, type CommandType } from '@reciple/core';\nimport { BaseModule } from './BaseModule.js';\nimport { hasMixin, mix } from 'ts-mixer';\nimport { ModuleType } from '../../helpers/constants.js';\n\nexport interface PostconditionModule<D = any> extends Omit<BaseModule, 'moduleType'>, CommandPostcondition<D> {}\n\n@mix(BaseModule, CommandPostcondition)\nexport abstract class PostconditionModule<D = any> implements PostconditionModule<D> {\n    public moduleType: ModuleType.Postcondition = ModuleType.Postcondition;\n\n    public abstract execute<T extends CommandType>(data: CommandPostcondition.ExecuteData<T>, preconditionTrigger?: CommandPrecondition.ResultData<T, any>): Promise<CommandPostcondition.ResultDataResolvable<T, D>>;\n\n    public static from<D = any>(data: PostconditionModule.Resolvable<D>): PostconditionModule<D> {\n        if (data instanceof PostconditionModule || hasMixin(data, PostconditionModule)) return data;\n\n        const ModuleInstance = class extends PostconditionModule { execute = data.execute; };\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n}\n\nexport namespace PostconditionModule {\n    export type Resolvable<D = any> = PostconditionModule<D>|PostconditionModule.Data<D>;\n\n    export interface Data<D = any> extends Omit<BaseModule.Data, 'moduleType'>, Omit<CommandPostcondition.Data<D>, 'id'> {\n        moduleType: ModuleType.Postcondition;\n    }\n}\n"],"mappings":";;;;;;;;AAQO,uDAAeA,sBAA+D;CACjF,AAAO,aAAuC,WAAW;CAIzD,OAAc,KAAc,MAAiE;AACzF,MAAI,wCAAuC,SAAS,2BAA0B,CAAE,QAAO;EAEvF,MAAM,iBAAiB,mCAAkC;GAAE,UAAU,KAAK;;AAC1E,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;;yDAXlC,IAAI,YAAY,qBAAqB"}

package/dist/classes/modules/PreconditionModule.d.mts

@@ -0,0 +1,20 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "./BaseModule.mjs";
+import { AnyCommandExecuteData, CommandPrecondition, CommandType } from "@reciple/core";
+
+//#region src/classes/modules/PreconditionModule.d.ts
+interface PreconditionModule<D = any> extends Omit<BaseModule, 'moduleType'>, CommandPrecondition<D> {}
+declare abstract class PreconditionModule<D = any> implements PreconditionModule<D> {
+  moduleType: ModuleType.Precondition;
+  abstract execute<T extends CommandType>(data: AnyCommandExecuteData<T>): Promise<CommandPrecondition.ResultDataResolvable<T, D>>;
+  static from<D>(data: PreconditionModule.Resolvable<D>): PreconditionModule<D>;
+}
+declare namespace PreconditionModule {
+  type Resolvable<D = any> = PreconditionModule<D> | PreconditionModule.Data<D>;
+  interface Data<D = any> extends Omit<BaseModule.Data, 'moduleType'>, Omit<CommandPrecondition.Data<D>, 'id'> {
+    moduleType: ModuleType.Precondition;
+  }
+}
+//#endregion
+export { PreconditionModule };
+//# sourceMappingURL=PreconditionModule.d.mts.map

package/dist/classes/modules/PreconditionModule.mjs

@@ -0,0 +1,24 @@
+import { ModuleType } from "../../helpers/constants.mjs";
+import { BaseModule } from "./BaseModule.mjs";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { CommandPrecondition } from "@reciple/core";
+import { hasMixin, mix } from "ts-mixer";
+
+//#region src/classes/modules/PreconditionModule.ts
+var _PreconditionModule;
+let PreconditionModule = _PreconditionModule = class PreconditionModule$1 {
+	moduleType = ModuleType.Precondition;
+	static from(data) {
+		if (data instanceof _PreconditionModule || hasMixin(data, _PreconditionModule)) return data;
+		const ModuleInstance = class extends _PreconditionModule {
+			execute = data.execute;
+		};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+};
+PreconditionModule = _PreconditionModule = __decorate([mix(BaseModule, CommandPrecondition)], PreconditionModule);
+
+//#endregion
+export { PreconditionModule };
+//# sourceMappingURL=PreconditionModule.mjs.map

package/dist/classes/modules/PreconditionModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreconditionModule.mjs","names":["PreconditionModule"],"sources":["../../../src/classes/modules/PreconditionModule.ts"],"sourcesContent":["import { CommandPrecondition, type AnyCommandExecuteData, type CommandType } from '@reciple/core';\nimport { BaseModule } from './BaseModule.js';\nimport { hasMixin, mix } from 'ts-mixer';\nimport { ModuleType } from '../../helpers/constants.js';\n\nexport interface PreconditionModule<D = any> extends Omit<BaseModule, 'moduleType'>, CommandPrecondition<D> {}\n\n@mix(BaseModule, CommandPrecondition)\nexport abstract class PreconditionModule<D = any> implements PreconditionModule<D> {\n    public moduleType: ModuleType.Precondition = ModuleType.Precondition;\n\n    public abstract execute<T extends CommandType>(data: AnyCommandExecuteData<T>): Promise<CommandPrecondition.ResultDataResolvable<T, D>>;\n\n    public static from<D>(data: PreconditionModule.Resolvable<D>): PreconditionModule<D> {\n        if (data instanceof PreconditionModule || hasMixin(data, PreconditionModule)) return data;\n\n        const ModuleInstance = class extends PreconditionModule { execute = data.execute; };\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n}\n\nexport namespace PreconditionModule {\n    export type Resolvable<D = any> = PreconditionModule<D>|PreconditionModule.Data<D>;\n\n    export interface Data<D = any> extends Omit<BaseModule.Data, 'moduleType'>, Omit<CommandPrecondition.Data<D>, 'id'> {\n        moduleType: ModuleType.Precondition;\n    }\n}\n"],"mappings":";;;;;;;;AAQO,qDAAeA,qBAA6D;CAC/E,AAAO,aAAsC,WAAW;CAIxD,OAAc,KAAQ,MAA+D;AACjF,MAAI,uCAAsC,SAAS,0BAAyB,CAAE,QAAO;EAErF,MAAM,iBAAiB,kCAAiC;GAAE,UAAU,KAAK;;AACzE,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;;uDAXlC,IAAI,YAAY,oBAAoB"}

package/dist/classes/modules/commands/ContextMenuCommandModule.d.mts

@@ -0,0 +1,24 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { AnyCommandBuilderMethods } from "../../../helpers/types.mjs";
+import { ContextMenuCommand, ContextMenuCommandBuilder } from "@reciple/core";
+
+//#region src/classes/modules/commands/ContextMenuCommandModule.d.ts
+interface ContextMenuCommandModule extends Omit<BaseModule, 'moduleType'>, ContextMenuCommandModule.ContextMenuCommandWithoutBuilderMethods {}
+declare abstract class ContextMenuCommandModule implements ContextMenuCommandModule {
+  readonly moduleType: ModuleType.Command;
+  readonly id: string;
+  abstract data: ContextMenuCommandBuilder.Data;
+  abstract execute(data: ContextMenuCommand.ExecuteData): Promise<void>;
+  static from(data: ContextMenuCommandModule.Resolvable): ContextMenuCommandModule;
+}
+declare namespace ContextMenuCommandModule {
+  type Resolvable = ContextMenuCommandModule | ContextMenuCommandModule.Data;
+  interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<ContextMenuCommand.Data, 'id'> {
+    moduleType: ModuleType.Command;
+  }
+  type ContextMenuCommandWithoutBuilderMethods = Omit<ContextMenuCommand, AnyCommandBuilderMethods>;
+}
+//#endregion
+export { ContextMenuCommandModule };
+//# sourceMappingURL=ContextMenuCommandModule.d.mts.map

package/dist/classes/modules/commands/ContextMenuCommandModule.mjs

@@ -0,0 +1,27 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { ContextMenuCommand } from "@reciple/core";
+import { DiscordSnowflake } from "@sapphire/snowflake";
+import { hasMixin, mix } from "ts-mixer";
+
+//#region src/classes/modules/commands/ContextMenuCommandModule.ts
+var _ContextMenuCommandModule;
+let ContextMenuCommandModule = _ContextMenuCommandModule = class ContextMenuCommandModule$1 {
+	moduleType = ModuleType.Command;
+	id = DiscordSnowflake.generate().toString();
+	static from(data) {
+		if (data instanceof _ContextMenuCommandModule || hasMixin(data, _ContextMenuCommandModule)) return data;
+		const ModuleInstance = class extends _ContextMenuCommandModule {
+			data = data.data;
+			execute = data.execute;
+		};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+};
+ContextMenuCommandModule = _ContextMenuCommandModule = __decorate([mix(BaseModule, ContextMenuCommand)], ContextMenuCommandModule);
+
+//#endregion
+export { ContextMenuCommandModule };
+//# sourceMappingURL=ContextMenuCommandModule.mjs.map

package/dist/classes/modules/commands/ContextMenuCommandModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextMenuCommandModule.mjs","names":["ContextMenuCommandModule"],"sources":["../../../../src/classes/modules/commands/ContextMenuCommandModule.ts"],"sourcesContent":["import { BaseModule } from '../BaseModule.js';\nimport { ModuleType } from '../../../helpers/constants.js';\nimport { DiscordSnowflake } from '@sapphire/snowflake';\nimport { hasMixin, mix } from 'ts-mixer';\nimport type { AnyCommandBuilderMethods } from '../../../helpers/types.js';\nimport { ContextMenuCommand, type ContextMenuCommandBuilder } from '@reciple/core';\n\nexport interface ContextMenuCommandModule extends Omit<BaseModule, 'moduleType'>, ContextMenuCommandModule.ContextMenuCommandWithoutBuilderMethods {}\n\n@mix(BaseModule, ContextMenuCommand)\nexport abstract class ContextMenuCommandModule implements ContextMenuCommandModule {\n    public readonly moduleType: ModuleType.Command = ModuleType.Command;\n    public readonly id: string = DiscordSnowflake.generate().toString();\n\n    public abstract data: ContextMenuCommandBuilder.Data;\n\n    public abstract execute(data: ContextMenuCommand.ExecuteData): Promise<void>;\n\n    public static from(data: ContextMenuCommandModule.Resolvable): ContextMenuCommandModule {\n        if (data instanceof ContextMenuCommandModule || hasMixin(data, ContextMenuCommandModule)) return data;\n\n        const ModuleInstance = class extends ContextMenuCommandModule { data = data.data; execute = data.execute; };\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n}\n\nexport namespace ContextMenuCommandModule {\n    export type Resolvable = ContextMenuCommandModule|ContextMenuCommandModule.Data;\n\n    export interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<ContextMenuCommand.Data, 'id'> {\n        moduleType: ModuleType.Command;\n    }\n\n    export type ContextMenuCommandWithoutBuilderMethods = Omit<ContextMenuCommand, AnyCommandBuilderMethods>;\n}\n"],"mappings":";;;;;;;;;AAUO,iEAAeA,2BAA6D;CAC/E,AAAgB,aAAiC,WAAW;CAC5D,AAAgB,KAAa,iBAAiB,UAAU,CAAC,UAAU;CAMnE,OAAc,KAAK,MAAqE;AACpF,MAAI,6CAA4C,SAAS,gCAA+B,CAAE,QAAO;EAEjG,MAAM,iBAAiB,wCAAuC;GAAE,OAAO,KAAK;GAAM,UAAU,KAAK;;AACjG,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;;mEAdlC,IAAI,YAAY,mBAAmB"}

package/dist/classes/modules/commands/MessageCommandModule.d.mts

@@ -0,0 +1,24 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { AnyCommandBuilderMethods } from "../../../helpers/types.mjs";
+import { MessageCommand, MessageCommandBuilder } from "@reciple/core";
+
+//#region src/classes/modules/commands/MessageCommandModule.d.ts
+interface MessageCommandModule extends Omit<BaseModule, 'moduleType'>, MessageCommandModule.MessageCommandWithoutBuilderMethods {}
+declare abstract class MessageCommandModule implements MessageCommandModule {
+  readonly moduleType: ModuleType.Command;
+  readonly id: string;
+  abstract data: MessageCommandBuilder.Data;
+  abstract execute(data: MessageCommand.ExecuteData): Promise<void>;
+  static from(data: MessageCommandModule.Resolvable): MessageCommandModule;
+}
+declare namespace MessageCommandModule {
+  type Resolvable = MessageCommandModule | MessageCommandModule.Data;
+  interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<MessageCommand.Data, 'id'> {
+    moduleType: ModuleType.Command;
+  }
+  type MessageCommandWithoutBuilderMethods = Omit<MessageCommand, AnyCommandBuilderMethods | 'options' | 'flags'>;
+}
+//#endregion
+export { MessageCommandModule };
+//# sourceMappingURL=MessageCommandModule.d.mts.map

package/dist/classes/modules/commands/MessageCommandModule.mjs

@@ -0,0 +1,27 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { MessageCommand, MessageCommandBuilder } from "@reciple/core";
+import { DiscordSnowflake } from "@sapphire/snowflake";
+import { hasMixin, mix } from "ts-mixer";
+
+//#region src/classes/modules/commands/MessageCommandModule.ts
+var _MessageCommandModule;
+let MessageCommandModule = _MessageCommandModule = class MessageCommandModule$1 {
+	moduleType = ModuleType.Command;
+	id = DiscordSnowflake.generate().toString();
+	static from(data) {
+		if (data instanceof _MessageCommandModule || hasMixin(data, _MessageCommandModule)) return data;
+		const ModuleInstance = class extends _MessageCommandModule {
+			data = data.data;
+			execute = data.execute;
+		};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+};
+MessageCommandModule = _MessageCommandModule = __decorate([mix(BaseModule, MessageCommand)], MessageCommandModule);
+
+//#endregion
+export { MessageCommandModule };
+//# sourceMappingURL=MessageCommandModule.mjs.map

package/dist/classes/modules/commands/MessageCommandModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageCommandModule.mjs","names":["MessageCommandModule"],"sources":["../../../../src/classes/modules/commands/MessageCommandModule.ts"],"sourcesContent":["import { MessageCommand, MessageCommandBuilder } from '@reciple/core';\nimport { BaseModule } from '../BaseModule.js';\nimport { ModuleType } from '../../../helpers/constants.js';\nimport { DiscordSnowflake } from '@sapphire/snowflake';\nimport { hasMixin, mix } from 'ts-mixer';\nimport type { AnyCommandBuilderMethods } from '../../../helpers/types.js';\n\nexport interface MessageCommandModule extends Omit<BaseModule, 'moduleType'>, MessageCommandModule.MessageCommandWithoutBuilderMethods {}\n\n@mix(BaseModule, MessageCommand)\nexport abstract class MessageCommandModule implements MessageCommandModule {\n    public readonly moduleType: ModuleType.Command = ModuleType.Command;\n    public readonly id: string = DiscordSnowflake.generate().toString();\n\n    public abstract data: MessageCommandBuilder.Data;\n\n    public abstract execute(data: MessageCommand.ExecuteData): Promise<void>;\n\n    public static from(data: MessageCommandModule.Resolvable): MessageCommandModule {\n        if (data instanceof MessageCommandModule || hasMixin(data, MessageCommandModule)) return data;\n\n        const ModuleInstance = class extends MessageCommandModule { data = data.data; execute = data.execute; };\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n}\n\nexport namespace MessageCommandModule {\n    export type Resolvable = MessageCommandModule|MessageCommandModule.Data;\n\n    export interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<MessageCommand.Data, 'id'> {\n        moduleType: ModuleType.Command;\n    }\n\n    export type MessageCommandWithoutBuilderMethods = Omit<MessageCommand, AnyCommandBuilderMethods|'options'|'flags'>;\n}\n"],"mappings":";;;;;;;;;AAUO,yDAAeA,uBAAqD;CACvE,AAAgB,aAAiC,WAAW;CAC5D,AAAgB,KAAa,iBAAiB,UAAU,CAAC,UAAU;CAMnE,OAAc,KAAK,MAA6D;AAC5E,MAAI,yCAAwC,SAAS,4BAA2B,CAAE,QAAO;EAEzF,MAAM,iBAAiB,oCAAmC;GAAE,OAAO,KAAK;GAAM,UAAU,KAAK;;AAC7F,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;;2DAdlC,IAAI,YAAY,eAAe"}

package/dist/classes/modules/commands/SlashCommandModule.d.mts

@@ -0,0 +1,24 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { AnyCommandBuilderMethods } from "../../../helpers/types.mjs";
+import { SlashCommand, SlashCommandBuilder } from "@reciple/core";
+
+//#region src/classes/modules/commands/SlashCommandModule.d.ts
+interface SlashCommandModule extends Omit<BaseModule, 'moduleType'>, SlashCommandModule.SlashCommandWithoutBuilderMethods {}
+declare abstract class SlashCommandModule implements SlashCommandModule {
+  readonly moduleType: ModuleType.Command;
+  readonly id: string;
+  abstract data: SlashCommandBuilder.Data;
+  abstract execute(data: SlashCommand.ExecuteData): Promise<void>;
+  static from(data: SlashCommandModule.Resolvable): SlashCommandModule;
+}
+declare namespace SlashCommandModule {
+  type Resolvable = SlashCommandModule | SlashCommandModule.Data;
+  interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<SlashCommand.Data, 'id'> {
+    moduleType: ModuleType.Command;
+  }
+  type SlashCommandWithoutBuilderMethods = Omit<SlashCommand, AnyCommandBuilderMethods>;
+}
+//#endregion
+export { SlashCommandModule };
+//# sourceMappingURL=SlashCommandModule.d.mts.map

package/dist/classes/modules/commands/SlashCommandModule.mjs

@@ -0,0 +1,27 @@
+import { ModuleType } from "../../../helpers/constants.mjs";
+import { BaseModule } from "../BaseModule.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { SlashCommand } from "@reciple/core";
+import { DiscordSnowflake } from "@sapphire/snowflake";
+import { hasMixin, mix } from "ts-mixer";
+
+//#region src/classes/modules/commands/SlashCommandModule.ts
+var _SlashCommandModule;
+let SlashCommandModule = _SlashCommandModule = class SlashCommandModule$1 {
+	moduleType = ModuleType.Command;
+	id = DiscordSnowflake.generate().toString();
+	static from(data) {
+		if (data instanceof _SlashCommandModule || hasMixin(data, _SlashCommandModule)) return data;
+		const ModuleInstance = class extends _SlashCommandModule {
+			data = data.data;
+			execute = data.execute;
+		};
+		Object.assign(ModuleInstance.prototype, data);
+		return new ModuleInstance();
+	}
+};
+SlashCommandModule = _SlashCommandModule = __decorate([mix(BaseModule, SlashCommand)], SlashCommandModule);
+
+//#endregion
+export { SlashCommandModule };
+//# sourceMappingURL=SlashCommandModule.mjs.map

package/dist/classes/modules/commands/SlashCommandModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlashCommandModule.mjs","names":["SlashCommandModule"],"sources":["../../../../src/classes/modules/commands/SlashCommandModule.ts"],"sourcesContent":["import { BaseModule } from '../BaseModule.js';\nimport { ModuleType } from '../../../helpers/constants.js';\nimport { DiscordSnowflake } from '@sapphire/snowflake';\nimport { hasMixin, mix } from 'ts-mixer';\nimport { SlashCommand, type SlashCommandBuilder } from '@reciple/core';\nimport type { AnyCommandBuilderMethods } from '../../../helpers/types.js';\n\nexport interface SlashCommandModule extends Omit<BaseModule, 'moduleType'>, SlashCommandModule.SlashCommandWithoutBuilderMethods {}\n\n@mix(BaseModule, SlashCommand)\nexport abstract class SlashCommandModule implements SlashCommandModule {\n    public readonly moduleType: ModuleType.Command = ModuleType.Command;\n    public readonly id: string = DiscordSnowflake.generate().toString();\n\n    public abstract data: SlashCommandBuilder.Data;\n\n    public abstract execute(data: SlashCommand.ExecuteData): Promise<void>;\n\n    public static from(data: SlashCommandModule.Resolvable): SlashCommandModule {\n        if (data instanceof SlashCommandModule || hasMixin(data, SlashCommandModule)) return data;\n\n        const ModuleInstance = class extends SlashCommandModule { data = data.data; execute = data.execute; };\n        Object.assign(ModuleInstance.prototype, data);\n        return new ModuleInstance();\n    }\n}\n\nexport namespace SlashCommandModule {\n    export type Resolvable = SlashCommandModule|SlashCommandModule.Data;\n\n    export interface Data extends Omit<BaseModule.Data, 'moduleType'>, Omit<SlashCommand.Data, 'id'> {\n        moduleType: ModuleType.Command;\n    }\n\n    export type SlashCommandWithoutBuilderMethods = Omit<SlashCommand, AnyCommandBuilderMethods>;\n}\n"],"mappings":";;;;;;;;;AAUO,qDAAeA,qBAAiD;CACnE,AAAgB,aAAiC,WAAW;CAC5D,AAAgB,KAAa,iBAAiB,UAAU,CAAC,UAAU;CAMnE,OAAc,KAAK,MAAyD;AACxE,MAAI,uCAAsC,SAAS,0BAAyB,CAAE,QAAO;EAErF,MAAM,iBAAiB,kCAAiC;GAAE,OAAO,KAAK;GAAM,UAAU,KAAK;;AAC3F,SAAO,OAAO,eAAe,WAAW,KAAK;AAC7C,SAAO,IAAI,gBAAgB;;;uDAdlC,IAAI,YAAY,aAAa"}

package/dist/classes/modules/events/ClientEventModule.d.mts

@@ -0,0 +1,11 @@
+import { EventModule } from "./EventModule.mjs";
+import { Client } from "@reciple/core";
+
+//#region src/classes/modules/events/ClientEventModule.d.ts
+declare abstract class ClientEventModule<Event extends keyof Client.Events> extends EventModule<Client.Events, Event> {
+  emitter: Client;
+  abstract event: Event;
+}
+//#endregion
+export { ClientEventModule };
+//# sourceMappingURL=ClientEventModule.d.mts.map

package/dist/classes/modules/events/ClientEventModule.mjs

@@ -0,0 +1,10 @@
+import { EventModule } from "./EventModule.mjs";
+
+//#region src/classes/modules/events/ClientEventModule.ts
+var ClientEventModule = class extends EventModule {
+	emitter = useClient();
+};
+
+//#endregion
+export { ClientEventModule };
+//# sourceMappingURL=ClientEventModule.mjs.map

package/dist/classes/modules/events/ClientEventModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientEventModule.mjs","names":[],"sources":["../../../../src/classes/modules/events/ClientEventModule.ts"],"sourcesContent":["import type { Client } from '@reciple/core';\nimport { EventModule } from './EventModule.js';\n\nexport abstract class ClientEventModule<Event extends keyof Client.Events> extends EventModule<Client.Events, Event> {\n    public emitter: Client = useClient();\n    public abstract event: Event;\n}\n"],"mappings":";;;AAGA,IAAsB,oBAAtB,cAAmF,YAAkC;CACjH,AAAO,UAAkB,WAAW"}