seyfert 1.5.0 → 2.1.0

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

@@ -1,46 +1,46 @@
-import type { AllChannels, Guild, InferWithPrefix, ReturnCache, WebhookMessage } from '../..';
+import type { AllChannels, InferWithPrefix, Message, ReturnCache } from '../..';
 import type { If, UnionToTuple, When } from '../../common';
 import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest } from '../../common/types/write';
-import { Message, type ChatInputCommandInteraction, type GuildMember, type InteractionGuildMember } from '../../structures';
+import { ChatInputCommandInteraction } from '../../structures';
 import { BaseContext } from '../basecontext';
 import type { RegisteredMiddlewares } from '../decorators';
-import type { OptionResolver } from '../optionresolver';
 import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, MessageStructure, OptionResolverStructure, WebhookMessageStructure } from '../../client/transformers';
 export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
 export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
-    readonly resolver: OptionResolver;
+    readonly resolver: OptionResolverStructure;
     readonly shardId: number;
     readonly command: Command | SubCommand;
-    message: If<InferWithPrefix, Message | undefined, undefined>;
+    message: If<InferWithPrefix, MessageStructure | undefined, undefined>;
     interaction: If<InferWithPrefix, ChatInputCommandInteraction | undefined, ChatInputCommandInteraction>;
-    messageResponse?: If<InferWithPrefix, Message | undefined>;
-    constructor(client: UsingClient, data: ChatInputCommandInteraction | Message, resolver: OptionResolver, shardId: number, command: Command | SubCommand);
+    messageResponse?: If<InferWithPrefix, MessageStructure | undefined>;
+    constructor(client: UsingClient, data: ChatInputCommandInteraction | MessageStructure, resolver: OptionResolverStructure, shardId: number, command: Command | SubCommand);
     options: ContextOptions<T>;
     metadata: CommandMetadata<UnionToTuple<M>>;
     globalMetadata: GlobalMetadata;
     get proxy(): import("../..").APIRoutes;
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
-        get(locale?: string | undefined): import("./shared").DefaultLocale;
+        get(locale?: string): import("./shared").DefaultLocale;
     };
     get fullCommandName(): string;
-    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
     deferReply(ephemeral?: boolean): Promise<void | Message>;
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message | WebhookMessage>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message | import("../..").WebhookMessage>;
     deleteResponse(): Promise<void>;
-    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
-    fetchResponse(): Promise<If<InferWithPrefix, WebhookMessage | Message | undefined, WebhookMessage | undefined>>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
+    fetchResponse(): Promise<If<InferWithPrefix, WebhookMessageStructure | MessageStructure | undefined, WebhookMessageStructure | undefined>>;
     channel(mode?: 'rest' | 'flow'): Promise<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
     channel(mode?: 'cache'): ReturnCache<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
-    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
-    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
-    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
-    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     get guildId(): string | undefined;
     get channelId(): string;
     get author(): import("../..").User;
-    get member(): If<InferWithPrefix, GuildMember | InteractionGuildMember | undefined, InteractionGuildMember | undefined>;
+    get member(): If<InferWithPrefix, GuildMemberStructure | InteractionGuildMemberStructure | undefined, InteractionGuildMemberStructure | undefined>;
     isChat(): this is CommandContext;
 }

package/lib/commands/applications/chatcontext.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContext = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../../types");
 const structures_1 = require("../../structures");
 const basecontext_1 = require("../basecontext");
 class CommandContext extends basecontext_1.BaseContext {
@@ -18,11 +18,11 @@ class CommandContext extends basecontext_1.BaseContext {
         this.resolver = resolver;
         this.shardId = shardId;
         this.command = command;
-        if (data instanceof structures_1.Message) {
-            this.message = data;
+        if (data instanceof structures_1.ChatInputCommandInteraction) {
+            this.interaction = data;
         }
         else {
-            this.interaction = data;
+            this.message = data;
         }
     }
     options = {};
@@ -45,7 +45,7 @@ class CommandContext extends basecontext_1.BaseContext {
     }
     async deferReply(ephemeral = false) {
         if (this.interaction)
-            return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+            return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
         const options = this.client.options?.commands;
         return (this.messageResponse = await this.message[options?.reply?.(this) ? 'reply' : 'write'](options?.deferReplyResponse?.(this) ?? { content: 'Thinking...' }));
     }

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

@@ -0,0 +1,46 @@
+import { type PermissionStrings } from '../../common';
+import { ApplicationCommandType, type EntryPointCommandHandlerType, type ApplicationIntegrationType, type InteractionContextType, type LocaleString } from '../../types';
+import type { RegisteredMiddlewares } from '../decorators';
+import type { EntryPointContext } from './entrycontext';
+import type { ExtraProps, UsingClient } from './shared';
+export declare abstract class EntryPointCommand {
+    middlewares: (keyof RegisteredMiddlewares)[];
+    __filePath?: string;
+    __t?: {
+        name: string | undefined;
+        description: string | undefined;
+    };
+    name: string;
+    type: ApplicationCommandType;
+    nsfw?: boolean;
+    integrationTypes: ApplicationIntegrationType[];
+    contexts: InteractionContextType[];
+    description: string;
+    botPermissions?: bigint;
+    dm?: boolean;
+    handler: EntryPointCommandHandlerType;
+    name_localizations?: Partial<Record<LocaleString, string>>;
+    description_localizations?: Partial<Record<LocaleString, string>>;
+    props: ExtraProps;
+    toJSON(): {
+        handler: EntryPointCommandHandlerType;
+        name: string;
+        type: ApplicationCommandType;
+        nsfw: boolean | undefined;
+        default_member_permissions: null;
+        guild_id: null;
+        description: string;
+        name_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
+        description_localizations: Partial<Record<"id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", string>> | undefined;
+        dm_permission: boolean | undefined;
+        contexts: InteractionContextType[];
+        integration_types: ApplicationIntegrationType[];
+    };
+    reload(): Promise<void>;
+    abstract run?(context: EntryPointContext): any;
+    onAfterRun?(context: EntryPointContext, error: unknown | undefined): any;
+    onRunError(context: EntryPointContext<never>, error: unknown): any;
+    onMiddlewaresError(context: EntryPointContext<never>, error: string): any;
+    onBotPermissionsFail(context: EntryPointContext<never>, permissions: PermissionStrings): any;
+    onInternalError(client: UsingClient, command: EntryPointCommand, error?: unknown): any;
+}

package/lib/commands/applications/entryPoint.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryPointCommand = void 0;
+const common_1 = require("../../common");
+const types_1 = require("../../types");
+class EntryPointCommand {
+    middlewares = [];
+    __filePath;
+    __t;
+    name;
+    type = types_1.ApplicationCommandType.PrimaryEntryPoint;
+    nsfw;
+    integrationTypes = [];
+    contexts = [];
+    description;
+    botPermissions;
+    dm;
+    handler;
+    name_localizations;
+    description_localizations;
+    props = {};
+    toJSON() {
+        return {
+            handler: this.handler,
+            name: this.name,
+            type: this.type,
+            nsfw: this.nsfw,
+            default_member_permissions: null,
+            guild_id: null,
+            description: this.description,
+            name_localizations: this.name_localizations,
+            description_localizations: this.description_localizations,
+            dm_permission: this.dm,
+            contexts: this.contexts,
+            integration_types: this.integrationTypes,
+        };
+    }
+    async reload() {
+        delete require.cache[this.__filePath];
+        const __tempCommand = await (0, common_1.magicImport)(this.__filePath).then(x => x.default ?? x);
+        Object.setPrototypeOf(this, __tempCommand.prototype);
+    }
+    onRunError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
+    }
+    onMiddlewaresError(context, error) {
+        context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
+    }
+    onBotPermissionsFail(context, permissions) {
+        context.client.logger.fatal(`${this.name}.<onBotPermissionsFail>`, context.author.id, permissions);
+    }
+    onInternalError(client, command, error) {
+        client.logger.fatal(command.name, error);
+    }
+}
+exports.EntryPointCommand = EntryPointCommand;

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

@@ -0,0 +1,40 @@
+import type { ReturnCache } from '../..';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, ModalCreateBodyRequest, UnionToTuple, When } from '../../common';
+import type { AllChannels, EntryPointInteraction } from '../../structures';
+import { BaseContext } from '../basecontext';
+import type { RegisteredMiddlewares } from '../decorators';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+import type { GuildMemberStructure, GuildStructure, MessageStructure, WebhookMessageStructure } from '../../client/transformers';
+import type { EntryPointCommand } from './entryPoint';
+export interface EntryPointContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
+}
+export declare class EntryPointContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+    readonly client: UsingClient;
+    readonly interaction: EntryPointInteraction;
+    readonly shardId: number;
+    readonly command: EntryPointCommand;
+    constructor(client: UsingClient, interaction: EntryPointInteraction, shardId: number, command: EntryPointCommand);
+    metadata: CommandMetadata<UnionToTuple<M>>;
+    globalMetadata: GlobalMetadata;
+    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
+        get(locale?: string): import("./shared").DefaultLocale;
+    };
+    get fullCommandName(): string;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, void | WebhookMessageStructure>>;
+    modal(body: ModalCreateBodyRequest): Promise<void>;
+    deferReply(ephemeral?: boolean): Promise<void>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("../..").WebhookMessage>;
+    deleteResponse(): Promise<void | undefined>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
+    fetchResponse(): Promise<import("../..").WebhookMessage | undefined>;
+    channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
+    channel(mode?: 'cache'): ReturnCache<AllChannels>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
+    get guildId(): string | undefined;
+    get channelId(): string;
+    get author(): import("../..").User;
+    get member(): import("../..").InteractionGuildMember | undefined;
+}

package/lib/commands/applications/entrycontext.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryPointContext = void 0;
+const types_1 = require("../../types");
+const basecontext_1 = require("../basecontext");
+class EntryPointContext extends basecontext_1.BaseContext {
+    client;
+    interaction;
+    shardId;
+    command;
+    constructor(client, interaction, shardId, command) {
+        super(client);
+        this.client = client;
+        this.interaction = interaction;
+        this.shardId = shardId;
+        this.command = command;
+    }
+    metadata = {};
+    globalMetadata = {};
+    get t() {
+        return this.client.t(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
+    }
+    get fullCommandName() {
+        return this.command.name;
+    }
+    write(body, fetchReply) {
+        return this.interaction.write(body, fetchReply);
+    }
+    modal(body) {
+        return this.interaction.modal(body);
+    }
+    deferReply(ephemeral = false) {
+        return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
+    }
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    deleteResponse() {
+        return this.interaction.deleteResponse();
+    }
+    editOrReply(body, fetchReply) {
+        return this.interaction.editOrReply(body, fetchReply);
+    }
+    fetchResponse() {
+        return this.interaction.fetchResponse();
+    }
+    channel(mode = 'cache') {
+        if (this.interaction.channel && mode === 'cache')
+            return this.client.cache.adapter.isAsync ? Promise.resolve(this.interaction.channel) : this.interaction.channel;
+        return this.client.channels.fetch(this.channelId, mode === 'rest');
+    }
+    me(mode = 'cache') {
+        if (!this.guildId)
+            return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.members?.get(this.client.botId, this.guildId);
+            default:
+                return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
+        }
+    }
+    guild(mode = 'cache') {
+        if (!this.guildId)
+            return (mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve());
+        switch (mode) {
+            case 'cache':
+                return this.client.cache.guilds?.get(this.guildId);
+            default:
+                return this.client.guilds.fetch(this.guildId, mode === 'rest');
+        }
+    }
+    get guildId() {
+        return this.interaction.guildId;
+    }
+    get channelId() {
+        return this.interaction.channelId;
+    }
+    get author() {
+        return this.interaction.user;
+    }
+    get member() {
+        return this.interaction.member;
+    }
+}
+exports.EntryPointContext = EntryPointContext;

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

@@ -1,4 +1,4 @@
-import type { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, LocaleString } from 'discord-api-types/v10';
+import type { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, LocaleString } from '../../types';
 import { type PermissionStrings } from '../../common';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
@@ -42,6 +42,5 @@ export declare abstract class ContextMenuCommand {
     onRunError(context: MenuCommandContext<any, never>, error: unknown): any;
     onMiddlewaresError(context: MenuCommandContext<any, never>, error: string): any;
     onBotPermissionsFail(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
-    onPermissionsFail(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
-    onInternalError(client: UsingClient, error?: unknown): any;
+    onInternalError(client: UsingClient, command: ContextMenuCommand, error?: unknown): any;
 }

package/lib/commands/applications/menu.js

@@ -48,11 +48,8 @@ class ContextMenuCommand {
     onBotPermissionsFail(context, permissions) {
         context.client.logger.fatal(`${this.name}.<onBotPermissionsFail>`, context.author.id, permissions);
     }
-    onPermissionsFail(context, permissions) {
-        context.client.logger.fatal(`${this.name}.<onPermissionsFail>`, context.author.id, permissions);
-    }
-    onInternalError(client, error) {
-        client.logger.fatal(error);
+    onInternalError(client, command, error) {
+        client.logger.fatal(command.name, error);
     }
 }
 exports.ContextMenuCommand = ContextMenuCommand;

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

@@ -1,10 +1,11 @@
-import type { ContextMenuCommand, ReturnCache, WebhookMessage } from '../..';
+import type { ContextMenuCommand, ReturnCache } from '../..';
 import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type ModalCreateBodyRequest, type UnionToTuple, type When } from '../../common';
-import { Message, User, type AllChannels, type Guild, type GuildMember, type MessageCommandInteraction, type UserCommandInteraction } from '../../structures';
+import type { AllChannels, MessageCommandInteraction, UserCommandInteraction } from '../../structures';
 import { BaseContext } from '../basecontext';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
-export type InteractionTarget<T> = T extends MessageCommandInteraction ? Message : User;
+import { type GuildMemberStructure, type GuildStructure, type MessageStructure, type UserStructure, type WebhookMessageStructure } from '../../client/transformers';
+export type InteractionTarget<T> = T extends MessageCommandInteraction ? MessageStructure : UserStructure;
 export interface MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
 export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
@@ -17,25 +18,25 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     globalMetadata: GlobalMetadata;
     get target(): InteractionTarget<T>;
     get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
-        get(locale?: string | undefined): import("./shared").DefaultLocale;
+        get(locale?: string): import("./shared").DefaultLocale;
     };
     get fullCommandName(): string;
-    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void | WebhookMessage>>;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure, void | WebhookMessageStructure>>;
     modal(body: ModalCreateBodyRequest): Promise<void>;
     deferReply(ephemeral?: boolean): Promise<void>;
-    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<WebhookMessage>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("../..").WebhookMessage>;
     deleteResponse(): Promise<void | undefined>;
-    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage | Message, void | WebhookMessage | Message>>;
-    fetchResponse(): Promise<WebhookMessage | undefined>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
+    fetchResponse(): Promise<import("../..").WebhookMessage | undefined>;
     channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
     channel(mode?: 'cache'): ReturnCache<AllChannels>;
-    me(mode?: 'rest' | 'flow'): Promise<GuildMember>;
-    me(mode?: 'cache'): ReturnCache<GuildMember | undefined>;
-    guild(mode?: 'rest' | 'flow'): Promise<Guild<'cached' | 'api'> | undefined>;
-    guild(mode?: 'cache'): ReturnCache<Guild<'cached'> | undefined>;
+    me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    me(mode?: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
+    guild(mode?: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     get guildId(): string | undefined;
     get channelId(): string;
-    get author(): User;
+    get author(): import("../..").User;
     get member(): import("../..").InteractionGuildMember | undefined;
     isMenu(): this is MenuCommandContext<UserCommandInteraction | MessageCommandInteraction>;
     isMenuUser(): this is MenuCommandContext<UserCommandInteraction>;

package/lib/commands/applications/menucontext.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MenuCommandContext = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../../types");
 const common_1 = require("../../common");
-const structures_1 = require("../../structures");
 const basecontext_1 = require("../basecontext");
+const transformers_1 = require("../../client/transformers");
 class MenuCommandContext extends basecontext_1.BaseContext {
     client;
     interaction;
@@ -22,13 +22,13 @@ class MenuCommandContext extends basecontext_1.BaseContext {
     // biome-ignore lint/suspicious/useGetterReturn: default don't exist.
     get target() {
         switch (this.interaction.data.type) {
-            case v10_1.ApplicationCommandType.Message: {
+            case types_1.ApplicationCommandType.Message: {
                 const data = this.interaction.data.resolved.messages[this.interaction.data.targetId];
-                return new structures_1.Message(this.client, (0, common_1.toSnakeCase)(data));
+                return transformers_1.Transformers.Message(this.client, (0, common_1.toSnakeCase)(data));
             }
-            case v10_1.ApplicationCommandType.User: {
+            case types_1.ApplicationCommandType.User: {
                 const data = this.interaction.data.resolved.users[this.interaction.data.targetId];
-                return new structures_1.User(this.client, (0, common_1.toSnakeCase)(data));
+                return transformers_1.Transformers.User(this.client, (0, common_1.toSnakeCase)(data));
             }
         }
     }
@@ -45,7 +45,7 @@ class MenuCommandContext extends basecontext_1.BaseContext {
         return this.interaction.modal(body);
     }
     deferReply(ephemeral = false) {
-        return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
+        return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined);
     }
     editResponse(body) {
         return this.interaction.editResponse(body);
@@ -100,10 +100,10 @@ class MenuCommandContext extends basecontext_1.BaseContext {
         return true;
     }
     isMenuUser() {
-        return this.target instanceof structures_1.User;
+        return this.interaction.data.type === types_1.ApplicationCommandType.User;
     }
     isMenuMessage() {
-        return this.target instanceof structures_1.Message;
+        return this.interaction.data.type === types_1.ApplicationCommandType.Message;
     }
 }
 exports.MenuCommandContext = MenuCommandContext;

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

@@ -1,5 +1,5 @@
-import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from 'discord-api-types/v10';
-import type { AutocompleteCallback, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
+import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
 import type { CommandContext } from './chatcontext';
 import type { MiddlewareContext } from './shared';
@@ -65,4 +65,5 @@ export declare function createNumberOption<T extends SeyfertNumberOption = Seyfe
 export declare function createAttachmentOption<T extends SeyfertAttachmentOption = SeyfertAttachmentOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Attachment;
 };
-export declare function createMiddleware<T = any, C extends CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;
+export type AnyContext = CommandContext | MenuCommandContext<MessageCommandInteraction<boolean> | UserCommandInteraction<boolean>> | ComponentContext | ModalContext | EntryPointContext;
+export declare function createMiddleware<T = any, C extends AnyContext = AnyContext>(data: MiddlewareContext<T, C>): MiddlewareContext<T, C>;

package/lib/commands/applications/options.js

@@ -1,44 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMiddleware = exports.createAttachmentOption = exports.createNumberOption = exports.createMentionableOption = exports.createRoleOption = exports.createChannelOption = exports.createUserOption = exports.createBooleanOption = exports.createIntegerOption = exports.createStringOption = void 0;
-const v10_1 = require("discord-api-types/v10");
+exports.createStringOption = createStringOption;
+exports.createIntegerOption = createIntegerOption;
+exports.createBooleanOption = createBooleanOption;
+exports.createUserOption = createUserOption;
+exports.createChannelOption = createChannelOption;
+exports.createRoleOption = createRoleOption;
+exports.createMentionableOption = createMentionableOption;
+exports.createNumberOption = createNumberOption;
+exports.createAttachmentOption = createAttachmentOption;
+exports.createMiddleware = createMiddleware;
+const types_1 = require("../../types");
 function createStringOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.String };
+    return { ...data, type: types_1.ApplicationCommandOptionType.String };
 }
-exports.createStringOption = createStringOption;
 function createIntegerOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Integer };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Integer };
 }
-exports.createIntegerOption = createIntegerOption;
 function createBooleanOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Boolean };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Boolean };
 }
-exports.createBooleanOption = createBooleanOption;
 function createUserOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.User };
+    return { ...data, type: types_1.ApplicationCommandOptionType.User };
 }
-exports.createUserOption = createUserOption;
 function createChannelOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Channel };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Channel };
 }
-exports.createChannelOption = createChannelOption;
 function createRoleOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Role };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Role };
 }
-exports.createRoleOption = createRoleOption;
 function createMentionableOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Mentionable };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Mentionable };
 }
-exports.createMentionableOption = createMentionableOption;
 function createNumberOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Number };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Number };
 }
-exports.createNumberOption = createNumberOption;
 function createAttachmentOption(data) {
-    return { ...data, type: v10_1.ApplicationCommandOptionType.Attachment };
+    return { ...data, type: types_1.ApplicationCommandOptionType.Attachment };
 }
-exports.createAttachmentOption = createAttachmentOption;
 function createMiddleware(data) {
     return data;
 }
-exports.createMiddleware = createMiddleware;

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

@@ -1,6 +1,6 @@
-import type { ChannelType } from 'discord-api-types/v10';
 import type { BaseClient } from '../../client/base';
 import type { IsStrictlyUndefined } from '../../common';
+import type { ChannelType } from '../../types';
 import type { RegisteredMiddlewares } from '../decorators';
 export type OKFunction<T> = (value: T) => void;
 export type StopFunction = (error: string) => void;
@@ -22,6 +22,8 @@ export interface UsingClient extends BaseClient {
 export type ParseClient<T extends BaseClient> = T;
 export interface InternalOptions {
 }
+export interface CustomStructures {
+}
 export type MiddlewareContext<T = any, C = any> = (context: {
     context: C;
     next: NextFunction<T>;