@globalart/nestcord 2.3.1 → 2.5.0-0

package/dist/core/src/text-commands/text-command.discovery.d.ts

@@ -2,6 +2,7 @@ import { NestCordBaseDiscovery } from '../context';
 export interface TextCommandMeta {
     name: string;
     description: string;
+    aliases?: string[];
 }
 /**
  * Represents a text command discovery.
@@ -9,6 +10,7 @@ export interface TextCommandMeta {
 export declare class TextCommandDiscovery extends NestCordBaseDiscovery<TextCommandMeta> {
     getName(): string;
     getDescription(): string;
+    getAliases(): string[];
     isTextCommand(): this is TextCommandDiscovery;
     toJSON(): Record<string, any>;
 }

package/dist/core/src/text-commands/text-command.discovery.js

@@ -12,6 +12,10 @@ class TextCommandDiscovery extends context_1.NestCordBaseDiscovery {
     getDescription() {
         return this.meta.description;
     }
+    getAliases() {
+        var _a;
+        return (_a = this.meta.aliases) !== null && _a !== void 0 ? _a : [];
+    }
     isTextCommand() {
         return true;
     }

package/dist/core/src/text-commands/text-commands.service.js

@@ -20,10 +20,18 @@ let TextCommandsService = TextCommandsService_1 = class TextCommandsService {
     }
     add(textCommand) {
         const name = textCommand.getName();
+        const aliases = textCommand.getAliases();
         if (this.cache.has(name)) {
             this.logger.warn(`TextCommand : ${name} already exists`);
         }
         this.cache.set(name, textCommand);
+        for (const alias of aliases) {
+            if (this.cache.has(alias)) {
+                this.logger.warn(`TextCommand alias : ${alias} already exists`);
+                continue;
+            }
+            this.cache.set(alias, textCommand);
+        }
     }
     get(name) {
         return this.cache.get(name);

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export * from './localization';
 export * from './pagination';
 export * from './stat-reporter';
 export * from './lavalink';
+export * from './sharding';

package/dist/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./localization"), exports);
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./stat-reporter"), exports);
 __exportStar(require("./lavalink"), exports);
+__exportStar(require("./sharding"), exports);

package/dist/lavalink/src/nestcord-lavalink.service.d.ts

@@ -4,7 +4,7 @@ export declare class NestCordLavalinkService {
     private readonly lavalinkManager;
     private readonly client;
     constructor(lavalinkManager: LavalinkManager, client: Client);
-    lavalinkUtils: import("lavalink-client/dist/types").ManagerUtils;
+    lavalinkUtils: import("lavalink-client").ManagerUtils;
     extractInfoForPlayer(base: Message | ChatInputCommandInteraction): {
         guildId: string;
         voiceChannelId: string;

package/dist/sharding/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/sharding/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

package/dist/sharding/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './listeners';
+export * from './providers';
+export * from './nestcord-sharding.module';
+export * from './nestcord-sharding.service';
+export * from './nestcord-sharding.module-definition';
+export * from './nestcord-sharding-options.interface';

package/dist/sharding/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./listeners"), exports);
+__exportStar(require("./providers"), exports);
+__exportStar(require("./nestcord-sharding.module"), exports);
+__exportStar(require("./nestcord-sharding.service"), exports);
+__exportStar(require("./nestcord-sharding.module-definition"), exports);
+__exportStar(require("./nestcord-sharding-options.interface"), exports);

package/dist/sharding/src/listeners/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listener.decorator';
+export * from './on.decorator';

package/dist/sharding/src/listeners/decorators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./listener.decorator"), exports);
+__exportStar(require("./on.decorator"), exports);

package/dist/sharding/src/listeners/decorators/listener.decorator.d.ts

@@ -0,0 +1,5 @@
+import { ShardingListenerMeta } from '../interfaces';
+/**
+ * Decorator that marks a method as a listener for the ShardingManager or a Shard.
+ */
+export declare const ShardingListener: import("@nestjs/core").ReflectableDecorator<ShardingListenerMeta, ShardingListenerMeta>;

package/dist/sharding/src/listeners/decorators/listener.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingListener = void 0;
+const core_1 = require("@nestjs/core");
+/**
+ * Decorator that marks a method as a listener for the ShardingManager or a Shard.
+ */
+exports.ShardingListener = core_1.Reflector.createDecorator({
+    transform: (options) => options,
+});

package/dist/sharding/src/listeners/decorators/on.decorator.d.ts

@@ -0,0 +1,17 @@
+import { NestCordShardingManagerEvents, NestCordShardEvents } from '../interfaces';
+/**
+ * Subscribes a method to an event on the ShardingManager.
+ *
+ * @example
+ * \@OnShardingManager('shardCreate')
+ * onShardCreate([shard]: ShardingManagerContextOf<'shardCreate'>) {}
+ */
+export declare const OnShardingManager: <K extends keyof NestCordShardingManagerEvents>(event: K) => import("@nestjs/common").CustomDecorator;
+/**
+ * Subscribes a method to an event on every Shard as it is created.
+ *
+ * @example
+ * \@OnShard('ready')
+ * onShardReady([shard]: ShardContextOf<'ready'>) {}
+ */
+export declare const OnShard: <K extends keyof NestCordShardEvents>(event: K) => import("@nestjs/common").CustomDecorator;

package/dist/sharding/src/listeners/decorators/on.decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnShard = exports.OnShardingManager = void 0;
+const listener_decorator_1 = require("./listener.decorator");
+const enums_1 = require("../enums");
+/**
+ * Subscribes a method to an event on the ShardingManager.
+ *
+ * @example
+ * \@OnShardingManager('shardCreate')
+ * onShardCreate([shard]: ShardingManagerContextOf<'shardCreate'>) {}
+ */
+const OnShardingManager = (event) => (0, listener_decorator_1.ShardingListener)({
+    type: enums_1.ShardingListenerType.On,
+    event,
+    host: enums_1.ShardingHostType.ShardingManager,
+});
+exports.OnShardingManager = OnShardingManager;
+/**
+ * Subscribes a method to an event on every Shard as it is created.
+ *
+ * @example
+ * \@OnShard('ready')
+ * onShardReady([shard]: ShardContextOf<'ready'>) {}
+ */
+const OnShard = (event) => (0, listener_decorator_1.ShardingListener)({
+    type: enums_1.ShardingListenerType.On,
+    event,
+    host: enums_1.ShardingHostType.Shard,
+});
+exports.OnShard = OnShard;

package/dist/sharding/src/listeners/enums/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listener-host-type.enum';
+export * from './listener-type.enum';

package/dist/sharding/src/listeners/enums/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./listener-host-type.enum"), exports);
+__exportStar(require("./listener-type.enum"), exports);

package/dist/sharding/src/listeners/enums/listener-host-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ShardingHostType {
+    ShardingManager = "shardingManager",
+    Shard = "shard"
+}

package/dist/sharding/src/listeners/enums/listener-host-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingHostType = void 0;
+var ShardingHostType;
+(function (ShardingHostType) {
+    ShardingHostType["ShardingManager"] = "shardingManager";
+    ShardingHostType["Shard"] = "shard";
+})(ShardingHostType || (exports.ShardingHostType = ShardingHostType = {}));

package/dist/sharding/src/listeners/enums/listener-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ShardingListenerType {
+    On = "on",
+    Once = "once"
+}

package/dist/sharding/src/listeners/enums/listener-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingListenerType = void 0;
+var ShardingListenerType;
+(function (ShardingListenerType) {
+    ShardingListenerType["On"] = "on";
+    ShardingListenerType["Once"] = "once";
+})(ShardingListenerType || (exports.ShardingListenerType = ShardingListenerType = {}));

package/dist/sharding/src/listeners/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decorators';
+export * from './enums';
+export * from './interfaces';
+export * from './listeners.module';

package/dist/sharding/src/listeners/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./listeners.module"), exports);

package/dist/sharding/src/listeners/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listener-events.interface';
+export * from './listener-meta.interface';

package/dist/sharding/src/listeners/interfaces/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./listener-events.interface"), exports);
+__exportStar(require("./listener-meta.interface"), exports);

package/dist/sharding/src/listeners/interfaces/listener-events.interface.d.ts

@@ -0,0 +1,24 @@
+import { Shard } from 'discord.js';
+import { ChildProcess } from 'node:child_process';
+import { Worker } from 'node:worker_threads';
+/**
+ * Events emitted by the ShardingManager itself.
+ */
+export interface NestCordShardingManagerEvents {
+    shardCreate: [shard: Shard];
+}
+/**
+ * Events emitted by individual Shard instances.
+ * These listeners are registered on every shard as it is created.
+ */
+export interface NestCordShardEvents {
+    death: [shard: Shard, process: ChildProcess | Worker];
+    disconnect: [shard: Shard];
+    error: [shard: Shard, error: Error];
+    message: [shard: Shard, message: unknown];
+    ready: [shard: Shard];
+    reconnecting: [shard: Shard];
+    resume: [shard: Shard];
+    spawn: [shard: Shard, process: ChildProcess | Worker];
+}
+export type NestCordShardingEvents = NestCordShardingManagerEvents & NestCordShardEvents;

package/dist/sharding/src/listeners/interfaces/listener-events.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sharding/src/listeners/interfaces/listener-meta.interface.d.ts

@@ -0,0 +1,7 @@
+import { NestCordShardingEvents } from './listener-events.interface';
+import { ShardingHostType, ShardingListenerType } from '../enums';
+export interface ShardingListenerMeta {
+    type: ShardingListenerType;
+    event: keyof NestCordShardingEvents;
+    host: ShardingHostType;
+}

package/dist/sharding/src/listeners/interfaces/listener-meta.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sharding/src/listeners/listeners.module.d.ts

@@ -0,0 +1,11 @@
+import { OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { ShardingManager } from 'discord.js';
+export declare class ShardingListenersModule implements OnModuleInit {
+    private readonly discoveryService;
+    private readonly metadataScanner;
+    private readonly reflector;
+    private readonly shardingManager;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, reflector: Reflector, shardingManager: ShardingManager);
+    onModuleInit(): void;
+}

package/dist/sharding/src/listeners/listeners.module.js

@@ -0,0 +1,86 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingListenersModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const discord_js_1 = require("discord.js");
+const decorators_1 = require("./decorators");
+const enums_1 = require("./enums");
+let ShardingListenersModule = class ShardingListenersModule {
+    constructor(discoveryService, metadataScanner, reflector, shardingManager) {
+        this.discoveryService = discoveryService;
+        this.metadataScanner = metadataScanner;
+        this.reflector = reflector;
+        this.shardingManager = shardingManager;
+    }
+    onModuleInit() {
+        var _a;
+        const groupedListeners = new Map();
+        const wrappers = this.discoveryService.getProviders().filter((wrapper) => {
+            const { instance } = wrapper;
+            const prototype = instance ? Object.getPrototypeOf(instance) : null;
+            return instance && prototype && wrapper.isDependencyTreeStatic();
+        });
+        for (const wrapper of wrappers) {
+            const instance = wrapper.instance;
+            const prototype = Object.getPrototypeOf(instance);
+            const methods = this.metadataScanner.getAllMethodNames(prototype);
+            for (const method of methods) {
+                const meta = this.reflector.get(decorators_1.ShardingListener, instance[method]);
+                if (!meta)
+                    continue;
+                const key = `${meta.event}:${meta.host}`;
+                const listeners = (_a = groupedListeners.get(key)) !== null && _a !== void 0 ? _a : [];
+                listeners.push(Object.assign(Object.assign({}, meta), { run: instance[method].bind(instance) }));
+                groupedListeners.set(key, listeners);
+            }
+        }
+        for (const [key, listeners] of groupedListeners) {
+            const [event, host] = key.split(':');
+            if (host === enums_1.ShardingHostType.ShardingManager) {
+                /**
+                 * ShardingManager extends EventEmitter. Casting to EventEmitter lets us
+                 * register listeners with a dynamic event name without bypassing type safety —
+                 * EventEmitter.on(event: string) is the correct untyped surface for this.
+                 */
+                this.shardingManager.on(event, (...args) => {
+                    for (const listener of listeners) {
+                        listener.run(args);
+                    }
+                });
+            }
+            if (host === enums_1.ShardingHostType.Shard) {
+                /**
+                 * Shard also extends EventEmitter. We subscribe to shardCreate on the manager
+                 * so that every new Shard gets the same listener registered on it immediately.
+                 */
+                this.shardingManager.on('shardCreate', (shard) => {
+                    shard.on(event, (...args) => {
+                        for (const listener of listeners) {
+                            listener.run(args);
+                        }
+                    });
+                });
+            }
+        }
+    }
+};
+exports.ShardingListenersModule = ShardingListenersModule;
+exports.ShardingListenersModule = ShardingListenersModule = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.DiscoveryModule],
+    }),
+    __metadata("design:paramtypes", [core_1.DiscoveryService,
+        core_1.MetadataScanner,
+        core_1.Reflector,
+        discord_js_1.ShardingManager])
+], ShardingListenersModule);

package/dist/sharding/src/nestcord-sharding-options.interface.d.ts

@@ -0,0 +1,33 @@
+import { ShardingManagerOptions } from 'discord.js';
+export interface NestCordShardingSpawnOptions {
+    /**
+     * Number of shards to spawn, or 'auto' to use Discord's recommendation.
+     * @default 'auto'
+     */
+    amount?: number | 'auto';
+    /**
+     * Delay in milliseconds between each shard spawn.
+     * @default 5500
+     */
+    delay?: number;
+    /**
+     * Timeout in milliseconds to wait for a shard to become ready.
+     * @default 30000
+     */
+    timeout?: number;
+}
+export interface NestCordShardingModuleOptions extends ShardingManagerOptions {
+    /**
+     * Path to the bot script file that each shard will run.
+     */
+    file: string;
+    /**
+     * Whether to automatically spawn shards when the module initializes.
+     * @default true
+     */
+    autoSpawn?: boolean;
+    /**
+     * Options passed to ShardingManager.spawn().
+     */
+    spawnOptions?: NestCordShardingSpawnOptions;
+}

package/dist/sharding/src/nestcord-sharding-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sharding/src/nestcord-sharding.module-definition.d.ts

@@ -0,0 +1,2 @@
+import { NestCordShardingModuleOptions } from './nestcord-sharding-options.interface';
+export declare const NestCordShardingConfigurableModule: import("@nestjs/common").ConfigurableModuleCls<NestCordShardingModuleOptions, "forRoot", "createNestCordShardingOptions", {}>, SHARDING_MODULE_OPTIONS: string | symbol;

package/dist/sharding/src/nestcord-sharding.module-definition.js

@@ -0,0 +1,9 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARDING_MODULE_OPTIONS = exports.NestCordShardingConfigurableModule = void 0;
+const common_1 = require("@nestjs/common");
+_a = new common_1.ConfigurableModuleBuilder()
+    .setClassMethodName('forRoot')
+    .setFactoryMethodName('createNestCordShardingOptions')
+    .build(), exports.NestCordShardingConfigurableModule = _a.ConfigurableModuleClass, exports.SHARDING_MODULE_OPTIONS = _a.MODULE_OPTIONS_TOKEN;

package/dist/sharding/src/nestcord-sharding.module.d.ts

@@ -0,0 +1,12 @@
+import { OnApplicationShutdown, OnModuleInit } from '@nestjs/common';
+import { ShardingManager } from 'discord.js';
+import { NestCordShardingConfigurableModule } from './nestcord-sharding.module-definition';
+import { NestCordShardingModuleOptions } from './nestcord-sharding-options.interface';
+export declare class NestCordShardingModule extends NestCordShardingConfigurableModule implements OnModuleInit, OnApplicationShutdown {
+    private readonly shardingManager;
+    private readonly options;
+    private readonly logger;
+    constructor(shardingManager: ShardingManager, options: NestCordShardingModuleOptions);
+    onModuleInit(): Promise<void>;
+    onApplicationShutdown(): void;
+}

package/dist/sharding/src/nestcord-sharding.module.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var NestCordShardingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestCordShardingModule = void 0;
+const common_1 = require("@nestjs/common");
+const discord_js_1 = require("discord.js");
+const nestcord_sharding_module_definition_1 = require("./nestcord-sharding.module-definition");
+const nestcord_sharding_service_1 = require("./nestcord-sharding.service");
+const listeners_1 = require("./listeners");
+const ProvidersMap = require("./providers");
+const Providers = Object.values(ProvidersMap);
+let NestCordShardingModule = NestCordShardingModule_1 = class NestCordShardingModule extends nestcord_sharding_module_definition_1.NestCordShardingConfigurableModule {
+    constructor(shardingManager, options) {
+        super();
+        this.shardingManager = shardingManager;
+        this.options = options;
+        this.logger = new common_1.Logger(NestCordShardingModule_1.name);
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.autoSpawn === false) {
+                return;
+            }
+            this.logger.log('Spawning shards...');
+            const shards = yield this.shardingManager.spawn(this.options.spawnOptions);
+            this.logger.log(`${shards.size} shard(s) spawned successfully`);
+        });
+    }
+    onApplicationShutdown() {
+        this.logger.log('Shutting down NestCord Sharding Module');
+        this.shardingManager.shards.forEach((shard) => shard.kill());
+    }
+};
+exports.NestCordShardingModule = NestCordShardingModule;
+exports.NestCordShardingModule = NestCordShardingModule = NestCordShardingModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [listeners_1.ShardingListenersModule],
+        providers: [nestcord_sharding_service_1.NestCordShardingService, ...Providers],
+        exports: [nestcord_sharding_service_1.NestCordShardingService, ...Providers],
+    }),
+    __param(1, (0, common_1.Inject)(nestcord_sharding_module_definition_1.SHARDING_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [discord_js_1.ShardingManager, Object])
+], NestCordShardingModule);

package/dist/sharding/src/nestcord-sharding.service.d.ts

@@ -0,0 +1,34 @@
+import { Collection, Shard, ShardingManager } from 'discord.js';
+import { NestCordShardingSpawnOptions } from './nestcord-sharding-options.interface';
+export declare class NestCordShardingService {
+    private readonly shardingManager;
+    constructor(shardingManager: ShardingManager);
+    /**
+     * Returns all spawned shards.
+     */
+    get shards(): Collection<number, Shard>;
+    /**
+     * Spawns shards. Resolves once all shards are ready.
+     */
+    spawn(options?: NestCordShardingSpawnOptions): Promise<Collection<number, Shard>>;
+    /**
+     * Sends a message to all shards.
+     */
+    broadcast(message: unknown): Promise<unknown[]>;
+    /**
+     * Evaluates a script on all shards and returns the results.
+     */
+    broadcastEval<T>(fn: Parameters<ShardingManager['broadcastEval']>[0], options?: Parameters<ShardingManager['broadcastEval']>[1]): Promise<T[]>;
+    /**
+     * Fetches a property from all shards' clients and returns the values as an array.
+     */
+    fetchClientValues(prop: string, shard?: number): Promise<unknown>;
+    /**
+     * Kills and restarts all shards.
+     */
+    respawnAll(options?: {
+        shardDelay?: number;
+        respawnDelay?: number;
+        timeout?: number;
+    }): Promise<Collection<number, Shard>>;
+}

package/dist/sharding/src/nestcord-sharding.service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestCordShardingService = void 0;
+const common_1 = require("@nestjs/common");
+const discord_js_1 = require("discord.js");
+let NestCordShardingService = class NestCordShardingService {
+    constructor(shardingManager) {
+        this.shardingManager = shardingManager;
+    }
+    /**
+     * Returns all spawned shards.
+     */
+    get shards() {
+        return this.shardingManager.shards;
+    }
+    /**
+     * Spawns shards. Resolves once all shards are ready.
+     */
+    spawn(options) {
+        return this.shardingManager.spawn(options);
+    }
+    /**
+     * Sends a message to all shards.
+     */
+    broadcast(message) {
+        return this.shardingManager.broadcast(message);
+    }
+    /**
+     * Evaluates a script on all shards and returns the results.
+     */
+    broadcastEval(fn, options) {
+        return this.shardingManager.broadcastEval(fn, options);
+    }
+    /**
+     * Fetches a property from all shards' clients and returns the values as an array.
+     */
+    fetchClientValues(prop, shard) {
+        return this.shardingManager.fetchClientValues(prop, shard);
+    }
+    /**
+     * Kills and restarts all shards.
+     */
+    respawnAll(options) {
+        return this.shardingManager.respawnAll(options);
+    }
+};
+exports.NestCordShardingService = NestCordShardingService;
+exports.NestCordShardingService = NestCordShardingService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [discord_js_1.ShardingManager])
+], NestCordShardingService);

package/dist/sharding/src/providers/index.d.ts

@@ -0,0 +1 @@
+export * from './sharding-manager.provider';

package/dist/sharding/src/providers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sharding-manager.provider"), exports);

package/dist/sharding/src/providers/sharding-manager.provider.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from '@nestjs/common';
+import { ShardingManager } from 'discord.js';
+export declare const ShardingManagerProvider: Provider<ShardingManager>;

package/dist/sharding/src/providers/sharding-manager.provider.js

@@ -0,0 +1,24 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingManagerProvider = void 0;
+const discord_js_1 = require("discord.js");
+const nestcord_sharding_module_definition_1 = require("../nestcord-sharding.module-definition");
+exports.ShardingManagerProvider = {
+    provide: discord_js_1.ShardingManager,
+    useFactory: (options) => {
+        const { file, autoSpawn, spawnOptions } = options, managerOptions = __rest(options, ["file", "autoSpawn", "spawnOptions"]);
+        return new discord_js_1.ShardingManager(file, managerOptions);
+    },
+    inject: [nestcord_sharding_module_definition_1.SHARDING_MODULE_OPTIONS],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@globalart/nestcord",
 	"description": "A module for creating Discord bots using NestJS, based on Discord.js",
-	"version": "2.3.1",
+	"version": "2.5.0-0",
 	"private": false,
 	"scripts": {
 		"build": "rimraf dist && tsc -p tsconfig.build.json",
@@ -50,35 +50,35 @@
 		"@nestjs/axios": "^4.0.0",
 		"@nestjs/schedule": "^6.0.0",
 		"axios": "^1.9.0",
-		"cron": "4.3.0",
+		"cron": "4.4.0",
 		"deepmerge": "^4.3.1",
 		"lavalink-client": "^2.5.3",
 		"path-to-regexp": "^8.0.0"
 	},
 	"devDependencies": {
-		"@commitlint/cli": "19.8.1",
-		"@commitlint/config-angular": "19.8.1",
+		"@commitlint/cli": "20.5.0",
+		"@commitlint/config-angular": "20.5.0",
 		"@favware/npm-deprecate": "2.0.0",
-		"@nestjs/common": "11.1.3",
-		"@nestjs/core": "11.1.3",
+		"@nestjs/common": "11.1.18",
+		"@nestjs/core": "11.1.18",
 		"@nestjs/platform-express": "^11.1.1",
-		"@types/node": "24.0.4",
-		"@typescript-eslint/eslint-plugin": "8.35.0",
-		"@typescript-eslint/parser": "8.35.0",
-		"discord-api-types": "0.38.13",
-		"discord.js": "14.21.0",
-		"eslint": "9.29.0",
-		"eslint-config-prettier": "10.1.5",
-		"eslint-plugin-prettier": "5.5.0",
+		"@types/node": "25.5.2",
+		"@typescript-eslint/eslint-plugin": "8.58.0",
+		"@typescript-eslint/parser": "8.58.0",
+		"discord-api-types": "0.38.44",
+		"discord.js": "14.26.2",
+		"eslint": "10.2.0",
+		"eslint-config-prettier": "10.1.8",
+		"eslint-plugin-prettier": "5.5.5",
 		"husky": "9.1.7",
-		"lint-staged": "16.1.2",
-		"prettier": "3.6.1",
+		"lint-staged": "16.4.0",
+		"prettier": "3.8.1",
 		"reflect-metadata": "0.2.2",
-		"release-it": "19.0.3",
-		"rimraf": "6.0.1",
+		"release-it": "19.2.4",
+		"rimraf": "6.1.3",
 		"rxjs": "7.8.2",
 		"ts-node": "10.9.2",
-		"typescript": "5.8.3"
+		"typescript": "5.9.3"
 	},
 	"peerDependencies": {
 		"@nestjs/common": ">=10.2.0",