seyfert 1.3.3 → 1.4.0

package/lib/api/api.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiHandler = void 0;
 const magic_bytes_js_1 = require("magic-bytes.js");
 const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:timers/promises");
-const node_worker_threads_1 = require("node:worker_threads");
 const common_1 = require("../common");
 const functions_1 = require("../structures/extra/functions");
 const Router_1 = require("./Router");
 const bucket_1 = require("./bucket");
 const shared_1 = require("./shared");
 const utils_1 = require("./utils/utils");
+let parentPort;
+let workerData;
 class ApiHandler {
     options;
     globalBlock = false;
@@ -32,10 +32,16 @@ class ApiHandler {
                 name: '[API]',
             });
         }
-        if (options.workerProxy && !node_worker_threads_1.parentPort)
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (options.workerProxy && !worker_threads?.parentPort)
             throw new Error('Cannot use workerProxy without a parent.');
         if (options.workerProxy)
             this.workerPromises = new Map();
+        if (worker_threads) {
+            workerData = worker_threads.workerData;
+            if (worker_threads.parentPort)
+                parentPort = worker_threads.parentPort;
+        }
     }
     globalUnblock() {
         this.globalBlock = false;
@@ -53,11 +59,11 @@ class ApiHandler {
     async request(method, url, { auth = true, ...request } = {}) {
         if (this.options.workerProxy) {
             const nonce = this.#randomUUID();
-            node_worker_threads_1.parentPort.postMessage({
+            parentPort.postMessage({
                 method,
                 url,
                 type: 'WORKER_API_REQUEST',
-                workerId: node_worker_threads_1.workerData.workerId,
+                workerId: workerData.workerId,
                 nonce,
                 requestOptions: { auth, ...request },
             }, request.files
@@ -182,7 +188,7 @@ class ApiHandler {
         const wait = Math.floor(Math.random() * 1900 + 100);
         this.debugger?.warn(`Handling a 50X status, retrying in ${wait}ms`);
         next();
-        await (0, promises_1.setTimeout)(wait);
+        await (0, common_1.delay)(wait);
         return this.request(method, url, {
             body: request.body,
             auth: request.auth,
@@ -204,7 +210,7 @@ class ApiHandler {
         }
         this.debugger?.info(`${response.headers.get('x-ratelimit-global') ? 'Global' : 'Unexpected'} 429: ${result}\n${content} ${now} ${route} ${response.status}: ${this.ratelimits.get(route).remaining}/${this.ratelimits.get(route).limit} left | Reset ${retryAfter} (${this.ratelimits.get(route).reset - now}ms left) | Scope ${response.headers.get('x-ratelimit-scope')}`);
         if (retryAfter) {
-            await (0, promises_1.setTimeout)(retryAfter);
+            await (0, common_1.delay)(retryAfter);
             next();
             return this.request(method, url, {
                 body: request.body,

package/lib/builders/Attachment.d.ts

@@ -94,10 +94,7 @@ export declare function resolveFiles(resources: (AttachmentBuilder | RawFile | A
  */
 export declare function resolveAttachmentData(data: AttachmentResolvable, type: AttachmentDataType): Promise<{
     data: AttachmentResolvable;
-    contentType?: undefined;
-} | {
-    data: Buffer;
-    contentType: string | null;
+    contentType?: string | null;
 }>;
 /**
  * Resolves a base64 data to a data URL.

package/lib/builders/Attachment.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveImage = exports.resolveBase64 = exports.resolveAttachmentData = exports.resolveFiles = exports.resolveAttachment = exports.AttachmentBuilder = exports.Attachment = void 0;
 const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const __1 = require("..");
 const Base_1 = require("../structures/extra/Base");
+const node_fs_1 = require("node:fs");
 class Attachment extends Base_1.Base {
     data;
     constructor(client, data) {
@@ -24,7 +24,7 @@ class AttachmentBuilder {
      * Creates a new Attachment instance.
      * @param data - The partial attachment data.
      */
-    constructor(data = { name: `${(0, node_crypto_1.randomBytes)(8).toString('base64url')}.jpg` }) {
+    constructor(data = { name: `${((0, node_crypto_1.randomBytes)?.(8))?.toString('base64url') || 'default'}.jpg` }) {
         this.data = data;
     }
     /**
@@ -163,10 +163,10 @@ async function resolveAttachmentData(data, type) {
         }
         case 'path': {
             const file = node_path_1.default.resolve(data);
-            const stats = await (0, promises_1.stat)(file);
+            const stats = await node_fs_1.promises.stat(file);
             if (!stats.isFile())
                 return (0, __1.throwError)(`The attachment type has been expressed as ${type.toUpperCase()} but cannot be resolved as one.`);
-            return { data: await (0, promises_1.readFile)(file) };
+            return { data: await node_fs_1.promises.readFile(file) };
         }
         case 'buffer': {
             if (Buffer.isBuffer(data))

package/lib/cache/adapters/workeradapter.js

@@ -2,17 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerAdapter = void 0;
 const node_crypto_1 = require("node:crypto");
-const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../../common");
+let parentPort;
 class WorkerAdapter {
     workerData;
     isAsync = true;
     promises = new Map();
     constructor(workerData) {
         this.workerData = workerData;
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (worker_threads?.parentPort)
+            parentPort = worker_threads.parentPort;
     }
     postMessage(body) {
-        if (node_worker_threads_1.parentPort)
-            return node_worker_threads_1.parentPort.postMessage(body);
+        if (parentPort)
+            return parentPort.postMessage(body);
         return process.send(body);
     }
     send(method, ...args) {

package/lib/cache/resources/default/base.d.ts

@@ -1,10 +1,9 @@
 import type { GatewayIntentBits } from 'discord-api-types/v10';
-import type { BaseClient } from '../../../client/base';
 import type { UsingClient } from '../../../commands';
 import type { Cache, ReturnCache } from '../../index';
 export declare class BaseResource<T = any> {
     protected cache: Cache;
-    client: BaseClient;
+    client: UsingClient;
     namespace: string;
     constructor(cache: Cache, client?: UsingClient);
     filter(data: any, id: string): boolean;

package/lib/cache/resources/default/guild-based.d.ts

@@ -1,10 +1,9 @@
 import type { GatewayIntentBits } from 'discord-api-types/v10';
-import type { BaseClient } from '../../../client/base';
 import type { UsingClient } from '../../../commands';
 import type { Cache, ReturnCache } from '../../index';
 export declare class GuildBasedResource<T = any> {
     protected cache: Cache;
-    client: BaseClient;
+    client: UsingClient;
     namespace: string;
     constructor(cache: Cache, client?: UsingClient);
     filter(data: any, id: string, guild_id: string): boolean;

package/lib/client/base.d.ts

@@ -5,11 +5,12 @@ import type { Command, RegisteredMiddlewares } from '../commands';
 import { type InferWithPrefix, type MiddlewareContext } from '../commands/applications/shared';
 import { CommandHandler } from '../commands/handler';
 import { ChannelShorter, EmojiShorter, GuildShorter, InteractionShorter, Logger, MemberShorter, MessageShorter, ReactionShorter, RoleShorter, TemplateShorter, ThreadShorter, UsersShorter, WebhookShorter, type MakeRequired } from '../common';
-import type { LocaleString } from 'discord-api-types/rest/v10';
+import type { LocaleString, RESTPostAPIChannelMessageJSONBody } from 'discord-api-types/rest/v10';
 import type { DeepPartial, IntentStrings, OmitInsert, When } from '../common/types/util';
 import { ComponentHandler } from '../components/handler';
 import { LangsHandler } from '../langs/handler';
-import type { ChatInputCommandInteraction, ComponentInteraction, Message, MessageCommandInteraction, UserCommandInteraction } from '../structures';
+import type { ChatInputCommandInteraction, ComponentInteraction, Message, MessageCommandInteraction, ModalSubmitInteraction, UserCommandInteraction } from '../structures';
+import type { ComponentCommand, ModalCommand } from '../components';
 export declare class BaseClient {
     rest: ApiHandler;
     cache: Cache;
@@ -35,7 +36,7 @@ export declare class BaseClient {
     middlewares?: Record<string, MiddlewareContext>;
     protected static assertString(value: unknown, message?: string): asserts value is string;
     protected static getBotIdFromToken(token: string): string;
-    options: BaseClientOptions | undefined;
+    options: BaseClientOptions;
     constructor(options?: BaseClientOptions);
     set botId(id: string);
     get botId(): string;
@@ -46,6 +47,7 @@ export declare class BaseClient {
     protected execute(..._options: unknown[]): Promise<void>;
     start(options?: Pick<DeepPartial<StartOptions>, 'langsDir' | 'commandsDir' | 'connection' | 'token' | 'componentsDir'>): Promise<void>;
     protected onPacket(..._packet: unknown[]): Promise<void>;
+    shouldUploadCommands(cachePath: string): Promise<boolean>;
     uploadCommands(applicationId?: string): Promise<void>;
     loadCommands(dir?: string): Promise<void>;
     loadComponents(dir?: string): Promise<void>;
@@ -66,7 +68,7 @@ export declare class BaseClient {
     }>;
 }
 export interface BaseClientOptions {
-    context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | When<InferWithPrefix, Message, never>) => {};
+    context?: (interaction: ChatInputCommandInteraction<boolean> | UserCommandInteraction<boolean> | MessageCommandInteraction<boolean> | ComponentInteraction | ModalSubmitInteraction | When<InferWithPrefix, Message, never>) => {};
     globalMiddlewares?: readonly (keyof RegisteredMiddlewares)[];
     commands?: {
         defaults?: {
@@ -79,6 +81,25 @@ export interface BaseClientOptions {
             onAfterRun?: Command['onAfterRun'];
         };
     };
+    components?: {
+        defaults?: {
+            onRunError?: ComponentCommand['onRunError'];
+            onInternalError?: ComponentCommand['onInternalError'];
+            onMiddlewaresError?: ComponentCommand['onMiddlewaresError'];
+            onAfterRun?: ComponentCommand['onAfterRun'];
+        };
+    };
+    modals?: {
+        defaults?: {
+            onRunError?: ModalCommand['onRunError'];
+            onInternalError?: ModalCommand['onInternalError'];
+            onMiddlewaresError?: ModalCommand['onMiddlewaresError'];
+            onAfterRun?: ModalCommand['onAfterRun'];
+        };
+    };
+    allowedMentions?: Omit<NonNullable<RESTPostAPIChannelMessageJSONBody['allowed_mentions']>, 'parse'> & {
+        parse?: ('everyone' | 'roles' | 'users')[];
+    };
 }
 export interface StartOptions {
     eventsDir: string;
@@ -91,6 +112,7 @@ export interface StartOptions {
     httpConnection: {
         publicKey: string;
         port: number;
+        useUWS: boolean;
     };
     token: string;
 }

package/lib/client/base.js

@@ -9,6 +9,7 @@ const handler_1 = require("../commands/handler");
 const common_1 = require("../common");
 const handler_2 = require("../components/handler");
 const handler_3 = require("../langs/handler");
+const node_fs_1 = require("node:fs");
 class BaseClient {
     rest;
     cache;
@@ -43,6 +44,8 @@ class BaseClient {
         return Buffer.from(token.split('.')[0], 'base64').toString('ascii');
     }
     options;
+    /**@internal */
+    static _seyferHttpConfig;
     constructor(options) {
         this.options = (0, common_1.MergeOptions)({
             commands: {
@@ -67,6 +70,32 @@ class BaseClient {
                     },
                 },
             },
+            components: {
+                defaults: {
+                    onRunError(context, error) {
+                        context.client.logger.fatal('ComponentCommand.<onRunError>', context.author.id, error);
+                    },
+                    onMiddlewaresError(context, error) {
+                        context.client.logger.fatal('ComponentCommand.<onMiddlewaresError>', context.author.id, error);
+                    },
+                    onInternalError(client, error) {
+                        client.logger.fatal(error);
+                    },
+                },
+            },
+            modals: {
+                defaults: {
+                    onRunError(context, error) {
+                        context.client.logger.fatal('ComponentCommand.<onRunError>', context.author.id, error);
+                    },
+                    onMiddlewaresError(context, error) {
+                        context.client.logger.fatal('ComponentCommand.<onMiddlewaresError>', context.author.id, error);
+                    },
+                    onInternalError(client, error) {
+                        client.logger.fatal(error);
+                    },
+                },
+            },
         }, options);
     }
     set botId(id) {
@@ -178,6 +207,13 @@ class BaseClient {
     async onPacket(..._packet) {
         throw new Error('Function not implemented');
     }
+    shouldUploadCommands(cachePath) {
+        return this.commands.shouldUpload(cachePath).then(async (should) => {
+            if (should)
+                await node_fs_1.promises.writeFile(cachePath, JSON.stringify(this.commands.values.map(x => x.toJSON())));
+            return should;
+        });
+    }
     async uploadCommands(applicationId) {
         applicationId ??= await this.getRC().then(x => x.applicationId ?? this.applicationId);
         BaseClient.assertString(applicationId, 'applicationId is not a string');
@@ -228,8 +264,10 @@ class BaseClient {
         return this.langs.get(locale);
     }
     async getRC() {
-        const { locations, debug, ...env } = (await (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), 'seyfert.config.js')).then(x => x.default ?? x));
-        return {
+        const seyfertConfig = (BaseClient._seyferHttpConfig ||
+            (await (0, common_1.magicImport)((0, node_path_1.join)(process.cwd(), 'seyfert.config.js')).then(x => x.default ?? x)));
+        const { locations, debug, ...env } = seyfertConfig;
+        const obj = {
             debug: !!debug,
             ...env,
             templates: locations.templates ? (0, node_path_1.join)(process.cwd(), locations.base, locations.templates) : undefined,
@@ -240,6 +278,8 @@ class BaseClient {
             base: (0, node_path_1.join)(process.cwd(), locations.base),
             output: (0, node_path_1.join)(process.cwd(), locations.output),
         };
+        BaseClient._seyferHttpConfig = seyfertConfig;
+        return obj;
     }
 }
 exports.BaseClient = BaseClient;

package/lib/client/client.d.ts

@@ -1,6 +1,6 @@
 import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
 import type { Command, CommandContext, Message, SubCommand } from '..';
-import type { DeepPartial, If } from '../common';
+import { type DeepPartial, type If } from '../common';
 import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
@@ -13,7 +13,7 @@ export declare class Client<Ready extends boolean = boolean> extends BaseClient
     gateway: ShardManager;
     events?: EventHandler | undefined;
     me: If<Ready, ClientUser>;
-    options: ClientOptions | undefined;
+    options: ClientOptions;
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
     constructor(options?: ClientOptions);
@@ -46,7 +46,7 @@ export interface ClientOptions extends BaseClientOptions {
         prefix?: (message: Message) => Promise<string[]> | string[];
         deferReplyResponse?: (ctx: CommandContext) => Parameters<Message['write']>[0];
         reply?: (ctx: CommandContext) => boolean;
-        argsParser?: (content: string, command: SubCommand | Command) => Record<string, string>;
+        argsParser?: (content: string, command: SubCommand | Command, message: Message) => Record<string, string>;
     };
     handlePayload?: ShardManagerOptions['handlePayload'];
 }

package/lib/client/client.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const v10_1 = require("discord-api-types/v10");
-const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../common");
 const events_1 = require("../events");
 const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
@@ -11,6 +11,7 @@ const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
+let parentPort;
 class Client extends base_1.BaseClient {
     __handleGuilds = new Set();
     gateway;
@@ -56,11 +57,15 @@ class Client extends base_1.BaseClient {
     }
     async execute(options = {}) {
         await super.execute(options);
-        if (!node_worker_threads_1.workerData?.__USING_WATCHER__) {
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (worker_threads?.parentPort) {
+            parentPort = worker_threads.parentPort;
+        }
+        if (!worker_threads?.workerData?.__USING_WATCHER__) {
             await this.gateway.spawnShards();
         }
         else {
-            node_worker_threads_1.parentPort?.on('message', (data) => {
+            parentPort?.on('message', (data) => {
                 switch (data.type) {
                     case 'PAYLOAD':
                         this.gateway.options.handlePayload(data.shardId, data.payload);
@@ -126,12 +131,19 @@ class Client extends base_1.BaseClient {
             case 'MESSAGE_UPDATE':
             case 'MESSAGE_DELETE_BULK':
             case 'MESSAGE_DELETE':
-                await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
-                break;
             case 'GUILD_DELETE':
             case 'CHANNEL_UPDATE':
+            case 'GUILD_EMOJIS_UPDATE':
+            case 'GUILD_UPDATE':
+            case 'GUILD_ROLE_UPDATE':
+            case 'GUILD_ROLE_DELETE':
+            case 'THREAD_UPDATE':
+            case 'USER_UPDATE':
+            case 'VOICE_STATE_UPDATE':
+            case 'STAGE_INSTANCE_UPDATE':
+            case 'GUILD_STICKERS_UPDATE':
                 await this.events?.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
                 break;
             //rest of the events
             default: {

package/lib/client/httpclient.d.ts

@@ -1,20 +1,19 @@
 /// <reference types="node" />
 import { type APIInteraction } from 'discord-api-types/v10';
 import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
-import type { DeepPartial } from '../common';
+import { type DeepPartial } from '../common';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 export declare class HttpClient extends BaseClient {
-    app: ReturnType<typeof import('uWebSockets.js').App>;
+    app?: ReturnType<typeof import('uWebSockets.js').App>;
     publicKey: string;
     publicKeyHex: Buffer;
     constructor(options?: BaseClientOptions);
     protected static readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
-    protected execute(options?: {
-        publicKey?: string;
-        port?: number;
-    }): Promise<void>;
-    start(options?: DeepPartial<Omit<StartOptions, 'connection'>>): Promise<void>;
+    protected execute(options: DeepPartial<StartOptions['httpConnection']>): Promise<void>;
+    start(options?: DeepPartial<Omit<StartOptions, 'connection' | 'eventsDir'>>): Promise<void>;
+    protected verifySignatureGenericRequest(req: Request): Promise<APIInteraction | undefined>;
     protected verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
-    onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
+    fetch(req: Request): Promise<Response>;
+    protected onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
 }

package/lib/client/httpclient.js

@@ -5,6 +5,7 @@ const v10_1 = require("discord-api-types/v10");
 const magic_bytes_js_1 = require("magic-bytes.js");
 const api_1 = require("../api");
 const utils_1 = require("../api/utils/utils");
+const common_1 = require("../common");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 let UWS;
@@ -27,9 +28,9 @@ class HttpClient extends base_1.BaseClient {
     publicKeyHex;
     constructor(options) {
         super(options);
-        if (!UWS) {
-            throw new Error('No uws installed.');
-        }
+        // if (!UWS) {
+        // 	throw new Error('No uws installed.');
+        // }
         if (!nacl) {
             throw new Error('No tweetnacl installed.');
         }
@@ -60,8 +61,8 @@ class HttpClient extends base_1.BaseClient {
     async execute(options) {
         await super.execute();
         const { publicKey: publicKeyRC, port: portRC, applicationId: applicationIdRC, } = await this.getRC();
-        const publicKey = options?.publicKey ?? publicKeyRC;
-        const port = options?.port ?? portRC;
+        const publicKey = options.publicKey ?? publicKeyRC;
+        const port = options.port ?? portRC;
         if (!publicKey) {
             throw new Error('Expected a publicKey, check your config file');
         }
@@ -73,17 +74,33 @@ class HttpClient extends base_1.BaseClient {
         }
         this.publicKey = publicKey;
         this.publicKeyHex = Buffer.from(this.publicKey, 'hex');
-        this.app = UWS.App();
-        this.app.post('/interactions', (res, req) => {
-            return this.onPacket(res, req);
-        });
-        this.app.listen(port, () => {
-            this.logger.info(`Listening to port ${port}`);
-        });
+        if (UWS && options.useUWS) {
+            this.app = UWS.App();
+            this.app.post('/interactions', (res, req) => {
+                return this.onPacket(res, req);
+            });
+            this.app.listen(port, () => {
+                this.logger.info(`Listening to <url>:${port}/interactions`);
+            });
+        }
+        else {
+            if (options.useUWS)
+                return this.logger.warn('No uWebSockets installed.');
+            this.logger.info('Use your preferred http server and invoke <HttpClient>.fetch(<Request>) to get started');
+        }
     }
     async start(options = {}) {
         await super.start(options);
-        return this.execute(options.httpConnection);
+        return this.execute((0, common_1.MergeOptions)({ useUWS: true }, options.httpConnection));
+    }
+    async verifySignatureGenericRequest(req) {
+        const timestamp = req.headers.get('x-signature-timestamp');
+        const ed25519 = req.headers.get('x-signature-ed25519') ?? '';
+        const body = (await req.json());
+        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
+            return body;
+        }
+        return;
     }
     // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
     async verifySignature(res, req) {
@@ -95,6 +112,68 @@ class HttpClient extends base_1.BaseClient {
         }
         return;
     }
+    async fetch(req) {
+        const rawBody = await this.verifySignatureGenericRequest(req);
+        if (!rawBody) {
+            this.debugger?.debug('Invalid request/No info, returning 418 status.');
+            // I'm a teapot
+            return new Response('', { status: 418 });
+        }
+        switch (rawBody.type) {
+            case v10_1.InteractionType.Ping:
+                this.debugger?.debug('Ping interaction received, responding.');
+                return Response.json({ type: v10_1.InteractionResponseType.Pong }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+            default:
+                return new Promise(r => {
+                    if ((0, common_1.isCloudfareWorker)())
+                        return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1)
+                            .then(() => r(new Response()))
+                            .catch(() => r(new Response()));
+                    return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
+                        let response;
+                        const headers = {};
+                        if (files) {
+                            response = new FormData();
+                            for (const [index, file] of files.entries()) {
+                                const fileKey = file.key ?? `files[${index}]`;
+                                if ((0, utils_1.isBufferLike)(file.data)) {
+                                    let contentType = file.contentType;
+                                    if (!contentType) {
+                                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
+                                        if (parsedType) {
+                                            contentType =
+                                                api_1.OverwrittenMimeTypes[parsedType.mime] ??
+                                                    parsedType.mime ??
+                                                    'application/octet-stream';
+                                        }
+                                    }
+                                    response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
+                                }
+                                else {
+                                    response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                                }
+                            }
+                            if (body) {
+                                response.append('payload_json', JSON.stringify(body));
+                            }
+                        }
+                        else {
+                            response = body ?? {};
+                            headers['Content-Type'] = 'application/json';
+                        }
+                        r(response instanceof FormData
+                            ? new Response(response, { headers })
+                            : Response.json(response, {
+                                headers,
+                            }));
+                    });
+                });
+        }
+    }
     async onPacket(res, req) {
         const rawBody = await this.verifySignature(res, req);
         if (!rawBody) {

package/lib/client/oninteractioncreate.d.ts

@@ -1,4 +1,4 @@
 import { type APIInteraction } from 'discord-api-types/v10';
+import { type UsingClient } from '../commands';
 import type { __InternalReplyFunction } from '../structures';
-import type { BaseClient } from './base';
-export declare function onInteractionCreate(self: BaseClient, body: APIInteraction, shardId: number, __reply?: __InternalReplyFunction): Promise<any>;
+export declare function onInteractionCreate(self: UsingClient, body: APIInteraction, shardId: number, __reply?: __InternalReplyFunction): Promise<any>;