seyfert 1.4.0 → 2.0.0

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

@@ -1,5 +1,6 @@
 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;
@@ -14,11 +15,15 @@ export interface DefaultLocale {
 }
 export interface ExtendContext {
 }
+export interface ExtraProps {
+}
 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>;
@@ -32,12 +37,21 @@ export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]>
 ] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? {} : {
     [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
 }) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
+export type MessageCommandOptionErrors = ['CHANNEL_TYPES', type: ChannelType[]] | ['STRING_MIN_LENGTH', min: number] | ['STRING_MAX_LENGTH', max: number] | ['STRING_INVALID_CHOICE', choices: readonly {
+    name: string;
+    value: string;
+}[]] | ['NUMBER_NAN', value: string | undefined] | ['NUMBER_MIN_VALUE', min: number] | ['NUMBER_MAX_VALUE', max: number] | ['NUMBER_INVALID_CHOICE', choices: readonly {
+    name: string;
+    value: number;
+}[]] | ['OPTION_REQUIRED'] | ['UNKNOWN', error: unknown];
 export type OnOptionsReturnObject = Record<string, {
     failed: false;
     value: unknown;
 } | {
     failed: true;
     value: string;
+    parseError: //only for text command
+    MessageCommandOptionErrors | undefined;
 }>;
 export declare enum IgnoreCommand {
     Slash = 0,

package/lib/commands/decorators.d.ts

@@ -1,18 +1,9 @@
-import { ApplicationCommandType, 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, IgnoreCommand, MiddlewareContext } from './applications/shared';
+import type { DefaultLocale, ExtraProps, IgnoreCommand, MiddlewareContext } from './applications/shared';
 export interface RegisteredMiddlewares {
 }
-export declare enum IntegrationTypes {
-    GUILD_INSTALL = 0,
-    USER_INSTALL = 1
-}
-export declare enum InteractionContextTypes {
-    GUILD = 0,
-    BOT_DM = 1,
-    PRIVATE_CHANNEL = 2
-}
 type DeclareOptions = {
     name: string;
     description: string;
@@ -20,10 +11,11 @@ type DeclareOptions = {
     defaultMemberPermissions?: PermissionStrings | bigint;
     guildId?: string[];
     nsfw?: boolean;
-    integrationTypes?: (keyof typeof IntegrationTypes)[];
-    contexts?: (keyof typeof InteractionContextTypes)[];
+    integrationTypes?: (keyof typeof ApplicationIntegrationType)[];
+    contexts?: (keyof typeof InteractionContextType)[];
     ignore?: IgnoreCommand;
     aliases?: string[];
+    props?: ExtraProps;
 } | (Omit<{
     name: string;
     description: string;
@@ -31,15 +23,18 @@ type DeclareOptions = {
     defaultMemberPermissions?: PermissionStrings | bigint;
     guildId?: string[];
     nsfw?: boolean;
-    integrationTypes?: (keyof typeof IntegrationTypes)[];
-    contexts?: (keyof typeof InteractionContextTypes)[];
+    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;
@@ -49,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;
@@ -62,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>;
     };
@@ -78,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;
     };
@@ -107,24 +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;
-        contexts: InteractionContextTypes[] | undefined;
-        integrationTypes: IntegrationTypes[] | undefined;
+        props: ExtraProps | undefined;
+        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,31 +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 = exports.InteractionContextTypes = exports.IntegrationTypes = void 0;
-const v10_1 = require("discord-api-types/v10");
-var IntegrationTypes;
-(function (IntegrationTypes) {
-    IntegrationTypes[IntegrationTypes["GUILD_INSTALL"] = 0] = "GUILD_INSTALL";
-    IntegrationTypes[IntegrationTypes["USER_INSTALL"] = 1] = "USER_INSTALL";
-})(IntegrationTypes || (exports.IntegrationTypes = IntegrationTypes = {}));
-var InteractionContextTypes;
-(function (InteractionContextTypes) {
-    InteractionContextTypes[InteractionContextTypes["GUILD"] = 0] = "GUILD";
-    InteractionContextTypes[InteractionContextTypes["BOT_DM"] = 1] = "BOT_DM";
-    InteractionContextTypes[InteractionContextTypes["PRIVATE_CHANNEL"] = 2] = "PRIVATE_CHANNEL";
-})(InteractionContextTypes || (exports.InteractionContextTypes = InteractionContextTypes = {}));
+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;
@@ -40,7 +35,6 @@ function GroupsT(groups) {
         }
     };
 }
-exports.GroupsT = GroupsT;
 function Groups(groups) {
     return (target) => class extends target {
         groups = groups;
@@ -55,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)
@@ -74,33 +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;
-        contexts = declare.contexts?.map(i => InteractionContextTypes[i]);
-        integrationTypes = declare.integrationTypes?.map(i => IntegrationTypes[i]);
+        props = declare.props;
+        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;
@@ -120,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[];
+    }>;
+}