seyfert 1.0.1 → 1.1.0

package/lib/commands/applications/chat.js

@@ -14,22 +14,22 @@ class BaseCommand {
     nsfw;
     description;
     default_member_permissions;
+    integration_types;
+    contexts;
     botPermissions;
-    dm;
     name_localizations;
     description_localizations;
     options;
     /** @internal */
     async __runOptions(ctx, resolver) {
-        const command = resolver.getCommand();
-        if (!command?.options?.length) {
+        if (!this?.options?.length) {
             return [false, {}];
         }
         const data = {};
         let errored = false;
-        for (const i of command.options ?? []) {
+        for (const i of this.options ?? []) {
             try {
-                const option = command.options.find(x => x.name === i.name);
+                const option = this.options.find(x => x.name === i.name);
                 const value = resolver.getHoisted(i.name)?.value !== undefined
                     ? await new Promise((res, rej) => option.value?.({ context: ctx, value: resolver.getValue(i.name) }, res, rej) ||
                         res(resolver.getValue(i.name)))
@@ -117,9 +117,9 @@ class BaseCommand {
             description_localizations: this.description_localizations,
             guild_id: this.guild_id,
             default_member_permissions: this.default_member_permissions,
+            contexts: this.contexts,
+            integration_types: this.integration_types,
         };
-        if ('dm' in this)
-            data.dm_permission = this.dm;
         return data;
     }
     async reload() {

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

@@ -4,18 +4,19 @@ import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest
 import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { OptionResolver } from '../optionresolver';
-import type { ContextOptions, OptionsRecord } from './chat';
+import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
 export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends ExtendContext {
 }
 export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> {
     readonly client: UsingClient;
-    resolver: OptionResolver;
+    readonly resolver: OptionResolver;
     readonly shardId: number;
+    readonly command: Command | SubCommand;
     message: If<InferWithPrefix, Message | undefined, undefined>;
     interaction: If<InferWithPrefix, ChatInputCommandInteraction | undefined, ChatInputCommandInteraction>;
     messageResponse?: If<InferWithPrefix, Message | undefined>;
-    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number);
+    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number, command: Command | SubCommand);
     options: ContextOptions<T>;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
@@ -23,6 +24,7 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
         get(locale?: string | undefined): import("./shared").DefaultLocale;
     };
+    get fullCommandName(): string;
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
     deferReply(ephemeral?: boolean): Promise<void | Message>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;

package/lib/commands/applications/chatcontext.js

@@ -8,13 +8,15 @@ class CommandContext {
     client;
     resolver;
     shardId;
+    command;
     message;
     interaction;
     messageResponse;
-    constructor(client, data, resolver, shardId) {
+    constructor(client, data, resolver, shardId, command) {
         this.client = client;
         this.resolver = resolver;
         this.shardId = shardId;
+        this.command = command;
         if (data instanceof structures_1.Message) {
             this.message = data;
         }
@@ -31,6 +33,9 @@ class CommandContext {
     get t() {
         return this.client.langs.get(this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US');
     }
+    get fullCommandName() {
+        return this.resolver.fullCommandName;
+    }
     async write(body, fetchReply) {
         if (this.interaction)
             return this.interaction.write(body, fetchReply);

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

@@ -1,5 +1,5 @@
 import { type ApplicationCommandType, type LocaleString, type PermissionStrings } from '../../common';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { IntegrationTypes, InteractionContextTypes, RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
 import type { UsingClient } from './shared';
 export declare abstract class ContextMenuCommand {
@@ -13,6 +13,8 @@ export declare abstract class ContextMenuCommand {
     name: string;
     type: ApplicationCommandType.User | ApplicationCommandType.Message;
     nsfw?: boolean;
+    integration_types?: IntegrationTypes[];
+    contexts?: InteractionContextTypes[];
     description: string;
     default_member_permissions?: string;
     botPermissions?: bigint;
@@ -29,6 +31,8 @@ export declare abstract class ContextMenuCommand {
         guild_id: string[] | undefined;
         dm_permission: boolean | undefined;
         default_member_permissions: string | undefined;
+        contexts: InteractionContextTypes[] | undefined;
+        integration_types: IntegrationTypes[] | undefined;
     };
     reload(): Promise<void>;
     abstract run?(context: MenuCommandContext<any>): any;

package/lib/commands/applications/menu.js

@@ -10,6 +10,8 @@ class ContextMenuCommand {
     name;
     type;
     nsfw;
+    integration_types;
+    contexts;
     description;
     default_member_permissions;
     botPermissions;
@@ -73,6 +75,8 @@ class ContextMenuCommand {
             guild_id: this.guild_id,
             dm_permission: this.dm,
             default_member_permissions: this.default_member_permissions,
+            contexts: this.contexts,
+            integration_types: this.integration_types,
         };
     }
     async reload() {

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

@@ -1,4 +1,4 @@
-import { CommandContext, type ReturnCache, type WebhookMessage } from '../..';
+import { CommandContext, type ContextMenuCommand, type ReturnCache, type WebhookMessage } from '../..';
 import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type UnionToTuple, type When } from '../../common';
 import { Message, User, type AllChannels, type Guild, type GuildMember, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
 import type { RegisteredMiddlewares } from '../decorators';
@@ -10,7 +10,8 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     readonly client: UsingClient;
     readonly interaction: T;
     readonly shardId: number;
-    constructor(client: UsingClient, interaction: T, shardId: number);
+    readonly command: ContextMenuCommand;
+    constructor(client: UsingClient, interaction: T, shardId: number, command: ContextMenuCommand);
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     get proxy(): import("../..").APIRoutes;
@@ -18,6 +19,7 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
         get(locale?: string | undefined): import("./shared").DefaultLocale;
     };
+    get fullCommandName(): string;
     write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void | WebhookMessage>>;
     get modal(): ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>) | ((body: import("../../common").ModalCreateBodyRequest) => Promise<void>);
     deferReply(ephemeral?: boolean): Promise<void>;

package/lib/commands/applications/menucontext.js

@@ -8,10 +8,12 @@ class MenuCommandContext {
     client;
     interaction;
     shardId;
-    constructor(client, interaction, shardId) {
+    command;
+    constructor(client, interaction, shardId, command) {
         this.client = client;
         this.interaction = interaction;
         this.shardId = shardId;
+        this.command = command;
     }
     metadata = {};
     globalMetadata = {};
@@ -34,6 +36,9 @@ class MenuCommandContext {
     get t() {
         return this.client.langs.get(this.interaction.locale);
     }
+    get fullCommandName() {
+        return this.command.name;
+    }
     write(body, fetchReply) {
         return this.interaction.write(body, fetchReply);
     }

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

@@ -63,5 +63,4 @@ export declare function createNumberOption<T extends SeyfertNumberOption = Seyfe
 export declare function createAttachmentOption<T extends SeyfertAttachmentOption = SeyfertAttachmentOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Attachment;
 };
-export type ParseMiddlewareType<T> = T extends MiddlewareContext<any, CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>> ? T : MiddlewareContext<T, CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>>;
-export declare function createMiddleware<T = ParseMiddlewareType<unknown>>(data: ParseMiddlewareType<T>): ParseMiddlewareType<T>;
+export declare function createMiddleware<T = any, C extends CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>>>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;

package/lib/commands/decorators.d.ts

@@ -3,22 +3,33 @@ import type { CommandOption, OptionsRecord, SubCommand } from './applications/ch
 import type { DefaultLocale, MiddlewareContext } from './applications/shared';
 export interface RegisteredMiddlewares {
 }
+export declare enum IntegrationTypes {
+    GUILD_INSTALL = 0,
+    USER_INSTALL = 1
+}
+export declare enum InteractionContextTypes {
+    GUILD = 0,
+    BOT_DM = 1,
+    PRIVATE_CHANNEL = 2
+}
 type DeclareOptions = {
     name: string;
     description: string;
     botPermissions?: PermissionStrings | bigint;
-    defaultPermissions?: PermissionStrings | bigint;
+    defaultMemberPermissions?: PermissionStrings | bigint;
     guildId?: string[];
-    dm?: boolean;
     nsfw?: boolean;
+    integrationTypes?: (keyof typeof IntegrationTypes)[];
+    contexts?: (keyof typeof InteractionContextTypes)[];
 } | (Omit<{
     name: string;
     description: string;
     botPermissions?: PermissionStrings | bigint;
-    defaultPermissions?: PermissionStrings | bigint;
+    defaultMemberPermissions?: PermissionStrings | bigint;
     guildId?: string[];
-    dm?: boolean;
     nsfw?: boolean;
+    integrationTypes?: (keyof typeof IntegrationTypes)[];
+    contexts?: (keyof typeof InteractionContextTypes)[];
 }, 'type' | 'description'> & {
     type: ApplicationCommandType.User | ApplicationCommandType.Message;
 });
@@ -96,9 +107,10 @@ export declare function Declare(declare: DeclareOptions): <T extends new (...arg
     new (...args: any[]): {
         name: string;
         nsfw: boolean | undefined;
+        contexts: InteractionContextTypes[] | undefined;
+        integration_types: IntegrationTypes[] | undefined;
         default_member_permissions: string | bigint | undefined;
         botPermissions: bigint | undefined;
-        dm?: boolean | undefined;
         description: string;
         type: ApplicationCommandType;
         guild_id?: string[] | undefined;

package/lib/commands/decorators.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Declare = exports.Middlewares = exports.AutoLoad = exports.Options = exports.Group = exports.Groups = exports.GroupsT = exports.LocalesT = exports.Locales = void 0;
+exports.Declare = exports.Middlewares = exports.AutoLoad = exports.Options = exports.Group = exports.Groups = exports.GroupsT = exports.LocalesT = exports.Locales = exports.InteractionContextTypes = exports.IntegrationTypes = void 0;
 const common_1 = require("../common");
+var IntegrationTypes;
+(function (IntegrationTypes) {
+    IntegrationTypes[IntegrationTypes["GUILD_INSTALL"] = 0] = "GUILD_INSTALL";
+    IntegrationTypes[IntegrationTypes["USER_INSTALL"] = 1] = "USER_INSTALL";
+})(IntegrationTypes || (exports.IntegrationTypes = IntegrationTypes = {}));
+var InteractionContextTypes;
+(function (InteractionContextTypes) {
+    InteractionContextTypes[InteractionContextTypes["GUILD"] = 0] = "GUILD";
+    InteractionContextTypes[InteractionContextTypes["BOT_DM"] = 1] = "BOT_DM";
+    InteractionContextTypes[InteractionContextTypes["PRIVATE_CHANNEL"] = 2] = "PRIVATE_CHANNEL";
+})(InteractionContextTypes || (exports.InteractionContextTypes = InteractionContextTypes = {}));
 function Locales({ name: names, description: descriptions, }) {
     return (target) => class extends target {
         name_localizations = names ? Object.fromEntries(names) : undefined;
@@ -62,13 +73,14 @@ function Declare(declare) {
     return (target) => class extends target {
         name = declare.name;
         nsfw = declare.nsfw;
-        default_member_permissions = Array.isArray(declare.defaultPermissions)
-            ? declare.defaultPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0)).toString()
-            : declare.defaultPermissions;
+        contexts = declare.contexts?.map(i => InteractionContextTypes[i]);
+        integration_types = declare.integrationTypes?.map(i => IntegrationTypes[i]);
+        default_member_permissions = Array.isArray(declare.defaultMemberPermissions)
+            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0)).toString()
+            : declare.defaultMemberPermissions;
         botPermissions = Array.isArray(declare.botPermissions)
             ? declare.botPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0))
             : declare.botPermissions;
-        dm;
         description = '';
         type = common_1.ApplicationCommandType.ChatInput;
         guild_id;
@@ -78,8 +90,6 @@ function Declare(declare) {
                 this.description = declare.description;
             if ('type' in declare)
                 this.type = declare.type;
-            if ('dm' in declare)
-                this.dm = !!declare.dm;
             if ('guildId' in declare)
                 this.guild_id = declare.guildId;
             // check if all properties are valid

package/lib/commands/handler.d.ts

@@ -1,16 +1,16 @@
-import type { BaseClient } from '../client/base';
 import type { Logger } from '../common';
 import { BaseHandler } from '../common';
 import { Command } from './applications/chat';
 import { ContextMenuCommand } from './applications/menu';
+import type { UsingClient } from './applications/shared';
 export declare class CommandHandler extends BaseHandler {
     protected logger: Logger;
-    protected client: BaseClient;
+    protected client: UsingClient;
     values: (Command | ContextMenuCommand)[];
     protected filter: (path: string) => boolean;
-    constructor(logger: Logger, client: BaseClient);
+    constructor(logger: Logger, client: UsingClient);
     reload(resolve: string | Command): Promise<void>;
     reloadAll(stopIfFail?: boolean): Promise<void>;
-    load(commandsDir: string, client: BaseClient): Promise<(Command | ContextMenuCommand)[]>;
-    private __parseLocales;
+    load(commandsDir: string, client: UsingClient): Promise<(Command | ContextMenuCommand)[]>;
+    private __parseCommandLocales;
 }

package/lib/commands/handler.js

@@ -63,6 +63,7 @@ class CommandHandler extends common_1.BaseHandler {
             commandInstance.__filePath = command.path;
             commandInstance.options ??= [];
             if (commandInstance.__d) {
+                //@AutoLoad
                 const options = await this.getFiles((0, node_path_1.dirname)(command.path));
                 for (const option of options) {
                     if (command.name === (0, node_path_1.basename)(option)) {
@@ -95,45 +96,60 @@ class CommandHandler extends common_1.BaseHandler {
                 }
             }
             this.values.push(commandInstance);
-            this.__parseLocales(commandInstance, client);
+            this.__parseCommandLocales(commandInstance, client);
             for (const i of commandInstance.options ?? []) {
                 if (i instanceof chat_1.SubCommand) {
-                    this.__parseLocales(i, client);
+                    this.__parseCommandLocales(i, client);
                 }
             }
         }
         return this.values;
     }
-    __parseLocales(command, client) {
+    __parseCommandLocales(command, client) {
         if (command.__t) {
             command.name_localizations = {};
             command.description_localizations = {};
             for (const locale of Object.keys(client.langs.values)) {
-                const aliases = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
-                if (Object.values(common_1.Locale).includes(locale)) {
-                    if (command.__t.name) {
+                const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+                if (Object.values(common_1.Locale).includes(locale))
+                    locales.push(locale);
+                if (command.__t.name) {
+                    for (const i of locales) {
                         const valueName = client.langs.getKey(locale, command.__t.name);
                         if (valueName)
-                            command.name_localizations[locale] = valueName;
+                            command.name_localizations[i] = valueName;
                     }
-                    if (command.__t.description) {
+                }
+                if (command.__t.description) {
+                    for (const i of locales) {
                         const valueKey = client.langs.getKey(locale, command.__t.description);
                         if (valueKey)
-                            command.description_localizations[locale] = valueKey;
+                            command.description_localizations[i] = valueKey;
                     }
                 }
-                for (const i of aliases) {
-                    if (command.__t.name) {
-                        const valueName = client.langs.getKey(locale, command.__t.name);
+            }
+        }
+        for (const options of command.options ?? []) {
+            if (options instanceof chat_1.SubCommand || !options.locales)
+                continue;
+            options.name_localizations = {};
+            options.description_localizations = {};
+            for (const locale of Object.keys(client.langs.values)) {
+                const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+                if (Object.values(common_1.Locale).includes(locale))
+                    locales.push(locale);
+                if (options.locales.name) {
+                    for (const i of locales) {
+                        const valueName = client.langs.getKey(locale, options.locales.name);
                         if (valueName)
-                            command.name_localizations[i] = valueName;
+                            options.name_localizations[i] = valueName;
                     }
                 }
-                for (const i of aliases) {
-                    if (command.__t.description) {
-                        const valueKey = client.langs.getKey(locale, command.__t.description);
+                if (options.locales.description) {
+                    for (const i of locales) {
+                        const valueKey = client.langs.getKey(locale, options.locales.description);
                         if (valueKey)
-                            command.description_localizations[i] = valueKey;
+                            options.description_localizations[i] = valueKey;
                     }
                 }
             }
@@ -141,37 +157,25 @@ class CommandHandler extends common_1.BaseHandler {
         if (command instanceof chat_1.Command && command.__tGroups) {
             command.groups = {};
             for (const locale of Object.keys(client.langs.values)) {
-                const aliases = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+                const locales = this.client.langs.aliases.find(x => x[0] === locale)?.[1] ?? [];
+                if (Object.values(common_1.Locale).includes(locale))
+                    locales.push(locale);
                 for (const group in command.__tGroups) {
                     command.groups[group] ??= {
                         defaultDescription: command.__tGroups[group].defaultDescription,
                         description: [],
                         name: [],
                     };
-                    if (Object.values(common_1.Locale).includes(locale)) {
-                        if (command.__tGroups[group].name) {
-                            const valueName = client.langs.getKey(locale, command.__tGroups[group].name);
-                            if (valueName) {
-                                command.groups[group].name.push([locale, valueName]);
-                            }
-                        }
-                        if (command.__tGroups[group].description) {
-                            const valueKey = client.langs.getKey(locale, command.__tGroups[group].description);
-                            if (valueKey) {
-                                command.groups[group].description.push([locale, valueKey]);
-                            }
-                        }
-                    }
-                    for (const i of aliases) {
-                        if (command.__tGroups[group].name) {
+                    if (command.__tGroups[group].name) {
+                        for (const i of locales) {
                             const valueName = client.langs.getKey(locale, command.__tGroups[group].name);
                             if (valueName) {
                                 command.groups[group].name.push([i, valueName]);
                             }
                         }
                     }
-                    for (const i of aliases) {
-                        if (command.__tGroups[group].description) {
+                    if (command.__tGroups[group].description) {
+                        for (const i of locales) {
                             const valueKey = client.langs.getKey(locale, command.__tGroups[group].description);
                             if (valueKey) {
                                 command.groups[group].description.push([i, valueKey]);

package/lib/commands/optionresolver.d.ts

@@ -1,20 +1,27 @@
 import { Attachment, GuildMember } from '..';
-import type { APIApplicationCommandInteractionDataOption, APIInteractionDataResolved, MakeRequired } from '../common';
+import type { APIApplicationCommandInteractionDataOption, APIAttachment, APIGuildMember, APIInteractionDataResolvedChannel, APIInteractionGuildMember, APIRole, APIUser, MakeRequired } from '../common';
 import { ApplicationCommandOptionType } from '../common';
 import type { AllChannels } from '../structures';
 import { GuildRole, InteractionGuildMember, User } from '../structures';
 import type { Command, CommandAutocompleteOption, SubCommand } from './applications/chat';
 import type { UsingClient } from './applications/shared';
+export type ContextOptionsResolved = {
+    members?: Record<string, APIGuildMember | APIInteractionGuildMember | GuildMember | InteractionGuildMember>;
+    users?: Record<string, APIUser | User>;
+    roles?: Record<string, APIRole | GuildRole>;
+    channels?: Record<string, APIInteractionDataResolvedChannel | AllChannels>;
+    attachments?: Record<string, APIAttachment | Attachment>;
+};
 export declare class OptionResolver {
     private client;
     parent?: Command | undefined;
     guildId?: string | undefined;
-    resolved?: APIInteractionDataResolved | undefined;
+    resolved?: ContextOptionsResolved | undefined;
     readonly options: OptionResolved[];
     hoistedOptions: OptionResolved[];
     private subCommand;
     private group;
-    constructor(client: UsingClient, options: APIApplicationCommandInteractionDataOption[], parent?: Command | undefined, guildId?: string | undefined, resolved?: APIInteractionDataResolved | undefined);
+    constructor(client: UsingClient, options: APIApplicationCommandInteractionDataOption[], parent?: Command | undefined, guildId?: string | undefined, resolved?: ContextOptionsResolved | undefined);
     get fullCommandName(): string;
     getCommand(): Command | SubCommand | undefined;
     getAutocompleteValue(): string | undefined;
@@ -28,7 +35,7 @@ export declare class OptionResolver {
     private getTypedOption;
     getChannel(name: string, required?: true): AllChannels;
     getString(name: string, required?: true): string;
-    transformOption(option: APIApplicationCommandInteractionDataOption, resolved?: APIInteractionDataResolved): OptionResolved;
+    transformOption(option: APIApplicationCommandInteractionDataOption, resolved?: ContextOptionsResolved): OptionResolved;
 }
 export interface OptionResolved {
     name: string;

package/lib/commands/optionresolver.js

@@ -122,14 +122,16 @@ class OptionResolver {
             const value = resolve.value;
             const user = resolved.users?.[value];
             if (user) {
-                resolve.user = new structures_1.User(this.client, user);
+                resolve.user = user instanceof structures_1.User ? user : new structures_1.User(this.client, user);
             }
             const member = resolved.members?.[value];
             if (member) {
                 resolve.member =
-                    member instanceof __1.GuildMember
+                    member instanceof __1.GuildMember || member instanceof structures_1.InteractionGuildMember
                         ? member
-                        : new structures_1.InteractionGuildMember(this.client, member, user, this.guildId);
+                        : 'permissions' in member
+                            ? new structures_1.InteractionGuildMember(this.client, member, user, this.guildId)
+                            : new __1.GuildMember(this.client, member, user, this.guildId);
             }
             const channel = resolved.channels?.[value];
             if (channel) {
@@ -141,7 +143,7 @@ class OptionResolver {
             }
             const attachment = resolved.attachments?.[value];
             if (attachment) {
-                resolve.attachment = new __1.Attachment(this.client, attachment);
+                resolve.attachment = attachment instanceof __1.Attachment ? attachment : new __1.Attachment(this.client, attachment);
             }
         }
         return resolve;

package/lib/common/index.d.ts

@@ -4,8 +4,15 @@ export * from 'discord-api-types/v10';
 export * from './it/colors';
 export * from './it/logger';
 export * from './shorters/channels';
+export * from './shorters/emojis';
 export * from './shorters/guilds';
+export * from './shorters/members';
+export * from './shorters/messages';
+export * from './shorters/reactions';
+export * from './shorters/roles';
+export * from './shorters/templates';
 export * from './shorters/users';
+export * from './shorters/webhook';
 export * from './types/options';
 export * from './types/resolvables';
 export * from './types/util';

package/lib/common/index.js

@@ -21,8 +21,15 @@ __exportStar(require("discord-api-types/v10"), exports);
 __exportStar(require("./it/colors"), exports);
 __exportStar(require("./it/logger"), exports);
 __exportStar(require("./shorters/channels"), exports);
+__exportStar(require("./shorters/emojis"), exports);
 __exportStar(require("./shorters/guilds"), exports);
+__exportStar(require("./shorters/members"), exports);
+__exportStar(require("./shorters/messages"), exports);
+__exportStar(require("./shorters/reactions"), exports);
+__exportStar(require("./shorters/roles"), exports);
+__exportStar(require("./shorters/templates"), exports);
 __exportStar(require("./shorters/users"), exports);
+__exportStar(require("./shorters/webhook"), exports);
 __exportStar(require("./types/options"), exports);
 __exportStar(require("./types/resolvables"), exports);
 __exportStar(require("./types/util"), exports);

package/lib/common/it/utils.js

@@ -240,6 +240,7 @@ async function magicImport(path) {
         return require(path);
     }
     catch {
+        // biome-ignore lint/security/noGlobalEval: modules import broke
         return eval('((path) => import(`file:///${path}`))')(path.split('\\').join('\\\\'));
     }
 }
@@ -248,6 +249,7 @@ function fakePromise(value) {
     if (value instanceof Promise)
         return value;
     return {
+        // biome-ignore lint/suspicious/noThenProperty: magic
         then: callback => callback(value),
     };
 }