seyfert 2.0.0 → 2.1.0

package/lib/commands/applications/entryPoint.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryPointCommand = void 0;
+const common_1 = require("../../common");
+const types_1 = require("../../types");
+class EntryPointCommand {
+    middlewares = [];
+    __filePath;
+    __t;
+    name;
+    type = types_1.ApplicationCommandType.PrimaryEntryPoint;
+    nsfw;
+    integrationTypes = [];
+    contexts = [];
+    description;
+    botPermissions;
+    dm;
+    handler;
+    name_localizations;
+    description_localizations;
+    props = {};
+    toJSON() {
+        return {
+            handler: this.handler,
+            name: this.name,
+            type: this.type,
+            nsfw: this.nsfw,
+            default_member_permissions: null,
+            guild_id: null,
+            description: this.description,
+            name_localizations: this.name_localizations,
+            description_localizations: this.description_localizations,
+            dm_permission: this.dm,
+            contexts: this.contexts,
+            integration_types: this.integrationTypes,
+        };
+    }
+    async reload() {
+        delete require.cache[this.__filePath];
+        const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
+        Object.setPrototypeOf(this, __tempCommand.prototype);
+    }
+    onRunError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
+    }
+    onMiddlewaresError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
+    }
+    onBotPermissionsFail(context, permissions) {
+        context.client.logger.fatal(`${this.name}.<onBotPermissionsFail>`, context.author.id, permissions);
+    }
+    onInternalError(client, command, error) {
+        client.logger.fatal(command.name, error);
+    }
+}
+exports.EntryPointCommand = EntryPointCommand;

package/lib/commands/applications/entrycontext.d.ts

@@ -0,0 +1,40 @@
+import type { ReturnCache } from '../..';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../../common';
+import type { AllChannels, EntryPointInteraction } from '../../structures';
+import { BaseContext } from '../basecontext';
+import type { RegisteredMiddlewares } from '../decorators';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+import type { GuildMemberStructure, GuildStructure, MessageStructure, WebhookMessageStructure } from '../../client/transformers';
+import type { EntryPointCommand } from './entryPoint';
+export interface EntryPointContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
+}
+export declare class EntryPointContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+    readonly client: UsingClient;
+    readonly interaction: EntryPointInteraction;
+    readonly shardId: number;
+    readonly command: EntryPointCommand;
+    constructor(client: UsingClient, interaction: EntryPointInteraction, shardId: number, command: EntryPointCommand);
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
+    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
+        get(locale?: string): import("./shared").DefaultLocale;
+    };
+    get fullCommandName(): string;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, void | WebhookMessageStructure>>;
+    modal(body: ModalCreateBodyRequest): Promise<void>;
+    deferReply(ephemeral?: boolean): Promise<void>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("../..").WebhookMessage>;
+    deleteResponse(): Promise<void | undefined>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
+    fetchResponse(): Promise<import("../..").WebhookMessage | undefined>;
+    channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
+    channel(mode?: 'cache'): ReturnCache<AllChannels>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
+    get guildId(): string | undefined;
+    get channelId(): string;
+    get author(): import("../..").User;
+    get member(): import("../..").InteractionGuildMember | undefined;
+}

package/lib/commands/applications/entrycontext.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryPointContext = void 0;
+const types_1 = require("../../types");
+const basecontext_1 = require("../basecontext");
+class EntryPointContext extends basecontext_1.BaseContext {
+    client;
+    interaction;
+    shardId;
+    command;
+    constructor(client, interaction, shardId, command) {
+        super(client);
+        this.client = client;
+        this.interaction = interaction;
+        this.shardId = shardId;
+        this.command = command;
+    }
+    metadata = {};
+    globalMetadata = {};
+    get t() {
+        return this.client.t(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
+    }
+    get fullCommandName() {
+        return this.command.name;
+    }
+    write(body, fetchReply) {
+        return this.interaction.write(body, fetchReply);
+    }
+    modal(body) {
+        return this.interaction.modal(body);
+    }
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
+    }
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    editOrReply(body, fetchReply) {
+        return this.interaction.editOrReply(body, fetchReply);
+    }
+    fetchResponse() {
+        return this.interaction.fetchResponse();
+    }
+    channel(mode = 'cache') {
+        if (this.interaction.channel && mode === 'cache')
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+        return this.client.channels.fetch(this.channelId, mode === 'rest');
+    }
+    me(mode = 'cache') {
+        if (!this.guildId)
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.members?.get(this.client.botId, this.guildId);
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
+    }
+    guild(mode = 'cache') {
+        if (!this.guildId)
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.guilds?.get(this.guildId);
+            default:
+                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+        }
+    }
+    get guildId() {
+        return this.interaction.guildId;
+    }
+    get channelId() {
+        return this.interaction.channelId;
+    }
+    get author() {
+        return this.interaction.user;
+    }
+    get member() {
+        return this.interaction.member;
+    }
+}
+exports.EntryPointContext = EntryPointContext;

package/lib/commands/applications/options.d.ts

@@ -1,5 +1,5 @@
 import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
-import type { AutocompleteCallback, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
 import type { CommandContext } from './chatcontext';
 import type { MiddlewareContext } from './shared';
@@ -65,4 +65,5 @@ export declare function createNumberOption<T extends SeyfertNumberOption = Seyfe
 export declare function createAttachmentOption<T extends SeyfertAttachmentOption = SeyfertAttachmentOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Attachment;
 };
-export declare function createMiddleware<T = any, C extends CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;
+export type AnyContext = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext | EntryPointContext;
+export declare function createMiddleware<T = any, C extends AnyContext = AnyContext>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;

package/lib/commands/decorators.d.ts

@@ -1,10 +1,16 @@
-import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, type LocaleString } from '../types';
+import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, InteractionContextType, type LocaleString } from '../types';
 import type { FlatObjectKeys, PermissionStrings } from '../common';
 import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
 import type { DefaultLocale, ExtraProps, IgnoreCommand, MiddlewareContext } from './applications/shared';
 export interface RegisteredMiddlewares {
 }
-type DeclareOptions = {
+export type CommandDeclareOptions = DecoratorDeclareOptions | (Omit<DecoratorDeclareOptions, 'description'> & {
+    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+}) | (Omit<DecoratorDeclareOptions, 'ignore' | 'aliases' | 'guildId'> & {
+    type: ApplicationCommandType.PrimaryEntryPoint;
+    handler: EntryPointCommandHandlerType;
+});
+export interface DecoratorDeclareOptions {
     name: string;
     description: string;
     botPermissions?: PermissionStrings | bigint;
@@ -16,19 +22,7 @@ type DeclareOptions = {
     ignore?: IgnoreCommand;
     aliases?: string[];
     props?: ExtraProps;
-} | (Omit<{
-    name: string;
-    description: string;
-    botPermissions?: PermissionStrings | bigint;
-    defaultMemberPermissions?: PermissionStrings | bigint;
-    guildId?: string[];
-    nsfw?: boolean;
-    integrationTypes?: (keyof typeof ApplicationIntegrationType)[];
-    contexts?: (keyof typeof InteractionContextType)[];
-    props?: ExtraProps;
-}, 'type' | 'description'> & {
-    type: ApplicationCommandType.User | ApplicationCommandType.Message;
-});
+}
 export declare function Locales({ name: names, description: descriptions, }: {
     name?: [language: LocaleString, value: string][];
     description?: [language: LocaleString, value: string][];
@@ -121,7 +115,7 @@ export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[
         middlewares: readonly never[];
     };
 } & T;
-export declare function Declare(declare: DeclareOptions): <T extends {
+export declare function Declare(declare: CommandDeclareOptions): <T extends {
     new (...args: any[]): {};
 }>(target: T) => {
     new (...args: any[]): {
@@ -137,6 +131,6 @@ export declare function Declare(declare: DeclareOptions): <T extends {
         guildId?: string[];
         ignore?: IgnoreCommand;
         aliases?: string[];
+        handler?: EntryPointCommandHandlerType;
     };
 } & T;
-export {};

package/lib/commands/decorators.js

@@ -97,6 +97,7 @@ function Declare(declare) {
         guildId;
         ignore;
         aliases;
+        handler;
         constructor(...args) {
             super(...args);
             if ('description' in declare)
@@ -109,6 +110,8 @@ function Declare(declare) {
                 this.ignore = declare.ignore;
             if ('aliases' in declare)
                 this.aliases = declare.aliases;
+            if ('handler' in declare)
+                this.handler = declare.handler;
             // check if all properties are valid
         }
     };

package/lib/commands/handle.d.ts

@@ -1,6 +1,6 @@
 import { type APIApplicationCommandInteraction, type APIInteraction, type GatewayMessageCreateDispatchData, type APIApplicationCommandInteractionDataOption, ApplicationCommandOptionType } from '../types';
-import { Command, type ContextOptionsResolved, type UsingClient, type CommandAutocompleteOption, type ContextMenuCommand, MenuCommandContext, CommandContext, SubCommand, type CommandOption, type MessageCommandOptionErrors } from '.';
-import { AutocompleteInteraction, type ComponentInteraction, type ModalSubmitInteraction, type ChatInputCommandInteraction, type MessageCommandInteraction, type UserCommandInteraction, type __InternalReplyFunction } from '../structures';
+import { Command, type ContextOptionsResolved, type UsingClient, type CommandAutocompleteOption, type ContextMenuCommand, MenuCommandContext, CommandContext, SubCommand, type CommandOption, type MessageCommandOptionErrors, EntryPointContext, type EntryPointCommand } from '.';
+import { AutocompleteInteraction, type ComponentInteraction, type ModalSubmitInteraction, type ChatInputCommandInteraction, type MessageCommandInteraction, type UserCommandInteraction, type __InternalReplyFunction, type EntryPointInteraction } from '../structures';
 import type { PermissionsBitField } from '../structures/extra/Permissions';
 import type { MakeRequired } from '../common';
 import { type MessageStructure, Transformers, type OptionResolverStructure } from '../client/transformers';
@@ -18,6 +18,7 @@ export declare class HandleCommand {
     autocomplete(interaction: AutocompleteInteraction, optionsResolver: OptionResolverStructure, command?: CommandAutocompleteOption): Promise<void>;
     contextMenuMessage(command: ContextMenuCommand, interaction: MessageCommandInteraction, context: MenuCommandContext<MessageCommandInteraction>): Promise<any>;
     contextMenuUser(command: ContextMenuCommand, interaction: UserCommandInteraction, context: MenuCommandContext<UserCommandInteraction>): Promise<any>;
+    entryPoint(command: EntryPointCommand, interaction: EntryPointInteraction, context: EntryPointContext): Promise<any>;
     chatInput(command: Command | SubCommand, interaction: ChatInputCommandInteraction, resolver: OptionResolverStructure, context: CommandContext): Promise<any>;
     modal(interaction: ModalSubmitInteraction): Promise<void>;
     messageComponent(interaction: ComponentInteraction): Promise<void>;
@@ -30,7 +31,7 @@ export declare class HandleCommand {
     getCommandFromContent(commandRaw: string[]): CommandFromContent;
     makeResolver(...args: Parameters<(typeof Transformers)['OptionResolver']>): import("./optionresolver").OptionResolver;
     getParentMessageCommand(rawParentName: string): Command | ContextMenuCommand | undefined;
-    getCommand<T extends Command | ContextMenuCommand>(data: {
+    getCommand<T extends Command | ContextMenuCommand | EntryPointCommand>(data: {
         guild_id?: string;
         name: string;
     }): T | undefined;
@@ -39,11 +40,11 @@ export declare class HandleCommand {
     fetchUser(_option: CommandOptionWithType, query: string): Promise<import("../types").APIUser | null>;
     fetchMember(_option: CommandOptionWithType, query: string, guildId: string): Promise<import("../types").APIGuildMember | null>;
     fetchRole(_option: CommandOptionWithType, query: string, guildId?: string): Promise<import("../types").APIRole | null | undefined>;
-    runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+    runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
         pass?: boolean;
     }>;
-    runMiddlewares(command: Command | ContextMenuCommand | SubCommand, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+    runMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
         pass?: boolean;
     }>;

package/lib/commands/handle.js

@@ -70,6 +70,37 @@ class HandleCommand {
             }
         }
     }
+    async entryPoint(command, interaction, context) {
+        if (command.botPermissions && interaction.appPermissions) {
+            const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
+            if (permissions)
+                return command.onBotPermissionsFail?.(context, permissions);
+        }
+        const resultGlobal = await this.runGlobalMiddlewares(command, context);
+        if (typeof resultGlobal === 'boolean')
+            return;
+        const resultMiddle = await this.runMiddlewares(command, context);
+        if (typeof resultMiddle === 'boolean')
+            return;
+        try {
+            try {
+                await command.run(context);
+                await command.onAfterRun?.(context, undefined);
+            }
+            catch (error) {
+                await command.onRunError(context, error);
+                await command.onAfterRun?.(context, error);
+            }
+        }
+        catch (error) {
+            try {
+                await command.onInternalError(this.client, command, error);
+            }
+            catch {
+                // pass
+            }
+        }
+    }
     async chatInput(command, interaction, resolver, context) {
         if (command.botPermissions && interaction.appPermissions) {
             const permissions = this.checkPermissions(interaction.appPermissions, command.botPermissions);
@@ -145,6 +176,17 @@ class HandleCommand {
                         this.contextMenuUser(data.command, data.interaction, data.context);
                         break;
                     }
+                    case types_1.ApplicationCommandType.PrimaryEntryPoint: {
+                        const command = this.client.commands?.entryPoint;
+                        if (!command?.run)
+                            return;
+                        const interaction = structures_1.BaseInteraction.from(this.client, body, __reply);
+                        const context = new _1.EntryPointContext(this.client, interaction, shardId, command);
+                        const extendContext = this.client.options?.context?.(interaction) ?? {};
+                        Object.assign(context, extendContext);
+                        await this.entryPoint(command, interaction, context);
+                        break;
+                    }
                     case types_1.ApplicationCommandType.ChatInput: {
                         const parentCommand = this.getCommand(body.data);
                         const optionsResolver = this.makeResolver(this.client, body.data.options ?? [], parentCommand, body.guild_id, body.data.resolved);

package/lib/commands/handler.d.ts

@@ -4,10 +4,12 @@ import { BaseHandler } from '../common';
 import { Command, type CommandOption, SubCommand } from './applications/chat';
 import { ContextMenuCommand } from './applications/menu';
 import type { UsingClient } from './applications/shared';
+import type { EntryPointCommand } from '.';
 export declare class CommandHandler extends BaseHandler {
     protected logger: Logger;
     protected client: UsingClient;
     values: (Command | ContextMenuCommand)[];
+    entryPoint: EntryPointCommand | null;
     protected filter: (path: string) => boolean;
     constructor(logger: Logger, client: UsingClient);
     reload(resolve: string | Command): Promise<void>;
@@ -17,8 +19,8 @@ export declare class CommandHandler extends BaseHandler {
     shouldUpload(file: string, guildId?: string): Promise<boolean>;
     set(commands: SeteableCommand[]): void;
     load(commandsDir: string, client: UsingClient): Promise<(Command | ContextMenuCommand)[]>;
-    parseLocales(command: Command | SubCommand | ContextMenuCommand): Command | ContextMenuCommand | SubCommand;
-    parseGlobalLocales(command: Command | SubCommand | ContextMenuCommand): void;
+    parseLocales(command: InstanceType<HandleableCommand>): Command | ContextMenuCommand | EntryPointCommand | SubCommand;
+    parseGlobalLocales(command: InstanceType<HandleableCommand>): void;
     parseCommandOptionLocales(option: MakeRequired<CommandOption, 'locales'>): void;
     parseCommandLocales(command: Command): void;
     parseContextMenuLocales(command: ContextMenuCommand): ContextMenuCommand;
@@ -29,12 +31,12 @@ export declare class CommandHandler extends BaseHandler {
     }> | false;
     stablishSubCommandDefaults(commandInstance: Command, option: SubCommand): SubCommand;
     onFile(file: FileLoaded): HandleableCommand[] | undefined;
-    onCommand(file: HandleableCommand): Command | SubCommand | ContextMenuCommand | false;
+    onCommand(file: HandleableCommand): InstanceType<HandleableCommand> | false;
     onSubCommand(file: HandleableSubCommand): SubCommand | false;
 }
 export type FileLoaded<T = null> = {
     default?: NulleableCoalising<T, HandleableCommand>;
 } & Record<string, NulleableCoalising<T, HandleableCommand>>;
-export type HandleableCommand = new () => Command | SubCommand | ContextMenuCommand;
+export type HandleableCommand = new () => Command | SubCommand | ContextMenuCommand | EntryPointCommand;
 export type SeteableCommand = new () => Extract<InstanceType<HandleableCommand>, SubCommand>;
 export type HandleableSubCommand = new () => SubCommand;

package/lib/commands/handler.js

@@ -11,6 +11,7 @@ class CommandHandler extends common_1.BaseHandler {
     logger;
     client;
     values = [];
+    entryPoint = null;
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts'));
     constructor(logger, client) {
         super(logger);
@@ -287,8 +288,12 @@ class CommandHandler extends common_1.BaseHandler {
                     }
                 }
                 this.stablishContextCommandDefaults(commandInstance);
-                this.values.push(commandInstance);
                 this.parseLocales(commandInstance);
+                if ('handler' in commandInstance && commandInstance.handler) {
+                    this.entryPoint = commandInstance;
+                }
+                else
+                    this.values.push(commandInstance);
             }
         }
         return this.values;

package/lib/commands/index.d.ts

@@ -4,5 +4,7 @@ export * from './applications/chatcontext';
 export * from './applications/menu';
 export * from './applications/menucontext';
 export * from './applications/options';
+export * from './applications/entryPoint';
+export * from './applications/entrycontext';
 export * from './decorators';
 export * from './optionresolver';

package/lib/commands/index.js

@@ -21,5 +21,7 @@ __exportStar(require("./applications/chatcontext"), exports);
 __exportStar(require("./applications/menu"), exports);
 __exportStar(require("./applications/menucontext"), exports);
 __exportStar(require("./applications/options"), exports);
+__exportStar(require("./applications/entryPoint"), exports);
+__exportStar(require("./applications/entrycontext"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./optionresolver"), exports);

package/lib/commands/optionresolver.js

@@ -43,7 +43,7 @@ class OptionResolver {
         return this.hoistedOptions.find(option => option.focused)?.value;
     }
     getAutocomplete() {
-        return (this.getCommand()?.options).find(option => option.name === this.hoistedOptions.find(x => x.focused)?.name);
+        return this.getCommand()?.options?.find(option => option.name === this.hoistedOptions.find(x => x.focused)?.name);
     }
     getParent() {
         return this.parent?.name;

package/lib/common/bot/watcher.d.ts

@@ -1,7 +1,7 @@
 import type { GatewayDispatchPayload, GatewaySendPayload } from '../../types';
 import type { ShardManager, ShardManagerOptions } from '../../websocket';
 import type { MakePartial } from '../types/util';
-export interface WatcherOptions extends MakePartial<Omit<ShardManager['options'], 'handlePayload' | 'info' | 'token' | 'intents'>, 'compress' | 'presence' | 'properties' | 'shardEnd' | 'shardStart' | 'spawnShardDelay' | 'totalShards' | 'url' | 'version'> {
+export interface WatcherOptions extends MakePartial<Omit<ShardManager['options'], 'handlePayload' | 'info' | 'token' | 'intents'>, 'compress' | 'presence' | 'properties' | 'shardEnd' | 'shardStart' | 'spawnShardDelay' | 'totalShards' | 'url' | 'version' | 'resharding' | 'debug'> {
     filePath: string;
     transpileCommand: string;
     srcPath: string;

package/lib/common/it/utils.d.ts

@@ -1,6 +1,13 @@
 import { type EmojiResolvable, type TypeArray, type ColorResolvable, type Logger, type ObjectToLower, type ObjectToSnake } from '..';
 import { type APIPartialEmoji } from '../../types';
-import type { Cache } from '../..';
+import type { Cache } from '../../cache';
+/**
+ * Calculates the shard ID for a guild based on its ID.
+ * @param guildId The ID of the guild.
+ * @param shards The number of shards to calculate the ID for.
+ * @returns The shard ID.
+ */
+export declare function calculateShardId(guildId: string, shards?: number): number;
 /**
  * Resolves the color to a numeric representation.
  * @param color The color to resolve.
@@ -33,9 +40,9 @@ export declare function MergeOptions<T>(defaults: any, ...options: any[]): T;
  * @param func The predicate function used to test elements of the array.
  * @returns An object containing two arrays: one with elements that passed the test and one with elements that did not.
  */
-export declare function filterSplit<Element, Predicate extends (value: Element) => boolean>(arr: Element[], func: Predicate): {
+export declare function filterSplit<Element, Never = Element>(arr: (Element | Never)[], func: (value: Element | Never) => boolean): {
     expect: Element[];
-    never: Element[];
+    never: Never[];
 };
 /**
  * Represents a base handler class.

package/lib/common/it/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplaceRegex = exports.BaseHandler = void 0;
+exports.calculateShardId = calculateShardId;
 exports.resolveColor = resolveColor;
 exports.delay = delay;
 exports.isObject = isObject;
@@ -21,6 +22,15 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const __1 = require("..");
 const types_1 = require("../../types");
+/**
+ * Calculates the shard ID for a guild based on its ID.
+ * @param guildId The ID of the guild.
+ * @param shards The number of shards to calculate the ID for.
+ * @returns The shard ID.
+ */
+function calculateShardId(guildId, shards) {
+    return Number((BigInt(guildId) >> 22n) % BigInt(shards ?? 1));
+}
 /**
  * Resolves the color to a numeric representation.
  * @param color The color to resolve.

package/lib/common/shorters/interaction.d.ts

@@ -2,7 +2,7 @@ import { type ReplyInteractionBody } from '../..';
 import type { InteractionMessageUpdateBodyRequest, MessageWebhookCreateBodyRequest } from '../types/write';
 import { BaseShorter } from './base';
 export declare class InteractionShorter extends BaseShorter {
-    reply(id: string, token: string, body: ReplyInteractionBody): Promise<never>;
+    reply(id: string, token: string, body: ReplyInteractionBody): Promise<import("../../types").RESTPostAPIInteractionCallbackResult>;
     fetchResponse(token: string, messageId: string): Promise<import("../..").WebhookMessage | undefined>;
     fetchOriginal(token: string): Promise<import("../..").WebhookMessage | undefined>;
     editMessage(token: string, messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<import("../..").WebhookMessage>;

package/lib/common/types/util.d.ts

@@ -7,7 +7,7 @@ export type MakePartial<T, K extends keyof T> = Omit<T, K> & {
     [P in K]?: T[P];
 };
 export type DeepPartial<T> = {
-    [K in keyof T]?: T[K] extends Record<any, any> ? DeepPartial<T[K]> : T[K] extends (infer I)[] ? DeepPartial<I>[] : T[K];
+    [K in keyof T]?: T[K] extends Record<any, any> ? DeepPartial<T[K]> : T[K] extends (infer I)[] ? DeepPartial<I>[] : Partial<T[K]>;
 };
 export type OmitInsert<T, K extends keyof T, I> = I extends [] ? Omit<T, K> & I[number] : Omit<T, K> & I;
 export type IntentStrings = (keyof typeof GatewayIntentBits)[];

package/lib/common/types/write.d.ts

@@ -13,8 +13,8 @@ export interface SendResolverProps extends ResolverProps {
 export type MessageCreateBodyRequest = OmitInsert<RESTPostAPIChannelMessageJSONBody, 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type MessageUpdateBodyRequest = OmitInsert<RESTPatchAPIChannelMessageJSONBody, 'components' | 'embeds', ResolverProps>;
 export type MessageWebhookCreateBodyRequest = OmitInsert<RESTPostAPIWebhookWithTokenJSONBody, 'components' | 'embeds' | 'poll', SendResolverProps>;
-export type MessageWebhookUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
-export type InteractionMessageUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export type MessageWebhookUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds' | 'poll', ResolverProps>;
+export type InteractionMessageUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type ComponentInteractionMessageUpdate = OmitInsert<APIInteractionResponseCallbackData, 'components' | 'embeds', ResolverProps>;
 export type InteractionCreateBodyRequest = OmitInsert<APIInteractionResponseChannelMessageWithSource['data'], 'components' | 'embeds' | 'poll', SendResolverProps>;
 export type ModalCreateBodyRequest = APIModalInteractionResponse['data'] | Modal;

package/lib/deps/mixer.js

@@ -26,6 +26,7 @@ function getDescriptors(c) {
  * @returns The mixed class.
  */
 function Mixin(...args) {
+    const ignoreOverwriteToString = Object.keys(Object.getOwnPropertyDescriptors(args[0].prototype)).includes('toString');
     function MixedClass(...constructorArgs) {
         for (const i of args) {
             const descriptors = getDescriptors(i);
@@ -35,10 +36,14 @@ function Mixin(...args) {
                 for (const descriptorK in j) {
                     if (descriptorK === 'constructor')
                         continue;
-                    if (descriptorK in MixedClass.prototype)
+                    if (descriptorK in MixedClass.prototype && descriptorK !== 'toString')
                         continue;
                     const descriptor = j[descriptorK];
                     if (descriptor.value) {
+                        if (descriptorK === 'toString' && ignoreOverwriteToString) {
+                            MixedClass.prototype[descriptorK] = args[0].prototype.toString;
+                            continue;
+                        }
                         MixedClass.prototype[descriptorK] = descriptor.value;
                         continue;
                     }

package/lib/events/handler.js

@@ -111,7 +111,7 @@ class EventHandler extends common_1.BaseHandler {
         const Event = this.values[name];
         if (!Event) {
             return runCache
-                ? this.client.cache.onPacket?.({
+                ? this.client.cache.onPacket({
                     t: name,
                     d: packet,
                 })
@@ -120,7 +120,7 @@ class EventHandler extends common_1.BaseHandler {
         try {
             if (Event.data.once && Event.fired) {
                 return runCache
-                    ? this.client.cache.onPacket?.({
+                    ? this.client.cache.onPacket({
                         t: name,
                         d: packet,
                     })
@@ -129,7 +129,7 @@ class EventHandler extends common_1.BaseHandler {
             Event.fired = true;
             const hook = await RawEvents[name]?.(client, packet);
             if (runCache)
-                await this.client.cache.onPacket?.({
+                await this.client.cache.onPacket({
                     t: name,
                     d: packet,
                 });

package/lib/events/hooks/custom.d.ts

@@ -2,3 +2,4 @@ import type { ClientUserStructure } from '../../client/transformers';
 import type { UsingClient } from '../../commands';
 export declare const BOT_READY: (_self: UsingClient, me: ClientUserStructure) => import("../..").ClientUser;
 export declare const WORKER_READY: (_self: UsingClient, me: ClientUserStructure) => import("../..").ClientUser;
+export declare const WORKER_SHARDS_CONNECTED: (_self: UsingClient, me: ClientUserStructure) => import("../..").ClientUser;

package/lib/events/hooks/custom.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORKER_READY = exports.BOT_READY = void 0;
+exports.WORKER_SHARDS_CONNECTED = exports.WORKER_READY = exports.BOT_READY = void 0;
 const BOT_READY = (_self, me) => {
     return me;
 };
@@ -9,3 +9,7 @@ const WORKER_READY = (_self, me) => {
     return me;
 };
 exports.WORKER_READY = WORKER_READY;
+const WORKER_SHARDS_CONNECTED = (_self, me) => {
+    return me;
+};
+exports.WORKER_SHARDS_CONNECTED = WORKER_SHARDS_CONNECTED;