seyfert 1.5.0 → 2.1.0

package/lib/client/transformers.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformers = void 0;
+const commands_1 = require("../commands");
+const structures_1 = require("../structures");
+const GuildBan_1 = require("../structures/GuildBan");
+class Transformers {
+    static AnonymousGuild(...args) {
+        return new structures_1.AnonymousGuild(...args);
+    }
+    static AutoModerationRule(...args) {
+        return new structures_1.AutoModerationRule(...args);
+    }
+    static BaseChannel(...args) {
+        return new structures_1.BaseChannel(...args);
+    }
+    static BaseGuildChannel(...args) {
+        return new structures_1.BaseGuildChannel(...args);
+    }
+    static TextGuildChannel(...args) {
+        return new structures_1.TextGuildChannel(...args);
+    }
+    static DMChannel(...args) {
+        return new structures_1.DMChannel(...args);
+    }
+    static VoiceChannel(...args) {
+        return new structures_1.VoiceChannel(...args);
+    }
+    static StageChannel(...args) {
+        return new structures_1.StageChannel(...args);
+    }
+    static MediaChannel(...args) {
+        return new structures_1.MediaChannel(...args);
+    }
+    static ForumChannel(...args) {
+        return new structures_1.ForumChannel(...args);
+    }
+    static ThreadChannel(...args) {
+        return new structures_1.ThreadChannel(...args);
+    }
+    static CategoryChannel(...args) {
+        return new structures_1.CategoryChannel(...args);
+    }
+    static NewsChannel(...args) {
+        return new structures_1.NewsChannel(...args);
+    }
+    static DirectoryChannel(...args) {
+        return new structures_1.DirectoryChannel(...args);
+    }
+    static ClientUser(...args) {
+        return new structures_1.ClientUser(...args);
+    }
+    static Guild(...args) {
+        return new structures_1.Guild(...args);
+    }
+    static GuildBan(...args) {
+        return new GuildBan_1.GuildBan(...args);
+    }
+    static GuildEmoji(...args) {
+        return new structures_1.GuildEmoji(...args);
+    }
+    static GuildMember(...args) {
+        return new structures_1.GuildMember(...args);
+    }
+    static InteractionGuildMember(...args) {
+        return new structures_1.InteractionGuildMember(...args);
+    }
+    static GuildRole(...args) {
+        return new structures_1.GuildRole(...args);
+    }
+    static GuildTemplate(...args) {
+        return new structures_1.GuildTemplate(...args);
+    }
+    static Message(...args) {
+        return new structures_1.Message(...args);
+    }
+    static WebhookMessage(...args) {
+        return new structures_1.WebhookMessage(...args);
+    }
+    static Poll(...args) {
+        return new structures_1.Poll(...args);
+    }
+    static Sticker(...args) {
+        return new structures_1.Sticker(...args);
+    }
+    static User(...args) {
+        return new structures_1.User(...args);
+    }
+    static VoiceState(...args) {
+        return new structures_1.VoiceState(...args);
+    }
+    static Webhook(...args) {
+        return new structures_1.Webhook(...args);
+    }
+    static OptionResolver(...args) {
+        return new commands_1.OptionResolver(...args);
+    }
+}
+exports.Transformers = Transformers;

package/lib/client/types.d.ts

@@ -0,0 +1,5 @@
+import type { HttpClient } from './httpclient';
+export interface HttpServerAdapter {
+    client: HttpClient;
+    start?(path: `/${string}`): any;
+}

package/lib/client/types.js

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

package/lib/client/workerclient.d.ts

@@ -1,32 +1,29 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { type GatewayDispatchPayload } from 'discord-api-types/v10';
-import { Logger } from '..';
-import type { Cache } from '../cache';
+import { type GatewayDispatchPayload } from '../types';
 import { type DeepPartial, type When } from '../common';
 import { EventHandler } from '../events';
-import { ClientUser } from '../structures';
-import { Shard, type ShardManagerOptions } from '../websocket';
+import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import type { Client, ClientOptions } from './client';
 import { Collectors } from './collectors';
+import { type ClientUserStructure } from './transformers';
+import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
+import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
-    logger: Logger;
+    memberUpdateHandler: MemberUpdateHandler;
+    presenceUpdateHandler: PresenceUpdateHandler;
     collectors: Collectors;
     events?: EventHandler | undefined;
-    me: When<Ready, ClientUser>;
+    me: When<Ready, ClientUserStructure>;
     promises: Map<string, {
         resolve: (value: any) => void;
         timeout: NodeJS.Timeout;
     }>;
     shards: Map<number, Shard>;
+    private __setServicesCache?;
     options: WorkerClientOptions;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
@@ -36,10 +33,12 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
             events?: EventHandler['callback'];
         };
     }): void;
+    setWorkerData(data: WorkerData): void;
+    get workerData(): WorkerData;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    postMessage(body: any): boolean | void;
-    protected handleManagerMessages(data: ManagerMessages): Promise<any>;
+    postMessage(body: unknown): unknown;
+    handleManagerMessages(data: ManagerMessages): Promise<any>;
     private generateNonce;
     private generateSendPromise;
     tellWorker(workerId: number, func: (_: this) => {}): Promise<unknown>;
@@ -47,9 +46,11 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 interface WorkerClientOptions extends BaseClientOptions {
-    disabledCache: Cache['disabledCache'];
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
     gateway?: ClientOptions['gateway'];
+    postMessage?: (body: unknown) => unknown;
+    /** can have perfomance issues in big bots if the client sends every event, specially in startup (false by default) */
+    sendPayloadToParent?: boolean;
 }
 export {};

package/lib/client/workerclient.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateShardInfo = exports.WorkerClient = void 0;
-const v10_1 = require("discord-api-types/v10");
+exports.WorkerClient = void 0;
+exports.generateShardInfo = generateShardInfo;
+const types_1 = require("../types");
 const node_crypto_1 = require("node:crypto");
 const __1 = require("..");
 const cache_1 = require("../cache");
 const common_1 = require("../common");
 const events_1 = require("../events");
-const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-const onmessagecreate_1 = require("./onmessagecreate");
 const collectors_1 = require("./collectors");
+const transformers_1 = require("./transformers");
+const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
+const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 let workerData;
 let manager;
 try {
@@ -24,59 +25,25 @@ try {
         token: process.env.SEYFERT_WORKER_TOKEN,
         workerId: Number.parseInt(process.env.SEYFERT_WORKER_WORKERID),
         workerProxy: process.env.SEYFERT_WORKER_WORKERPROXY === 'true',
+        totalShards: Number(process.env.SEYFERT_WORKER_TOTALSHARDS),
+        mode: process.env.SEYFERT_WORKER_MODE,
     };
 }
 catch { }
 class WorkerClient extends base_1.BaseClient {
     __handleGuilds = new Set();
-    logger = new __1.Logger({
-        name: `[Worker #${workerData.workerId}]`,
-    });
+    memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
+    presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
     collectors = new collectors_1.Collectors();
     events = new events_1.EventHandler(this);
     me;
     promises = new Map();
     shards = new Map();
+    __setServicesCache;
     constructor(options) {
         super(options);
-        this.options = (0, common_1.MergeOptions)({
-            commands: {
-                argsParser: onmessagecreate_1.defaultArgsParser,
-                optionsParser: onmessagecreate_1.defaultOptionsParser,
-            },
-        }, this.options);
-        if (!process.env.SEYFERT_SPAWNING) {
-            throw new Error('WorkerClient cannot spawn without manager');
-        }
-        this.postMessage({
-            type: 'WORKER_START',
-            workerId: workerData.workerId,
-        });
-        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
-        if (worker_threads?.parentPort) {
-            manager = worker_threads?.parentPort;
-        }
-        (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
-        this.setServices({
-            cache: {
-                adapter: new cache_1.WorkerAdapter(workerData),
-                disabledCache: options?.disabledCache,
-            },
-        });
-        if (workerData.debug) {
-            this.debugger = new __1.Logger({
-                name: `[Worker #${workerData.workerId}]`,
-                logLevel: common_1.LogLevels.Debug,
-            });
-        }
-        if (workerData.workerProxy) {
-            this.setServices({
-                rest: new __1.ApiHandler({
-                    token: workerData.token,
-                    workerProxy: true,
-                    debug: workerData.debug,
-                }),
-            });
+        if (options?.postMessage) {
+            this.postMessage = options.postMessage;
         }
     }
     get workerId() {
@@ -89,22 +56,76 @@ class WorkerClient extends base_1.BaseClient {
     }
     setServices({ ...rest }) {
         super.setServices(rest);
+        if (rest.cache) {
+            this.__setServicesCache = true;
+        }
         if (rest.handlers && 'events' in rest.handlers) {
             if (!rest.handlers.events) {
                 this.events = undefined;
             }
             else if (typeof rest.handlers.events === 'function') {
                 this.events = new events_1.EventHandler(this);
-                this.events.setHandlers({
-                    callback: rest.handlers.events,
-                });
             }
             else {
                 this.events = rest.handlers.events;
             }
         }
     }
+    setWorkerData(data) {
+        workerData = data;
+    }
+    get workerData() {
+        return workerData;
+    }
     async start(options = {}) {
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (worker_threads?.parentPort) {
+            manager = worker_threads?.parentPort;
+        }
+        if (workerData.mode !== 'custom')
+            (manager ?? process).on('message', (data) => this.handleManagerMessages(data));
+        this.logger = new __1.Logger({
+            name: `[Worker #${workerData.workerId}]`,
+        });
+        if (this.__setServicesCache) {
+            this.setServices({
+                cache: {
+                    disabledCache: this.cache.disabledCache,
+                },
+            });
+        }
+        else {
+            const adapter = new cache_1.WorkerAdapter(workerData);
+            if (this.options.postMessage) {
+                adapter.postMessage = this.options.postMessage;
+            }
+            this.setServices({
+                cache: {
+                    adapter,
+                    disabledCache: this.cache.disabledCache,
+                },
+            });
+        }
+        delete this.__setServicesCache;
+        if (workerData.debug) {
+            this.debugger = new __1.Logger({
+                name: `[Worker #${workerData.workerId}]`,
+                logLevel: common_1.LogLevels.Debug,
+            });
+        }
+        if (workerData.workerProxy) {
+            this.setServices({
+                rest: new __1.ApiHandler({
+                    token: workerData.token,
+                    workerProxy: true,
+                    debug: workerData.debug,
+                }),
+            });
+        }
+        this.postMessage({
+            type: 'WORKER_START',
+            workerId: workerData.workerId,
+        });
         await super.start(options);
         await this.loadEvents(options.eventsDir);
         this.cache.intents = workerData.intents;
@@ -164,6 +185,7 @@ class WorkerClient extends base_1.BaseClient {
                     const onPacket = this.onPacket.bind(this);
                     const handlePayload = this.options?.handlePayload?.bind(this);
                     const self = this;
+                    const { sendPayloadToParent } = this.options;
                     for (const id of workerData.shards) {
                         let shard = this.shards.get(id);
                         if (!shard) {
@@ -179,13 +201,14 @@ class WorkerClient extends base_1.BaseClient {
                                 },
                                 async handlePayload(shardId, payload) {
                                     await handlePayload?.(shardId, payload);
-                                    await onPacket?.(payload, shardId);
-                                    self.postMessage({
-                                        workerId: workerData.workerId,
-                                        shardId,
-                                        type: 'RECEIVE_PAYLOAD',
-                                        payload,
-                                    });
+                                    await onPacket(payload, shardId);
+                                    if (sendPayloadToParent)
+                                        self.postMessage({
+                                            workerId: workerData.workerId,
+                                            shardId,
+                                            type: 'RECEIVE_PAYLOAD',
+                                            payload,
+                                        });
                                 },
                             });
                             this.shards.set(id, shard);
@@ -241,7 +264,6 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     let result;
                     try {
-                        // biome-ignore lint/security/noGlobalEval: yes
                         result = await eval(`
 					(${data.func})(this)
 					`);
@@ -297,19 +319,42 @@ class WorkerClient extends base_1.BaseClient {
         return this.generateSendPromise(nonce);
     }
     async onPacket(packet, shardId) {
-        await this.events?.execute('RAW', packet, this, shardId);
+        Promise.allSettled([
+            this.events?.runEvent('RAW', this, packet, shardId, false),
+            this.collectors.run('RAW', packet, this),
+        ]); //ignore promise
         switch (packet.t) {
+            //// Cases where we must obtain the old data before updating
+            case 'GUILD_MEMBER_UPDATE':
+                {
+                    if (!this.memberUpdateHandler.check(packet.d)) {
+                        return;
+                    }
+                    await this.events?.execute(packet.t, packet, this, shardId);
+                }
+                break;
+            case 'PRESENCE_UPDATE':
+                {
+                    if (!this.presenceUpdateHandler.check(packet.d)) {
+                        return;
+                    }
+                    await this.events?.execute(packet.t, packet, this, shardId);
+                }
+                break;
+            case 'GUILD_DELETE':
             case 'GUILD_CREATE': {
                 if (this.__handleGuilds?.has(packet.d.id)) {
-                    this.__handleGuilds.delete(packet.d.id);
-                    if (!this.__handleGuilds.size && [...this.shards.values()].every(shard => shard.data.session_id)) {
+                    this.__handleGuilds?.delete(packet.d.id);
+                    if (!this.__handleGuilds?.size && [...this.shards.values()].every(shard => shard.data.session_id)) {
+                        delete this.__handleGuilds;
+                        await this.cache.onPacket(packet);
                         this.postMessage({
                             type: 'WORKER_READY',
                             workerId: this.workerId,
                         });
-                        await this.events?.runEvent('WORKER_READY', this, this.me, -1);
+                        return this.events?.runEvent('WORKER_READY', this, this.me, -1);
                     }
-                    if (!this.__handleGuilds.size)
+                    if (!this.__handleGuilds?.size)
                         delete this.__handleGuilds;
                     return this.cache.onPacket(packet);
                 }
@@ -317,17 +362,34 @@ class WorkerClient extends base_1.BaseClient {
                 break;
             }
             default: {
-                await this.events?.execute(packet.t, packet, this, shardId);
                 switch (packet.t) {
+                    case 'INTERACTION_CREATE':
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.interaction(packet.d, shardId);
+                        break;
+                    case 'MESSAGE_CREATE':
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.message(packet.d, shardId);
+                        break;
                     case 'READY':
+                        if (!this.__handleGuilds)
+                            this.__handleGuilds = new Set();
                         for (const g of packet.d.guilds) {
                             this.__handleGuilds?.add(g.id);
                         }
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
-                        this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
+                        this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        if ([...this.shards.values()].every(shard => shard.data.session_id)) {
+                            this.postMessage({
+                                type: 'WORKER_SHARDS_CONNECTED',
+                                workerId: this.workerId,
+                            });
+                            await this.events?.runEvent('WORKER_SHARDS_CONNECTED', this, this.me, -1);
+                        }
                         if (!(this.__handleGuilds?.size &&
-                            (workerData.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
+                            (workerData.intents & types_1.GatewayIntentBits.Guilds) === types_1.GatewayIntentBits.Guilds)) {
                             if ([...this.shards.values()].every(shard => shard.data.session_id)) {
                                 this.postMessage({
                                     type: 'WORKER_READY',
@@ -337,13 +399,10 @@ class WorkerClient extends base_1.BaseClient {
                             }
                             delete this.__handleGuilds;
                         }
-                        this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
+                        this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
-                    case 'INTERACTION_CREATE':
-                        await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
-                        break;
-                    case 'MESSAGE_CREATE':
-                        await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
+                    default:
+                        await this.events?.execute(packet.t, packet, this, shardId);
                         break;
                 }
                 break;
@@ -360,4 +419,3 @@ function generateShardInfo(shard) {
         resumable: shard.resumable,
     };
 }
-exports.generateShardInfo = generateShardInfo;

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

@@ -1,21 +1,22 @@
-import { ApplicationCommandOptionType, ApplicationCommandType, type ApplicationIntegrationType, type InteractionContextType, type APIApplicationCommandBasicOption, type APIApplicationCommandOption, type LocaleString } from 'discord-api-types/v10';
+import { ApplicationCommandOptionType, ApplicationCommandType, type ApplicationIntegrationType, type InteractionContextType, type APIApplicationCommandBasicOption, type APIApplicationCommandOption, type LocaleString } from '../../types';
 import type { PermissionStrings, SeyfertNumberOption, SeyfertStringOption } from '../..';
 import type { Attachment } from '../../builders';
-import { type FlatObjectKeys } from '../../common';
-import type { AllChannels, AutocompleteInteraction, GuildRole, InteractionGuildMember, User } from '../../structures';
+import { type Awaitable, type FlatObjectKeys } from '../../common';
+import type { AllChannels, AutocompleteInteraction } from '../../structures';
 import type { Groups, RegisteredMiddlewares } from '../decorators';
 import type { CommandContext } from './chatcontext';
 import type { DefaultLocale, ExtraProps, IgnoreCommand, OKFunction, OnOptionsReturnObject, StopFunction, UsingClient } from './shared';
+import type { GuildRoleStructure, InteractionGuildMemberStructure, UserStructure } from '../../client/transformers';
 export interface ReturnOptionsTypes {
     1: never;
     2: never;
     3: string;
     4: number;
     5: boolean;
-    6: InteractionGuildMember | User;
+    6: InteractionGuildMemberStructure | UserStructure;
     7: AllChannels;
-    8: GuildRole;
-    9: GuildRole | AllChannels | User;
+    8: GuildRoleStructure;
+    9: GuildRoleStructure | AllChannels | UserStructure;
     10: number;
     11: Attachment;
 }
@@ -24,7 +25,7 @@ type Wrap<N extends ApplicationCommandOptionType> = N extends ApplicationCommand
     value?(data: {
         context: CommandContext;
         value: ReturnOptionsTypes[N];
-    }, ok: OKFunction<any>, fail: StopFunction): void;
+    }, ok: OKFunction<any>, fail: StopFunction): Awaitable<void>;
 } & {
     description: string;
     description_localizations?: APIApplicationCommandBasicOption['description_localizations'];
@@ -88,16 +89,16 @@ export declare class BaseCommand {
     aliases?: string[];
     props: ExtraProps;
     toJSON(): {
-        name: BaseCommand['name'];
-        type: BaseCommand['type'];
-        nsfw: BaseCommand['nsfw'];
-        description: BaseCommand['description'];
-        name_localizations: BaseCommand['name_localizations'];
-        description_localizations: BaseCommand['description_localizations'];
-        guild_id: BaseCommand['guildId'];
+        name: BaseCommand["name"];
+        type: BaseCommand["type"];
+        nsfw: BaseCommand["nsfw"];
+        description: BaseCommand["description"];
+        name_localizations: BaseCommand["name_localizations"];
+        description_localizations: BaseCommand["description_localizations"];
+        guild_id: BaseCommand["guildId"];
         default_member_permissions: string;
-        contexts: BaseCommand['contexts'];
-        integration_types: BaseCommand['integrationTypes'];
+        contexts: BaseCommand["contexts"];
+        integration_types: BaseCommand["integrationTypes"];
     };
     reload(): Promise<void>;
     run?(context: CommandContext): any;
@@ -120,16 +121,16 @@ export declare class Command extends BaseCommand {
     }>;
     toJSON(): {
         options: APIApplicationCommandOption[];
-        name: string;
-        type: number;
-        nsfw: boolean | undefined;
-        description: string;
-        name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        guild_id: string[] | undefined;
+        name: BaseCommand["name"];
+        type: BaseCommand["type"];
+        nsfw: BaseCommand["nsfw"];
+        description: BaseCommand["description"];
+        name_localizations: BaseCommand["name_localizations"];
+        description_localizations: BaseCommand["description_localizations"];
+        guild_id: BaseCommand["guildId"];
         default_member_permissions: string;
-        contexts: InteractionContextType[];
-        integration_types: ApplicationIntegrationType[];
+        contexts: BaseCommand["contexts"];
+        integration_types: BaseCommand["integrationTypes"];
     };
 }
 export declare abstract class SubCommand extends BaseCommand {
@@ -138,16 +139,16 @@ export declare abstract class SubCommand extends BaseCommand {
     options?: CommandOption[];
     toJSON(): {
         options: APIApplicationCommandBasicOption[];
-        name: string;
-        type: number;
-        nsfw: boolean | undefined;
-        description: string;
-        name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
-        guild_id: string[] | undefined;
+        name: BaseCommand["name"];
+        type: BaseCommand["type"];
+        nsfw: BaseCommand["nsfw"];
+        description: BaseCommand["description"];
+        name_localizations: BaseCommand["name_localizations"];
+        description_localizations: BaseCommand["description_localizations"];
+        guild_id: BaseCommand["guildId"];
         default_member_permissions: string;
-        contexts: InteractionContextType[];
-        integration_types: ApplicationIntegrationType[];
+        contexts: BaseCommand["contexts"];
+        integration_types: BaseCommand["integrationTypes"];
     };
     abstract run(context: CommandContext<any>): any;
 }

package/lib/commands/applications/chat.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubCommand = exports.Command = exports.BaseCommand = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../../types");
 const common_1 = require("../../common");
 const node_util_1 = require("node:util");
 class BaseCommand {
@@ -35,9 +35,7 @@ class BaseCommand {
             try {
                 const option = this.options.find(x => x.name === i.name);
                 const value = resolver.getHoisted(i.name)?.value !== undefined
-                    ? await new Promise(
-                    // biome-ignore lint/suspicious/noAsyncPromiseExecutor: yes
-                    async (res, rej) => {
+                    ? await new Promise(async (res, rej) => {
                         try {
                             (await option.value?.({ context: ctx, value: resolver.getValue(i.name) }, res, rej)) ||
                                 res(resolver.getValue(i.name));
@@ -95,8 +93,6 @@ class BaseCommand {
                 if (!running) {
                     return;
                 }
-                // biome-ignore lint/style/noArguments: yes
-                // biome-ignore lint/correctness/noUndeclaredVariables: xd
                 if (arguments.length) {
                     // @ts-expect-error
                     context[global ? 'globalMetadata' : 'metadata'][middlewares[index]] = obj;
@@ -153,7 +149,7 @@ class BaseCommand {
 }
 exports.BaseCommand = BaseCommand;
 class Command extends BaseCommand {
-    type = v10_1.ApplicationCommandType.ChatInput;
+    type = types_1.ApplicationCommandType.ChatInput;
     groups;
     groupsAliases;
     __tGroups;
@@ -167,7 +163,7 @@ class Command extends BaseCommand {
             if (i.group) {
                 if (!options.find(x => x.name === i.group)) {
                     options.push({
-                        type: v10_1.ApplicationCommandOptionType.SubcommandGroup,
+                        type: types_1.ApplicationCommandOptionType.SubcommandGroup,
                         name: i.group,
                         description: this.groups[i.group].defaultDescription,
                         description_localizations: Object.fromEntries(this.groups?.[i.group].description ?? []),
@@ -189,7 +185,7 @@ class Command extends BaseCommand {
 }
 exports.Command = Command;
 class SubCommand extends BaseCommand {
-    type = v10_1.ApplicationCommandOptionType.Subcommand;
+    type = types_1.ApplicationCommandOptionType.Subcommand;
     group;
     toJSON() {
         return {