seyfert 4.5.0 → 5.0.0

package/lib/commands/decorators.d.ts

@@ -1,9 +1,14 @@
+import type { RegisteredPluginMiddlewares, SeyfertRegistry } from '../client/plugins';
 import type { FlatObjectKeys, PermissionStrings } from '../common';
 import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, InteractionContextType, type LocaleString } from '../types';
 import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
-import type { DefaultLocale, ExtraProps, IgnoreCommand, MiddlewareContext } from './applications/shared';
-export interface RegisteredMiddlewares {
-}
+import type { AnyMiddlewareContext, DefaultLocale, ExtraProps, IgnoreCommand } from './applications/shared';
+export type RegisteredMiddlewares = SeyfertRegistry extends {
+    middlewares: infer M extends Record<string, AnyMiddlewareContext>;
+} ? M : {};
+export type ResolvedRegisteredMiddlewares = RegisteredMiddlewares & RegisteredPluginMiddlewares;
+type MiddlewareKey = keyof ResolvedRegisteredMiddlewares;
+export type InferMiddlewares<T extends readonly MiddlewareKey[]> = T[number];
 export type CommandDeclareOptions = DecoratorDeclareOptions | (Omit<DecoratorDeclareOptions, 'description'> & {
     type: ApplicationCommandType.User | ApplicationCommandType.Message;
 }) | (Omit<DecoratorDeclareOptions, 'ignore' | 'aliases' | 'guildId'> & {
@@ -15,12 +20,12 @@ export interface DecoratorDeclareOptions {
     description: string;
     botPermissions?: PermissionStrings;
     defaultMemberPermissions?: PermissionStrings;
-    guildId?: string[];
+    guildId?: readonly string[];
     nsfw?: boolean;
     integrationTypes?: (keyof typeof ApplicationIntegrationType)[] | ApplicationIntegrationType[];
     contexts?: (keyof typeof InteractionContextType)[] | InteractionContextType[];
     ignore?: IgnoreCommand;
-    aliases?: string[];
+    aliases?: readonly string[];
     props?: ExtraProps;
 }
 export declare function Locales({ name: names, description: descriptions, }: {
@@ -48,56 +53,64 @@ export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, descripti
         };
     };
 } & T;
-export declare function GroupsT(groups: Record<string, {
+export type TranslatedGroupDefinition = {
     name?: FlatObjectKeys<DefaultLocale>;
     description?: FlatObjectKeys<DefaultLocale>;
     defaultDescription: string;
     aliases?: string[];
-}>): <T extends {
-    new (...args: any[]): object;
-}>(target: T) => {
-    new (...args: any[]): {
-        __tGroups: Record<string, {
-            name?: FlatObjectKeys<DefaultLocale>;
-            description?: FlatObjectKeys<DefaultLocale>;
-            defaultDescription: string;
-            aliases?: string[];
-        }>;
-        groupsAliases: Record<string, string>;
-    };
-} & T;
-export declare function Groups(groups: Record<string, {
+};
+export type LocalizedGroupDefinition = {
     name?: [language: LocaleString, value: string][];
     description?: [language: LocaleString, value: string][];
     defaultDescription: string;
     aliases?: string[];
-}>): <T extends {
+};
+export type GroupDefinition = TranslatedGroupDefinition | LocalizedGroupDefinition;
+export type GroupDefinitions = Record<string, LocalizedGroupDefinition> | Record<string, TranslatedGroupDefinition>;
+export declare function defineGroups<const T extends Record<string, LocalizedGroupDefinition>>(groups: T): T;
+export declare function defineGroups<const T extends Record<string, TranslatedGroupDefinition>>(groups: T): T;
+export declare function GroupsT<const T extends Record<string, TranslatedGroupDefinition>>(groups: T): <T_1 extends {
     new (...args: any[]): object;
-}>(target: T) => {
+}>(target: T_1) => {
     new (...args: any[]): {
-        groups: Record<string, {
-            name?: [language: LocaleString, value: string][];
-            description?: [language: LocaleString, value: string][];
-            defaultDescription: string;
-            aliases?: string[];
-        }>;
+        __tGroups: T;
         groupsAliases: Record<string, string>;
     };
-} & T;
-export declare function Group(groupName: string): <T extends {
+} & T_1;
+export declare function Groups<const T extends Record<string, LocalizedGroupDefinition>>(groups: T): <T_1 extends {
+    new (...args: any[]): object;
+}>(target: T_1) => {
+    new (...args: any[]): {
+        groups: T;
+        groupsAliases: Record<string, string>;
+    };
+} & T_1;
+type GroupDecorator = <T extends {
     new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         group: string;
     };
 } & T;
-export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
+type OptionsDecorator = <T extends {
     new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         options: SubCommand[] | CommandOption[];
     };
 } & T;
+type LowercaseOptionsRecord<T extends OptionsRecord> = T & {
+    [K in keyof T as K extends string ? (K extends Lowercase<K> ? never : K) : never]: never;
+};
+type LowercaseDeclareName<T extends CommandDeclareOptions> = {
+    [K in keyof T]: K extends 'name' ? T extends {
+        type: ApplicationCommandType.User | ApplicationCommandType.Message;
+    } ? T[K] : string extends T[K] ? T[K] : T[K] extends Lowercase<T[K] & string> ? T[K] : Lowercase<T[K] & string> : T[K];
+};
+export declare function Group(groupName: string): GroupDecorator;
+export declare function Group<const T extends GroupDefinitions>(_groupsDef: T, groupName: keyof T & string): GroupDecorator;
+export declare function Options(options: (new () => SubCommand)[]): OptionsDecorator;
+export declare function Options<const T extends OptionsRecord>(options: LowercaseOptionsRecord<T>): OptionsDecorator;
 export declare function AutoLoad(): <T extends {
     new (...args: any[]): object;
 }>(target: T) => {
@@ -105,19 +118,17 @@ export declare function AutoLoad(): <T extends {
         __autoload: boolean;
     };
 } & T;
-export type ParseMiddlewares<T extends Record<string, MiddlewareContext>> = {
-    [k in keyof T]: T[k];
-};
-export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[]): <T extends {
+export declare function middlewares<const T extends readonly MiddlewareKey[]>(...cbs: T): T;
+export declare function Middlewares(cbs: readonly MiddlewareKey[]): <T extends {
     new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         middlewares: readonly never[];
     };
 } & T;
-export declare function Declare(declare: CommandDeclareOptions): <T extends {
+export declare function Declare<const T extends CommandDeclareOptions>(input: LowercaseDeclareName<T>): <C extends {
     new (...args: any[]): object;
-}>(target: T) => {
+}>(target: C) => {
     new (...args: any[]): {
         name: string;
         nsfw: boolean | undefined;
@@ -133,4 +144,5 @@ export declare function Declare(declare: CommandDeclareOptions): <T extends {
         aliases?: string[];
         handler?: EntryPointCommandHandlerType;
     };
-} & T;
+} & C;
+export {};

package/lib/commands/decorators.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Locales = Locales;
 exports.LocalesT = LocalesT;
+exports.defineGroups = defineGroups;
 exports.GroupsT = GroupsT;
 exports.Groups = Groups;
 exports.Group = Group;
 exports.Options = Options;
 exports.AutoLoad = AutoLoad;
+exports.middlewares = middlewares;
 exports.Middlewares = Middlewares;
 exports.Declare = Declare;
 const Permissions_1 = require("../structures/extra/Permissions");
@@ -22,6 +24,9 @@ function LocalesT(name, description) {
         __t = { name, description };
     };
 }
+function defineGroups(groups) {
+    return groups;
+}
 function GroupsT(groups) {
     return (target) => class extends target {
         __tGroups = groups;
@@ -50,9 +55,10 @@ function Groups(groups) {
         }
     };
 }
-function Group(groupName) {
+function Group(groupsDefOrGroupName, groupName) {
+    const resolvedGroupName = typeof groupsDefOrGroupName === 'string' ? groupsDefOrGroupName : groupName;
     return (target) => class extends target {
-        group = groupName;
+        group = resolvedGroupName;
     };
 }
 function Options(options) {
@@ -72,12 +78,16 @@ function AutoLoad() {
         __autoload = true;
     };
 }
+function middlewares(...cbs) {
+    return cbs;
+}
 function Middlewares(cbs) {
     return (target) => class extends target {
         middlewares = cbs;
     };
 }
-function Declare(declare) {
+function Declare(input) {
+    const declare = input;
     return (target) => class extends target {
         name = declare.name;
         nsfw = declare.nsfw;
@@ -104,11 +114,11 @@ function Declare(declare) {
             if ('type' in declare)
                 this.type = declare.type;
             if ('guildId' in declare)
-                this.guildId = declare.guildId;
+                this.guildId = declare.guildId?.slice();
             if ('ignore' in declare)
                 this.ignore = declare.ignore;
             if ('aliases' in declare)
-                this.aliases = declare.aliases;
+                this.aliases = declare.aliases?.slice();
             if ('handler' in declare)
                 this.handler = declare.handler;
             // check if all properties are valid

package/lib/commands/handle.d.ts

@@ -2,7 +2,7 @@ import { type MessageStructure, type OptionResolverStructure, Transformers } fro
 import type { MakeRequired } from '../common';
 import { type __InternalReplyFunction, AutocompleteInteraction, type ChatInputCommandInteraction, type ComponentInteraction, type EntryPointInteraction, type MessageCommandInteraction, type ModalSubmitInteraction, type UserCommandInteraction } from '../structures';
 import type { PermissionsBitField } from '../structures/extra/Permissions';
-import { type APIApplicationCommandInteraction, type APIApplicationCommandInteractionDataOption, type APIInteraction, ApplicationCommandOptionType, type GatewayMessageCreateDispatchData } from '../types';
+import { type APIApplicationCommandInteraction, type APIApplicationCommandInteractionDataBasicOption, type APIInteraction, ApplicationCommandOptionType, type GatewayMessageCreateDispatchData } from '../types';
 import { Command, type CommandAutocompleteOption, CommandContext, type CommandOption, type ContextMenuCommand, type ContextOptionsResolved, type EntryPointCommand, EntryPointContext, MenuCommandContext, type MessageCommandOptionErrors, SubCommand, type UsingClient } from '.';
 export type CommandOptionWithType = CommandOption & {
     type: ApplicationCommandOptionType;
@@ -16,6 +16,7 @@ export declare class HandleCommand {
     client: UsingClient;
     constructor(client: UsingClient);
     autocomplete(interaction: AutocompleteInteraction, optionsResolver: OptionResolverStructure, command?: CommandAutocompleteOption): Promise<void>;
+    private runAutocomplete;
     contextMenu(command: ContextMenuCommand, interaction: MessageCommandInteraction | UserCommandInteraction, context: MenuCommandContext<MessageCommandInteraction | UserCommandInteraction>): Promise<any>;
     contextMenuMessage(command: ContextMenuCommand, interaction: MessageCommandInteraction, context: MenuCommandContext<MessageCommandInteraction>): Promise<any>;
     contextMenuUser(command: ContextMenuCommand, interaction: UserCommandInteraction, context: MenuCommandContext<UserCommandInteraction>): Promise<any>;
@@ -29,24 +30,34 @@ export declare class HandleCommand {
     resolveCommandFromContent(content: string, _prefix: string, _message: GatewayMessageCreateDispatchData): CommandFromContent & {
         argsContent?: string;
     };
-    getCommandFromContent(commandRaw: string[]): CommandFromContent;
+    getCommandFromContent(commandRaw: string[], guildId?: string): CommandFromContent;
+    /**
+     * Resolves a message command by its full name.
+     *
+     * Guild-scoped commands require a matching `guildId`; without one, they intentionally resolve to `undefined`.
+     */
+    resolveByName(fullName: string, guildId?: string): CommandFromContent | undefined;
+    private resolveCommandFromNameParts;
     makeResolver(...args: Parameters<(typeof Transformers)['OptionResolver']>): OptionResolverStructure;
-    getParentMessageCommand(rawParentName: string): Command | ContextMenuCommand | undefined;
+    getParentMessageCommand(rawParentName: string, guildId?: string): Command | ContextMenuCommand | undefined;
+    private commandCanRunInGuild;
     getCommand<T extends Command | ContextMenuCommand | EntryPointCommand>(data: {
         guild_id?: string;
         name: string;
     }): T | undefined;
     checkPermissions(app: PermissionsBitField, bot: bigint): ("CreateInstantInvite" | "KickMembers" | "BanMembers" | "Administrator" | "ManageChannels" | "ManageGuild" | "AddReactions" | "ViewAuditLog" | "PrioritySpeaker" | "Stream" | "ViewChannel" | "SendMessages" | "SendTTSMessages" | "ManageMessages" | "EmbedLinks" | "AttachFiles" | "ReadMessageHistory" | "MentionEveryone" | "UseExternalEmojis" | "ViewGuildInsights" | "Connect" | "Speak" | "MuteMembers" | "DeafenMembers" | "MoveMembers" | "UseVAD" | "ChangeNickname" | "ManageNicknames" | "ManageRoles" | "ManageWebhooks" | "ManageGuildExpressions" | "UseApplicationCommands" | "RequestToSpeak" | "ManageEvents" | "ManageThreads" | "CreatePublicThreads" | "CreatePrivateThreads" | "UseExternalStickers" | "SendMessagesInThreads" | "UseEmbeddedActivities" | "ModerateMembers" | "ViewCreatorMonetizationAnalytics" | "UseSoundboard" | "CreateGuildExpressions" | "CreateEvents" | "UseExternalSounds" | "SendVoiceMessages" | "SetVoiceChannelStatus" | "SendPolls" | "UseExternalApps" | "PinMessages" | "BypassSlowmode")[] | 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;
+    fetchChannel(_option: CommandOptionWithType, query: string): Promise<import("..").APIChannel> | null;
+    fetchUser(_option: CommandOptionWithType, query: string): Promise<import("..").APIUser> | null;
+    fetchMember(_option: CommandOptionWithType, query: string, guildId: string): Promise<import("..").APIGuildMember> | null;
+    fetchRole(_option: CommandOptionWithType, query: string, guildId?: string): Promise<import("..").APIRole> | null;
     runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
+        metadata?: import("..").PluginMiddlewareDenialMetadata;
         pass?: boolean;
     }>;
     runMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
+        metadata?: import("..").PluginMiddlewareDenialMetadata;
         pass?: boolean;
     }>;
     makeMenuCommand(body: APIApplicationCommandInteraction, shardId: number, __reply?: __InternalReplyFunction): void | {
@@ -61,6 +72,6 @@ export declare class HandleCommand {
             error: string;
             fullError: MessageCommandOptionErrors;
         }[];
-        options: APIApplicationCommandInteractionDataOption[];
+        options: APIApplicationCommandInteractionDataBasicOption[];
     }>;
 }