seyfert 0.1.0 → 1.0.1

package/lib/client/onmessagecreate.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onMessageCreate = void 0;
+const v10_1 = require("discord-api-types/v10");
+const __1 = require("..");
+const structures_1 = require("../structures");
+function getCommandFromContent(commandRaw, self) {
+    const parentName = commandRaw[0];
+    const groupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
+    const subcommandName = groupName ? commandRaw[2] : commandRaw[1];
+    const parent = self.commands.values.find(x => x.name === parentName);
+    const fullCommandName = `${parentName}${groupName ? ` ${groupName} ${subcommandName}` : ` ${subcommandName ?? ''}`}`;
+    if (!(parent instanceof __1.Command))
+        return { fullCommandName };
+    if (groupName && !parent.groups?.[groupName])
+        return getCommandFromContent([parentName, subcommandName], self);
+    if (subcommandName && !parent.options?.some(x => x instanceof __1.SubCommand && x.name === subcommandName))
+        return getCommandFromContent([parentName], self);
+    const command = groupName || subcommandName
+        ? parent.options?.find(opt => {
+            if (opt instanceof __1.SubCommand) {
+                if (groupName) {
+                    if (opt.group !== groupName)
+                        return false;
+                }
+                if (opt.group && !groupName)
+                    return false;
+                return subcommandName === opt.name;
+            }
+            return false;
+        })
+        : parent;
+    return {
+        command,
+        fullCommandName,
+        parent,
+    };
+}
+async function onMessageCreate(self, rawMessage, shardId) {
+    if (!self.options?.commands)
+        return;
+    const message = new structures_1.Message(self, rawMessage);
+    const prefixes = ((await self.options.commands.prefix?.(message)) ?? []).sort((a, b) => b.length - a.length);
+    const prefix = prefixes.find(x => message.content.startsWith(x));
+    if (!prefix || !message.content.startsWith(prefix))
+        return;
+    const content = message.content.slice(prefix.length).trimStart();
+    const { fullCommandName, command, parent } = getCommandFromContent(content.split(' ').filter(x => x), self);
+    if (!command)
+        return;
+    if (!command.run)
+        return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
+    if (command.dm && !message.guildId)
+        return;
+    if (command.guild_id && !command.guild_id?.includes(message.guildId))
+        return;
+    const resolved = {
+        channels: {},
+        roles: {},
+        users: {},
+        members: {},
+        attachments: {},
+    };
+    const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(content, command);
+    const { options, errors } = await parseOptions(self, command, rawMessage, args, resolved);
+    const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
+    const context = new __1.CommandContext(self, message, optionsResolver, shardId);
+    try {
+        if (command.botPermissions && message.guildId) {
+            const meMember = await self.cache.members?.get(self.botId, message.guildId);
+            if (!meMember)
+                return; //enable member cache and "Guilds" intent, lol
+            const appPermissions = await meMember.fetchPermissions();
+            const permissions = appPermissions.missings(...appPermissions.values(command.botPermissions));
+            if (permissions.length) {
+                return command.onPermissionsFail?.(context, appPermissions.keys(permissions));
+            }
+        }
+        if (errors.length) {
+            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                return [
+                    x.name,
+                    {
+                        failed: true,
+                        value: x.error,
+                    },
+                ];
+            })));
+        }
+        const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
+        if (erroredOptions) {
+            return command.onOptionsError?.(context, result);
+        }
+        const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
+        if (resultRunGlobalMiddlewares.pass) {
+            return;
+        }
+        if ('error' in resultRunGlobalMiddlewares) {
+            return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+        }
+        const resultRunMiddlewares = await command.__runMiddlewares(context);
+        if (resultRunMiddlewares.pass) {
+            return;
+        }
+        if ('error' in resultRunMiddlewares) {
+            return command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+        }
+        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?.(self, error);
+        }
+        catch {
+            // supress error
+        }
+    }
+}
+exports.onMessageCreate = onMessageCreate;
+async function parseOptions(self, command, message, args, resolved) {
+    const options = [];
+    const errors = [];
+    for (const i of (command.options ?? [])) {
+        let value;
+        let indexAttachment = -1;
+        switch (i.type) {
+            case v10_1.ApplicationCommandOptionType.Attachment:
+                if (message.attachments[++indexAttachment]) {
+                    value = message.attachments[indexAttachment].id;
+                    resolved.attachments[value] = message.attachments[indexAttachment];
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Boolean:
+                if (args[i.name]) {
+                    value = ['yes', 'y', 'true', 'treu'].includes(args[i.name].toLowerCase());
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Channel:
+                {
+                    const rawId = message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x));
+                    if (rawId) {
+                        const channel = i.required ? await self.channels.fetch(rawId) : await self.cache.channels?.get(rawId);
+                        if (channel) {
+                            if ('channel_types' in i) {
+                                if (!i.channel_types.includes(channel.type)) {
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered channel type is not one of ${i
+                                            .channel_types.map(t => v10_1.ChannelType[t])
+                                            .join(', ')}`,
+                                    });
+                                    break;
+                                }
+                            }
+                            value = rawId;
+                            //@ts-expect-error
+                            resolved.channels[rawId] = channel;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Mentionable:
+                {
+                    const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
+                    for (const match of matches) {
+                        if (match.includes('&')) {
+                            const rawId = match.slice(3);
+                            if (rawId) {
+                                const role = i.required
+                                    ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId)
+                                    : await self.cache.roles?.get(rawId);
+                                if (role) {
+                                    value = rawId;
+                                    //@ts-expect-error
+                                    resolved.roles[rawId] = role;
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            const rawId = match.slice(2);
+                            const raw = message.mentions.find(x => rawId === x.id);
+                            if (raw) {
+                                value = raw.id;
+                                resolved.users[raw.id] = raw;
+                                break;
+                            }
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Role:
+                {
+                    const rawId = message.mention_roles.find(x => args[i.name]?.includes(x));
+                    if (rawId) {
+                        const role = i.required
+                            ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) //why, discord, why
+                            : await self.cache.roles?.get(rawId);
+                        if (role) {
+                            value = rawId;
+                            //@ts-expect-error
+                            resolved.roles[rawId] = role;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.User:
+                {
+                    const raw = message.mentions.find(x => args[i.name]?.includes(x.id));
+                    if (raw) {
+                        value = raw.id;
+                        resolved.users[raw.id] = raw;
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.String:
+                {
+                    value = args[i.name];
+                    const option = i;
+                    if (value) {
+                        if (option.min_length) {
+                            if (value.length < option.min_length) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                });
+                                break;
+                            }
+                        }
+                        if (option.max_length) {
+                            if (value.length > option.max_length) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                });
+                                break;
+                            }
+                        }
+                        if (option.choices?.length) {
+                            if (!option.choices.some(x => x.name === value)) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                        .map(x => x.name)
+                                        .join(', ')}.`,
+                                });
+                                break;
+                            }
+                            value = option.choices.find(x => x.name === value).value;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Number:
+            case v10_1.ApplicationCommandOptionType.Integer:
+                {
+                    value = Number(args[i.name]);
+                    if (args[i.name] === undefined) {
+                        value = undefined;
+                        break;
+                    }
+                    if (Number.isNaN(value)) {
+                        value = undefined;
+                        errors.push({
+                            name: i.name,
+                            error: 'The entered choice is an invalid number.',
+                        });
+                        break;
+                    }
+                    const option = i;
+                    if (option.min_value) {
+                        if (value < option.min_value) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                            });
+                            break;
+                        }
+                    }
+                    if (option.max_value) {
+                        if (value > option.max_value) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                            });
+                            break;
+                        }
+                    }
+                    if (option.choices?.length) {
+                        if (!option.choices.some(x => x.name === value)) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                    .map(x => x.name)
+                                    .join(', ')}.`,
+                            });
+                            break;
+                        }
+                        value = option.choices.find(x => x.name === value).value;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        if (value !== undefined) {
+            options.push({
+                name: i.name,
+                type: i.type,
+                value,
+            });
+        }
+    }
+    return { errors, options };
+}
+function defaultArgsParser(content) {
+    const args = {};
+    for (const i of content.match(/-(.*?)(?=\s-|$)/gs) ?? []) {
+        args[i.slice(1).split(' ')[0]] = i.split(' ').slice(1).join(' ');
+    }
+    return args;
+}
+//-(.*?)(?=\s-|$)/gs
+//-(?<text>[^-]*)/gm

package/lib/client/workerclient.d.ts

@@ -1,28 +1,45 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import type { Cache } from '../cache';
 import type { GatewayDispatchPayload, When } from '../common';
 import { Logger, type DeepPartial } from '../common';
 import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
-import { Shard } from '../websocket';
+import { Shard, type ShardManagerOptions } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
+import type { Client } from './client';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
+    private __handleGuilds?;
     logger: Logger;
     events: EventHandler;
     me: When<Ready, ClientUser>;
+    promises: Map<string, {
+        resolve: (value: any) => void;
+        timeout: NodeJS.Timeout;
+    }>;
     shards: Map<number, Shard>;
     options: WorkerClientOptions | undefined;
     constructor(options?: WorkerClientOptions);
     get workerId(): number;
+    get latency(): number;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
     loadEvents(dir?: string): Promise<void>;
-    protected handleManagerMessages(data: ManagerMessages): Promise<void>;
+    protected handleManagerMessages(data: ManagerMessages): Promise<any>;
+    private generateNonce;
+    private generateSendPromise;
+    tellWorker(workerId: number, func: (_: this) => {}): Promise<unknown>;
     protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
 }
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 interface WorkerClientOptions extends BaseClientOptions {
     disabledCache: Cache['disabledCache'];
+    commands?: NonNullable<Client['options']>['commands'];
+    handlePayload?: ShardManagerOptions['handlePayload'];
 }
 export {};

package/lib/client/workerclient.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateShardInfo = exports.WorkerClient = void 0;
+const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
+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 oninteraction_1 = require("./oninteraction");
+const oninteractioncreate_1 = require("./oninteractioncreate");
+const onmessagecreate_1 = require("./onmessagecreate");
 const workerData = node_worker_threads_1.workerData;
 class WorkerClient extends base_1.BaseClient {
+    __handleGuilds = new Set();
     logger = new common_1.Logger({
         name: `[Worker #${workerData.workerId}]`,
     });
     events = new events_1.EventHandler(this.logger);
     me;
+    promises = new Map();
     shards = new Map();
     constructor(options) {
         super(options);
@@ -35,10 +40,24 @@ class WorkerClient extends base_1.BaseClient {
                 logLevel: common_1.LogLevels.Debug,
             });
         }
+        if (workerData.workerProxy) {
+            this.setServices({
+                rest: new __1.ApiHandler({
+                    token: workerData.token,
+                    workerProxy: true,
+                    debug: workerData.debug,
+                }),
+            });
+        }
     }
     get workerId() {
         return workerData.workerId;
     }
+    get latency() {
+        let acc = 0;
+        this.shards.forEach(s => (acc += s.latency));
+        return acc / this.shards.size;
+    }
     async start(options = {}) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
@@ -54,8 +73,10 @@ class WorkerClient extends base_1.BaseClient {
     async handleManagerMessages(data) {
         switch (data.type) {
             case 'CACHE_RESULT':
-                if (this.cache.adapter.promises.has(data.nonce)) {
-                    this.cache.adapter.promises.get(data.nonce)?.(data.result);
+                if (this.cache.adapter instanceof cache_1.WorkerAdapter && this.cache.adapter.promises.has(data.nonce)) {
+                    const cacheData = this.cache.adapter.promises.get(data.nonce);
+                    clearTimeout(cacheData.timeout);
+                    cacheData.resolve(data.result);
                     this.cache.adapter.promises.delete(data.nonce);
                 }
                 break;
@@ -72,6 +93,7 @@ class WorkerClient extends base_1.BaseClient {
                     node_worker_threads_1.parentPort.postMessage({
                         type: 'RESULT_PAYLOAD',
                         nonce: data.nonce,
+                        workerId: this.workerId,
                     });
                 }
                 break;
@@ -90,6 +112,7 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const cache = this.cache;
                     const onPacket = this.onPacket.bind(this);
+                    const handlePayload = this.options?.handlePayload?.bind(this);
                     for (const id of workerData.shards) {
                         let shard = this.shards.get(id);
                         if (!shard) {
@@ -100,6 +123,7 @@ class WorkerClient extends base_1.BaseClient {
                                 compress: data.compress,
                                 debugger: this.debugger,
                                 async handlePayload(shardId, payload) {
+                                    await handlePayload?.(shardId, payload);
                                     await cache.onPacket(payload);
                                     await onPacket?.(payload, shardId);
                                     node_worker_threads_1.parentPort.postMessage({
@@ -131,6 +155,7 @@ class WorkerClient extends base_1.BaseClient {
                         ...generateShardInfo(shard),
                         nonce: data.nonce,
                         type: 'SHARD_INFO',
+                        workerId: this.workerId,
                     });
                 }
                 break;
@@ -145,60 +170,145 @@ class WorkerClient extends base_1.BaseClient {
                 }
                 break;
             case 'BOT_READY':
-                if (this.events.values.BOT_READY &&
-                    (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                    this.events.values.BOT_READY.fired = true;
-                    await this.events.values.BOT_READY.run(this.me, this, -1);
+                await this.events.runEvent('BOT_READY', this, this.me, -1);
+                break;
+            case 'API_RESPONSE':
+                {
+                    const promise = this.rest.workerPromises.get(data.nonce);
+                    if (!promise)
+                        return;
+                    this.rest.workerPromises.delete(data.nonce);
+                    if (data.error)
+                        return promise.reject(data.error);
+                    promise.resolve(data.response);
+                }
+                break;
+            case 'EXECUTE_EVAL':
+                {
+                    let result;
+                    try {
+                        // biome-ignore lint/security/noGlobalEval: yes
+                        result = await eval(`
+					(${data.func})(this)
+					`);
+                    }
+                    catch (e) {
+                        result = e;
+                    }
+                    node_worker_threads_1.parentPort.postMessage({
+                        type: 'EVAL_RESPONSE',
+                        response: result,
+                        workerId: workerData.workerId,
+                        nonce: data.nonce,
+                    });
+                }
+                break;
+            case 'EVAL_RESPONSE':
+                {
+                    const evalResponse = this.promises.get(data.nonce);
+                    if (!evalResponse)
+                        return;
+                    this.promises.delete(data.nonce);
+                    clearTimeout(evalResponse.timeout);
+                    evalResponse.resolve(data.response);
                 }
                 break;
         }
     }
+    generateNonce(large = true) {
+        const uuid = (0, node_crypto_1.randomUUID)();
+        const nonce = large ? uuid : uuid.split('-')[0];
+        if (this.promises.has(nonce))
+            return this.generateNonce(large);
+        return nonce;
+    }
+    generateSendPromise(nonce, message = 'Timeout') {
+        let resolve = (_) => {
+            /**/
+        };
+        let timeout = -1;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            timeout = setTimeout(() => {
+                this.promises.delete(nonce);
+                rej(new Error(message));
+            }, 60e3);
+        });
+        this.promises.set(nonce, { resolve, timeout });
+        return promise;
+    }
+    tellWorker(workerId, func) {
+        const nonce = this.generateNonce();
+        node_worker_threads_1.parentPort.postMessage({
+            type: 'EVAL',
+            func: func.toString(),
+            toWorkerId: workerId,
+            workerId: workerData.workerId,
+            nonce,
+        });
+        return this.generateSendPromise(nonce);
+    }
     async onPacket(packet, shardId) {
+        await this.events.execute('RAW', packet, this, shardId);
         switch (packet.t) {
-            case 'READY':
-                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);
-                if (!this.__handleGuilds.size) {
-                    if ([...this.shards.values()].every(shard => shard.data.session_id) &&
-                        this.events.values.WORKER_READY &&
-                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                        node_worker_threads_1.parentPort.postMessage({
-                            type: 'WORKER_READY',
-                            workerId: this.workerId,
-                        });
-                        this.events.values.WORKER_READY.fired = true;
-                        await this.events.values.WORKER_READY.run(this.me, this, -1);
-                    }
-                }
-                this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
+            case 'GUILD_MEMBER_UPDATE':
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
                 break;
-            case 'INTERACTION_CREATE': {
-                await (0, oninteraction_1.onInteraction)(shardId, packet.d, this);
+            case 'PRESENCE_UPDATE':
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
                 break;
-            }
-            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.events.values.WORKER_READY &&
-                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                        node_worker_threads_1.parentPort.postMessage({
-                            type: 'WORKER_READY',
-                            workerId: this.workerId,
-                        });
-                        this.events.values.WORKER_READY.fired = true;
-                        await this.events.values.WORKER_READY.run(this.me, this, -1);
+            //rest of the events
+            default:
+                {
+                    switch (packet.t) {
+                        case 'READY':
+                            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);
+                            if (!this.__handleGuilds?.size ||
+                                !((workerData.intents & common_1.GatewayIntentBits.Guilds) === common_1.GatewayIntentBits.Guilds)) {
+                                if ([...this.shards.values()].every(shard => shard.data.session_id)) {
+                                    node_worker_threads_1.parentPort.postMessage({
+                                        type: 'WORKER_READY',
+                                        workerId: this.workerId,
+                                    });
+                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                }
+                                delete this.__handleGuilds;
+                            }
+                            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);
+                            break;
+                        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)) {
+                                    node_worker_threads_1.parentPort.postMessage({
+                                        type: 'WORKER_READY',
+                                        workerId: this.workerId,
+                                    });
+                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                }
+                                if (!this.__handleGuilds.size)
+                                    delete this.__handleGuilds;
+                                return;
+                            }
+                        }
                     }
-                    return;
+                    await this.events.execute(packet.t, packet, this, shardId);
                 }
-            }
+                break;
         }
-        await this.events.execute(packet.t, packet, this, shardId);
     }
 }
 exports.WorkerClient = WorkerClient;

package/lib/collection.d.ts

@@ -142,7 +142,7 @@ export declare class LimitedCollection<K, V> {
     private readonly data;
     private readonly options;
     private timeout;
-    constructor(options: Partial<LimitedCollectionOptions>);
+    constructor(options?: Partial<LimitedCollectionOptions>);
     /**
      * Adds an element to the limited collection.
      * @param key The key of the element.