seyfert 1.3.3 → 1.5.0

package/lib/client/base.js

@@ -9,6 +9,8 @@ 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");
+const bans_1 = require("../common/shorters/bans");
 class BaseClient {
     rest;
     cache;
@@ -23,6 +25,7 @@ class BaseClient {
     reactions = new common_1.ReactionShorter(this);
     emojis = new common_1.EmojiShorter(this);
     threads = new common_1.ThreadShorter(this);
+    bans = new bans_1.BanShorter(this);
     interactions = new common_1.InteractionShorter(this);
     debugger;
     logger = new common_1.Logger({
@@ -43,6 +46,8 @@ class BaseClient {
         return Buffer.from(token.split('.')[0], 'base64').toString('ascii');
     }
     options;
+    /**@internal */
+    static _seyfertConfig;
     constructor(options) {
         this.options = (0, common_1.MergeOptions)({
             commands: {
@@ -67,13 +72,39 @@ 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) {
         this._botId = id;
     }
     get botId() {
-        return this._botId ?? BaseClient.getBotIdFromToken(this.rest.options.token);
+        return (this._botId ?? BaseClient.getBotIdFromToken(this.rest.options.token));
     }
     set applicationId(id) {
         this._applicationId = id;
@@ -84,7 +115,7 @@ class BaseClient {
     get proxy() {
         return new api_1.Router(this.rest).createProxy();
     }
-    setServices({ rest, cache, langs, middlewares, handlers }) {
+    setServices({ rest, cache, langs, middlewares, handlers, }) {
         if (rest) {
             this.rest = rest;
         }
@@ -101,7 +132,9 @@ class BaseClient {
                 }
                 else if (typeof handlers.components === 'function') {
                     this.components ??= new handler_2.ComponentHandler(this.logger, this);
-                    this.components.setHandlers({ callback: handlers.components });
+                    this.components.setHandlers({
+                        callback: handlers.components,
+                    });
                 }
                 else {
                     this.components = handlers.components;
@@ -168,23 +201,32 @@ class BaseClient {
                 debug: (await this.getRC()).debug,
             });
         }
-        if (!this.cache) {
-            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
+        if (this.cache) {
+            this.cache.__setClient(this);
         }
         else {
-            this.cache.__setClient(this);
+            this.cache = new cache_1.Cache(0, new cache_1.MemoryAdapter(), [], this);
         }
     }
     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);
+        applicationId ??= await this.getRC().then((x) => x.applicationId ?? this.applicationId);
         BaseClient.assertString(applicationId, 'applicationId is not a string');
         const commands = this.commands.values;
-        const filter = (0, common_1.filterSplit)(commands, command => !command.guildId);
+        const filter = (0, common_1.filterSplit)(commands, (command) => !command.guildId);
         await this.proxy.applications(applicationId).commands.put({
-            body: filter.expect.filter(cmd => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash).map(x => x.toJSON()),
+            body: filter.expect
+                .filter((cmd) => !('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash)
+                .map((x) => x.toJSON()),
         });
         const guilds = new Set();
         for (const command of filter.never) {
@@ -198,27 +240,29 @@ class BaseClient {
                 .guilds(guild)
                 .commands.put({
                 body: filter.never
-                    .filter(cmd => cmd.guildId?.includes(guild) && (!('ignore' in cmd) || cmd.ignore !== shared_1.IgnoreCommand.Slash))
-                    .map(x => x.toJSON()),
+                    .filter((cmd) => cmd.guildId?.includes(guild) &&
+                    (!('ignore' in cmd) ||
+                        cmd.ignore !== shared_1.IgnoreCommand.Slash))
+                    .map((x) => x.toJSON()),
             });
         }
     }
     async loadCommands(dir) {
-        dir ??= await this.getRC().then(x => x.commands);
+        dir ??= await this.getRC().then((x) => x.commands);
         if (dir && this.commands) {
             await this.commands.load(dir, this);
             this.logger.info('CommandHandler loaded');
         }
     }
     async loadComponents(dir) {
-        dir ??= await this.getRC().then(x => x.components);
+        dir ??= await this.getRC().then((x) => x.components);
         if (dir && this.components) {
             await this.components.load(dir);
             this.logger.info('ComponentHandler loaded');
         }
     }
     async loadLangs(dir) {
-        dir ??= await this.getRC().then(x => x.langs);
+        dir ??= await this.getRC().then((x) => x.langs);
         if (dir && this.langs) {
             await this.langs.load(dir);
             this.logger.info('LangsHandler loaded');
@@ -228,18 +272,33 @@ 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._seyfertConfig ||
+            (await this.options.getRC?.()) ||
+            (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,
-            langs: locations.langs ? (0, node_path_1.join)(process.cwd(), locations.output, locations.langs) : undefined,
-            events: 'events' in locations && locations.events ? (0, node_path_1.join)(process.cwd(), locations.output, locations.events) : undefined,
-            components: locations.components ? (0, node_path_1.join)(process.cwd(), locations.output, locations.components) : undefined,
-            commands: locations.commands ? (0, node_path_1.join)(process.cwd(), locations.output, locations.commands) : undefined,
+            templates: locations.templates
+                ? (0, node_path_1.join)(process.cwd(), locations.base, locations.templates)
+                : undefined,
+            langs: locations.langs
+                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.langs)
+                : undefined,
+            events: 'events' in locations && locations.events
+                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.events)
+                : undefined,
+            components: locations.components
+                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.components)
+                : undefined,
+            commands: locations.commands
+                ? (0, node_path_1.join)(process.cwd(), locations.output, locations.commands)
+                : undefined,
             base: (0, node_path_1.join)(process.cwd(), locations.base),
             output: (0, node_path_1.join)(process.cwd(), locations.output),
         };
+        BaseClient._seyfertConfig = 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 APIApplicationCommandInteractionDataOption, type GatewayMessageCreateDispatchData, type GatewayDispatchPayload, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
+import type { Command, CommandContext, ContextOptionsResolved, Message, MessageCommandOptionErrors, SubCommand, UsingClient } from '..';
+import { type Awaitable, type MakeRequired, type DeepPartial, type If } from '../common';
 import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
@@ -8,14 +8,18 @@ import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
+import { Collectors } from './collectors';
 export declare class Client<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     gateway: ShardManager;
-    events?: EventHandler | undefined;
     me: If<Ready, ClientUser>;
-    options: ClientOptions | undefined;
+    options: Omit<ClientOptions, 'commands'> & {
+        commands: MakeRequired<NonNullable<ClientOptions['commands']>, 'argsParser' | 'optionsParser'>;
+    };
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
+    collectors: Collectors;
+    events?: EventHandler | undefined;
     constructor(options?: ClientOptions);
     setServices({ gateway, ...rest }: ServicesOptions & {
         gateway?: ShardManager;
@@ -46,7 +50,15 @@ 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>;
+        optionsParser?: (self: UsingClient, command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>) => Awaitable<{
+            errors: {
+                name: string;
+                error: string;
+                fullError: MessageCommandOptionErrors;
+            }[];
+            options: APIApplicationCommandInteractionDataOption[];
+        }>;
     };
     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,15 +11,25 @@ const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
+const collectors_1 = require("./collectors");
+let parentPort;
 class Client extends base_1.BaseClient {
     __handleGuilds = new Set();
     gateway;
-    events = new events_1.EventHandler(this.logger);
     me;
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    collectors = new collectors_1.Collectors();
+    events = new events_1.EventHandler(this);
     constructor(options) {
         super(options);
+        this.options = (0, common_1.MergeOptions)({
+            commands: {
+                argsParser: options?.commands?.argsParser ?? onmessagecreate_1.defaultArgsParser,
+                optionsParser: options?.commands?.optionsParser ??
+                    onmessagecreate_1.defaultOptionsParser,
+            },
+        }, this.options);
     }
     setServices({ gateway, ...rest }) {
         super.setServices(rest);
@@ -37,7 +47,7 @@ class Client extends base_1.BaseClient {
                 this.events = undefined;
             }
             else if (typeof rest.handlers.events === 'function') {
-                this.events = new events_1.EventHandler(this.logger);
+                this.events = new events_1.EventHandler(this);
                 this.events.setHandlers({
                     callback: rest.handlers.events,
                 });
@@ -48,7 +58,7 @@ class Client extends base_1.BaseClient {
         }
     }
     async loadEvents(dir) {
-        dir ??= await this.getRC().then(x => x.events);
+        dir ??= await this.getRC().then((x) => x.events);
         if (dir && this.events) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
@@ -56,11 +66,12 @@ class Client extends base_1.BaseClient {
     }
     async execute(options = {}) {
         await super.execute(options);
-        if (!node_worker_threads_1.workerData?.__USING_WATCHER__) {
-            await this.gateway.spawnShards();
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        if (worker_threads?.parentPort) {
+            parentPort = worker_threads.parentPort;
         }
-        else {
-            node_worker_threads_1.parentPort?.on('message', (data) => {
+        if (worker_threads?.workerData?.__USING_WATCHER__) {
+            parentPort?.on('message', (data) => {
                 switch (data.type) {
                     case 'PAYLOAD':
                         this.gateway.options.handlePayload(data.shardId, data.payload);
@@ -71,11 +82,14 @@ class Client extends base_1.BaseClient {
                 }
             });
         }
+        else {
+            await this.gateway.spawnShards();
+        }
     }
     async start(options = {}, execute = true) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
-        const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
+        const { token: tokenRC, intents: intentsRC, debug: debugRC, } = await this.getRC();
         const token = options?.token ?? tokenRC;
         const intents = options?.connection?.intents ?? intentsRC;
         if (!this.gateway) {
@@ -93,7 +107,10 @@ class Client extends base_1.BaseClient {
                 shardStart: this.options?.shards?.start,
                 shardEnd: this.options?.shards?.end ?? this.options?.shards?.total,
                 totalShards: this.options?.shards?.total ?? this.options?.shards?.end,
-                properties: { ...this.options?.gateway?.properties, ...websocket_1.properties },
+                properties: {
+                    ...websocket_1.properties,
+                    ...this.options?.gateway?.properties,
+                },
                 compress: this.options?.gateway?.compress,
             });
         }
@@ -114,28 +131,30 @@ class Client extends base_1.BaseClient {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
             case 'PRESENCE_UPDATE':
                 if (!this.presenceUpdateHandler.check(packet.d)) {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
-                break;
-            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_CREATE': {
+                if (this.__handleGuilds?.has(packet.d.id)) {
+                    this.__handleGuilds.delete(packet.d.id);
+                    if (!this.__handleGuilds.size &&
+                        [...this.gateway.values()].every((shard) => shard.data.session_id)) {
+                        await this.events?.runEvent('BOT_READY', this, this.me, -1);
+                    }
+                    if (!this.__handleGuilds.size)
+                        delete this.__handleGuilds;
+                    return this.cache.onPacket(packet);
+                }
                 await this.events?.execute(packet.t, packet, this, shardId);
                 break;
+            }
             //rest of the events
             default: {
-                await this.cache.onPacket(packet);
+                await this.events?.execute(packet.t, packet, this, shardId);
                 switch (packet.t) {
                     case 'INTERACTION_CREATE':
                         await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
@@ -150,29 +169,18 @@ class Client extends base_1.BaseClient {
                         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);
-                        if (!this.__handleGuilds?.size ||
-                            !((this.gateway.options.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
-                            if ([...this.gateway.values()].every(shard => shard.data.session_id)) {
+                        if (!(this.__handleGuilds?.size &&
+                            (this.gateway.options.intents &
+                                v10_1.GatewayIntentBits.Guilds) ===
+                                v10_1.GatewayIntentBits.Guilds)) {
+                            if ([...this.gateway.values()].every((shard) => shard.data.session_id)) {
                                 await this.events?.runEvent('BOT_READY', this, this.me, -1);
                             }
                             delete this.__handleGuilds;
                         }
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
-                    case 'GUILD_CREATE': {
-                        if (this.__handleGuilds?.has(packet.d.id)) {
-                            this.__handleGuilds.delete(packet.d.id);
-                            if (!this.__handleGuilds.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
-                                await this.events?.runEvent('BOT_READY', this, this.me, -1);
-                            }
-                            if (!this.__handleGuilds.size)
-                                delete this.__handleGuilds;
-                            return;
-                        }
-                        break;
-                    }
                 }
-                await this.events?.execute(packet.t, packet, this, shardId);
                 break;
             }
         }

package/lib/client/collectors.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type { Awaitable, CamelCase } from '../common';
+import type { CallbackEventHandler, CustomEventsKeys, GatewayEvents } from '../events';
+export type AllClientEvents = CustomEventsKeys | GatewayEvents;
+export type ParseClientEventName<T extends AllClientEvents> = T extends CustomEventsKeys ? T : CamelCase<T>;
+type RunData<T extends AllClientEvents> = {
+    options: {
+        event: T;
+        idle?: number;
+        timeout?: number;
+        onStop?: (reason: string) => unknown;
+        onStopError?: (reason: string, error: unknown) => unknown;
+        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string) => void) => unknown;
+        onRunError?: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string) => void) => unknown;
+    };
+    idle?: NodeJS.Timeout;
+    timeout?: NodeJS.Timeout;
+    nonce: string;
+};
+export declare class Collectors {
+    readonly values: Map<AllClientEvents, RunData<any>[]>;
+    private generateRandomUUID;
+    create<T extends AllClientEvents>(options: RunData<T>['options']): {
+        event: T;
+        idle?: number | undefined;
+        timeout?: number | undefined;
+        onStop?: ((reason: string) => unknown) | undefined;
+        onStopError?: ((reason: string, error: unknown) => unknown) | undefined;
+        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string | undefined) => void) => unknown;
+        onRunError?: ((arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string | undefined) => void) => unknown) | undefined;
+    };
+    private delete;
+}
+export {};

package/lib/client/collectors.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collectors = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_console_1 = require("node:console");
+class Collectors {
+    values = new Map();
+    generateRandomUUID(name) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return '*';
+        let nonce = (0, node_crypto_1.randomUUID)();
+        while (collectors.find(x => x.nonce === nonce)) {
+            nonce = (0, node_crypto_1.randomUUID)();
+        }
+        return nonce;
+    }
+    create(options) {
+        const nonce = this.generateRandomUUID(options.event);
+        if (!this.values.has(options.event)) {
+            this.values.set(options.event, []);
+        }
+        this.values.get(options.event).push({
+            options: {
+                ...options,
+                name: options.event,
+            },
+            idle: options.idle && options.idle > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'idle');
+                }, options.idle)
+                : undefined,
+            timeout: options.timeout && options.timeout > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'timeout');
+                }, options.timeout)
+                : undefined,
+            nonce,
+        });
+        return options;
+    }
+    async delete(name, nonce, reason = 'unknown') {
+        const collectors = this.values.get(name);
+        if (!collectors?.length) {
+            if (collectors)
+                this.values.delete(name);
+            return;
+        }
+        const index = collectors.findIndex(x => x.nonce === nonce);
+        if (index === -1)
+            return;
+        const collector = collectors[index];
+        clearTimeout(collector.idle);
+        clearTimeout(collector.timeout);
+        collectors.splice(index, 1);
+        try {
+            await collector.options.onStop?.(reason);
+        }
+        catch (e) {
+            await collector.options.onStopError?.(reason, node_console_1.error);
+        }
+    }
+    /**@internal */
+    async run(name, data) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return;
+        for (const i of collectors) {
+            if (await i.options.filter(data)) {
+                i.idle?.refresh();
+                const stop = (reason = 'unknown') => {
+                    return this.delete(i.options.event, i.nonce, reason);
+                };
+                try {
+                    await i.options.run(data, stop);
+                }
+                catch (e) {
+                    await i.options.onRunError?.(data, e, stop);
+                }
+                break;
+            }
+        }
+    }
+}
+exports.Collectors = Collectors;

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>;
 }