seyfert 1.5.0 → 2.0.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/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,4 +1,4 @@
-import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from 'discord-api-types/v10';
+import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
 import type { AutocompleteCallback, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
 import type { CommandContext } from './chatcontext';

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

package/lib/commands/decorators.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, type LocaleString } from 'discord-api-types/v10';
+import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, type LocaleString } from '../types';
 import type { FlatObjectKeys, PermissionStrings } from '../common';
 import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
 import type { DefaultLocale, ExtraProps, IgnoreCommand, MiddlewareContext } from './applications/shared';
@@ -32,7 +32,9 @@ type DeclareOptions = {
 export declare function Locales({ name: names, description: descriptions, }: {
     name?: [language: LocaleString, value: string][];
     description?: [language: LocaleString, value: string][];
-}): <T extends new (...args: any[]) => {}>(target: T) => {
+}): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         name_localizations: {
             [k: string]: string;
@@ -42,7 +44,9 @@ export declare function Locales({ name: names, description: descriptions, }: {
         } | undefined;
     };
 } & T;
-export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, description?: FlatObjectKeys<DefaultLocale>): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, description?: FlatObjectKeys<DefaultLocale>): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         __t: {
             name: undefined;
@@ -55,13 +59,15 @@ export declare function GroupsT(groups: Record<string, {
     description?: FlatObjectKeys<DefaultLocale>;
     defaultDescription: string;
     aliases?: string[];
-}>): <T extends new (...args: any[]) => {}>(target: T) => {
+}>): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         __tGroups: Record<string, {
-            name?: undefined;
-            description?: undefined;
+            name?: FlatObjectKeys<DefaultLocale>;
+            description?: FlatObjectKeys<DefaultLocale>;
             defaultDescription: string;
-            aliases?: string[] | undefined;
+            aliases?: string[];
         }>;
         groupsAliases: Record<string, string>;
     };
@@ -71,28 +77,36 @@ export declare function Groups(groups: Record<string, {
     description?: [language: LocaleString, value: string][];
     defaultDescription: string;
     aliases?: string[];
-}>): <T extends new (...args: any[]) => {}>(target: T) => {
+}>): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         groups: Record<string, {
-            name?: [language: "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", value: string][] | undefined;
-            description?: [language: "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", value: string][] | undefined;
+            name?: [language: LocaleString, value: string][];
+            description?: [language: LocaleString, value: string][];
             defaultDescription: string;
-            aliases?: string[] | undefined;
+            aliases?: string[];
         }>;
         groupsAliases: Record<string, string>;
     };
 } & T;
-export declare function Group(groupName: string): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function Group(groupName: string): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         group: string;
     };
 } & T;
-export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         options: SubCommand[] | CommandOption[];
     };
 } & T;
-export declare function AutoLoad(): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function AutoLoad(): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         __autoload: boolean;
     };
@@ -100,25 +114,29 @@ export declare function AutoLoad(): <T extends new (...args: any[]) => {}>(targe
 export type ParseMiddlewares<T extends Record<string, MiddlewareContext>> = {
     [k in keyof T]: T[k];
 };
-export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[]): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[]): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         middlewares: readonly never[];
     };
 } & T;
-export declare function Declare(declare: DeclareOptions): <T extends new (...args: any[]) => {}>(target: T) => {
+export declare function Declare(declare: DeclareOptions): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => {
     new (...args: any[]): {
         name: string;
         nsfw: boolean | undefined;
         props: ExtraProps | undefined;
-        contexts: (string | InteractionContextType)[];
+        contexts: InteractionContextType[];
         integrationTypes: ApplicationIntegrationType[];
         defaultMemberPermissions: bigint | undefined;
         botPermissions: bigint | undefined;
         description: string;
         type: ApplicationCommandType;
-        guildId?: string[] | undefined;
-        ignore?: IgnoreCommand | undefined;
-        aliases?: string[] | undefined;
+        guildId?: string[];
+        ignore?: IgnoreCommand;
+        aliases?: string[];
     };
 } & T;
 export {};

package/lib/commands/decorators.js

@@ -1,20 +1,26 @@
 "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;
-const v10_1 = require("discord-api-types/v10");
+exports.Locales = Locales;
+exports.LocalesT = LocalesT;
+exports.GroupsT = GroupsT;
+exports.Groups = Groups;
+exports.Group = Group;
+exports.Options = Options;
+exports.AutoLoad = AutoLoad;
+exports.Middlewares = Middlewares;
+exports.Declare = Declare;
+const types_1 = require("../types");
 function Locales({ name: names, description: descriptions, }) {
     return (target) => class extends target {
         name_localizations = names ? Object.fromEntries(names) : undefined;
         description_localizations = descriptions ? Object.fromEntries(descriptions) : undefined;
     };
 }
-exports.Locales = Locales;
 function LocalesT(name, description) {
     return (target) => class extends target {
         __t = { name, description };
     };
 }
-exports.LocalesT = LocalesT;
 function GroupsT(groups) {
     return (target) => class extends target {
         __tGroups = groups;
@@ -29,7 +35,6 @@ function GroupsT(groups) {
         }
     };
 }
-exports.GroupsT = GroupsT;
 function Groups(groups) {
     return (target) => class extends target {
         groups = groups;
@@ -44,13 +49,11 @@ function Groups(groups) {
         }
     };
 }
-exports.Groups = Groups;
 function Group(groupName) {
     return (target) => class extends target {
         group = groupName;
     };
 }
-exports.Group = Group;
 function Options(options) {
     return (target) => class extends target {
         options = Array.isArray(options)
@@ -63,37 +66,34 @@ function Options(options) {
             });
     };
 }
-exports.Options = Options;
 function AutoLoad() {
     return (target) => class extends target {
         __autoload = true;
     };
 }
-exports.AutoLoad = AutoLoad;
 function Middlewares(cbs) {
     return (target) => class extends target {
         middlewares = cbs;
     };
 }
-exports.Middlewares = Middlewares;
 function Declare(declare) {
     return (target) => class extends target {
         name = declare.name;
         nsfw = declare.nsfw;
         props = declare.props;
-        contexts = declare.contexts?.map(i => v10_1.InteractionContextType[i]) ??
-            Object.values(v10_1.InteractionContextType).filter(x => typeof x === 'number');
-        integrationTypes = declare.integrationTypes?.map(i => v10_1.ApplicationIntegrationType[i]) ?? [
-            v10_1.ApplicationIntegrationType.GuildInstall,
+        contexts = declare.contexts?.map(i => types_1.InteractionContextType[i]) ??
+            Object.values(types_1.InteractionContextType).filter(x => typeof x === 'number');
+        integrationTypes = declare.integrationTypes?.map(i => types_1.ApplicationIntegrationType[i]) ?? [
+            types_1.ApplicationIntegrationType.GuildInstall,
         ];
         defaultMemberPermissions = Array.isArray(declare.defaultMemberPermissions)
-            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | v10_1.PermissionFlagsBits[prev], BigInt(0))
+            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
             : declare.defaultMemberPermissions;
         botPermissions = Array.isArray(declare.botPermissions)
-            ? declare.botPermissions?.reduce((acc, prev) => acc | v10_1.PermissionFlagsBits[prev], BigInt(0))
+            ? declare.botPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
             : declare.botPermissions;
         description = '';
-        type = v10_1.ApplicationCommandType.ChatInput;
+        type = types_1.ApplicationCommandType.ChatInput;
         guildId;
         ignore;
         aliases;
@@ -113,4 +113,3 @@ function Declare(declare) {
         }
     };
 }
-exports.Declare = Declare;

package/lib/commands/handle.d.ts

@@ -0,0 +1,64 @@
+import { type APIApplicationCommandInteraction, type APIInteraction, type GatewayMessageCreateDispatchData, type APIApplicationCommandInteractionDataOption, ApplicationCommandOptionType } from '../types';
+import { Command, type ContextOptionsResolved, type UsingClient, type CommandAutocompleteOption, type ContextMenuCommand, MenuCommandContext, CommandContext, SubCommand, type CommandOption, type MessageCommandOptionErrors } from '.';
+import { AutocompleteInteraction, type ComponentInteraction, type ModalSubmitInteraction, type ChatInputCommandInteraction, type MessageCommandInteraction, type UserCommandInteraction, type __InternalReplyFunction } from '../structures';
+import type { PermissionsBitField } from '../structures/extra/Permissions';
+import type { MakeRequired } from '../common';
+import { type MessageStructure, Transformers, type OptionResolverStructure } from '../client/transformers';
+export type CommandOptionWithType = CommandOption & {
+    type: ApplicationCommandOptionType;
+};
+export interface CommandFromContent {
+    command?: Command | SubCommand;
+    parent?: Command;
+    fullCommandName: string;
+}
+export declare class HandleCommand {
+    client: UsingClient;
+    constructor(client: UsingClient);
+    autocomplete(interaction: AutocompleteInteraction, optionsResolver: OptionResolverStructure, command?: CommandAutocompleteOption): Promise<void>;
+    contextMenuMessage(command: ContextMenuCommand, interaction: MessageCommandInteraction, context: MenuCommandContext<MessageCommandInteraction>): Promise<any>;
+    contextMenuUser(command: ContextMenuCommand, interaction: UserCommandInteraction, context: MenuCommandContext<UserCommandInteraction>): Promise<any>;
+    chatInput(command: Command | SubCommand, interaction: ChatInputCommandInteraction, resolver: OptionResolverStructure, context: CommandContext): Promise<any>;
+    modal(interaction: ModalSubmitInteraction): Promise<void>;
+    messageComponent(interaction: ComponentInteraction): Promise<void>;
+    interaction(body: APIInteraction, shardId: number, __reply?: __InternalReplyFunction): Promise<void>;
+    message(rawMessage: GatewayMessageCreateDispatchData, shardId: number): Promise<any>;
+    argsParser(content: string, _command: SubCommand | Command, _message: MessageStructure): Record<string, string>;
+    resolveCommandFromContent(content: string, _prefix: string, _message: GatewayMessageCreateDispatchData): CommandFromContent & {
+        argsContent?: string;
+    };
+    getCommandFromContent(commandRaw: string[]): CommandFromContent;
+    makeResolver(...args: Parameters<(typeof Transformers)['OptionResolver']>): import("./optionresolver").OptionResolver;
+    getParentMessageCommand(rawParentName: string): Command | ContextMenuCommand | undefined;
+    getCommand<T extends Command | ContextMenuCommand>(data: {
+        guild_id?: string;
+        name: string;
+    }): T | undefined;
+    checkPermissions(app: PermissionsBitField, bot: bigint): import("../common").PermissionStrings | undefined;
+    fetchChannel(_option: CommandOptionWithType, query: string): Promise<import("../types").APIChannel | null>;
+    fetchUser(_option: CommandOptionWithType, query: string): Promise<import("../types").APIUser | null>;
+    fetchMember(_option: CommandOptionWithType, query: string, guildId: string): Promise<import("../types").APIGuildMember | null>;
+    fetchRole(_option: CommandOptionWithType, query: string, guildId?: string): Promise<import("../types").APIRole | null | undefined>;
+    runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+        error?: string;
+        pass?: boolean;
+    }>;
+    runMiddlewares(command: Command | ContextMenuCommand | SubCommand, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+        error?: string;
+        pass?: boolean;
+    }>;
+    makeMenuCommand(body: APIApplicationCommandInteraction, shardId: number, __reply?: __InternalReplyFunction): void | {
+        command: ContextMenuCommand;
+        interaction: UserCommandInteraction<boolean> | MessageCommandInteraction<boolean>;
+        context: MenuCommandContext<UserCommandInteraction<boolean> | MessageCommandInteraction<boolean>, never>;
+    };
+    runOptions(command: Command | SubCommand, context: CommandContext, resolver: OptionResolverStructure): Promise<boolean>;
+    argsOptionsParser(command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>): Promise<{
+        errors: {
+            name: string;
+            error: string;
+            fullError: MessageCommandOptionErrors;
+        }[];
+        options: APIApplicationCommandInteractionDataOption[];
+    }>;
+}