seyfert 1.5.0 → 2.1.0

package/lib/commands/decorators.d.ts

@@ -1,10 +1,16 @@
-import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, type LocaleString } from 'discord-api-types/v10';
+import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, 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';
 export interface RegisteredMiddlewares {
 }
-type DeclareOptions = {
+export type CommandDeclareOptions = DecoratorDeclareOptions | (Omit<DecoratorDeclareOptions, 'description'> & {
+    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+}) | (Omit<DecoratorDeclareOptions, 'ignore' | 'aliases' | 'guildId'> & {
+    type: ApplicationCommandType.PrimaryEntryPoint;
+    handler: EntryPointCommandHandlerType;
+});
+export interface DecoratorDeclareOptions {
     name: string;
     description: string;
     botPermissions?: PermissionStrings | bigint;
@@ -16,23 +22,13 @@ type DeclareOptions = {
     ignore?: IgnoreCommand;
     aliases?: string[];
     props?: ExtraProps;
-} | (Omit<{
-    name: string;
-    description: string;
-    botPermissions?: PermissionStrings | bigint;
-    defaultMemberPermissions?: PermissionStrings | bigint;
-    guildId?: string[];
-    nsfw?: boolean;
-    integrationTypes?: (keyof typeof ApplicationIntegrationType)[];
-    contexts?: (keyof typeof InteractionContextType)[];
-    props?: ExtraProps;
-}, 'type' | 'description'> & {
-    type: ApplicationCommandType.User | ApplicationCommandType.Message;
-});
+}
 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 +38,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 +53,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 +71,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 +108,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: CommandDeclareOptions): <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[];
+        handler?: EntryPointCommandHandlerType;
     };
 } & 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,40 +66,38 @@ 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;
+        handler;
         constructor(...args) {
             super(...args);
             if ('description' in declare)
@@ -109,8 +110,9 @@ function Declare(declare) {
                 this.ignore = declare.ignore;
             if ('aliases' in declare)
                 this.aliases = declare.aliases;
+            if ('handler' in declare)
+                this.handler = declare.handler;
             // check if all properties are valid
         }
     };
 }
-exports.Declare = Declare;

package/lib/commands/handle.d.ts

@@ -0,0 +1,65 @@
+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, EntryPointContext, type EntryPointCommand } from '.';
+import { AutocompleteInteraction, type ComponentInteraction, type ModalSubmitInteraction, type ChatInputCommandInteraction, type MessageCommandInteraction, type UserCommandInteraction, type __InternalReplyFunction, type EntryPointInteraction } 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>;
+    entryPoint(command: EntryPointCommand, interaction: EntryPointInteraction, context: EntryPointContext): 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 | EntryPointCommand>(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 | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
+        error?: string;
+        pass?: boolean;
+    }>;
+    runMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): 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[];
+    }>;
+}