seyfert 2.0.0 → 2.1.1-dev-11310514874.0

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

@@ -0,0 +1,46 @@
+import { type PermissionStrings } from '../../common';
+import { ApplicationCommandType, type ApplicationIntegrationType, type EntryPointCommandHandlerType, 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 { GuildMemberStructure, GuildStructure, MessageStructure, WebhookMessageStructure } from '../../client/transformers';
+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 { EntryPointCommand } from './entryPoint';
+import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
+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<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure, void | WebhookMessageStructure>>;
+    modal(body: ModalCreateBodyRequest): Promise<undefined>;
+    deferReply<WR extends boolean = false>(ephemeral?: boolean): Promise<When<WR, WebhookMessageStructure, undefined>>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<import("../..").WebhookMessage>;
+    deleteResponse(): Promise<void | undefined>;
+    editOrReply<WR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: WR): Promise<When<WR, 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, withResponse) {
+        return this.interaction.write(body, withResponse);
+    }
+    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, withResponse) {
+        return this.interaction.editOrReply(body, withResponse);
+    }
+    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,5 +1,5 @@
-import type { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, LocaleString } from '../../types';
 import { type PermissionStrings } from '../../common';
+import type { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, LocaleString } from '../../types';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
 import type { ExtraProps, UsingClient } from './shared';

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

@@ -1,10 +1,10 @@
 import type { ContextMenuCommand, ReturnCache } from '../..';
+import { type GuildMemberStructure, type GuildStructure, type MessageStructure, type UserStructure, type WebhookMessageStructure } from '../../client/transformers';
 import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type ModalCreateBodyRequest, type UnionToTuple, type When } from '../../common';
 import type { AllChannels, MessageCommandInteraction, UserCommandInteraction } from '../../structures';
 import { BaseContext } from '../basecontext';
 import type { RegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
-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 {
 }
@@ -21,12 +21,12 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
         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>;
+    write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure, void | WebhookMessageStructure>>;
+    modal(body: ModalCreateBodyRequest): Promise<undefined>;
+    deferReply<WR extends boolean = false>(ephemeral?: boolean): Promise<When<WR, WebhookMessageStructure, undefined>>;
     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>>;
+    editOrReply<WR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | MessageStructure, void | WebhookMessageStructure | MessageStructure>>;
     fetchResponse(): Promise<import("../..").WebhookMessage | undefined>;
     channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
     channel(mode?: 'cache'): ReturnCache<AllChannels>;

package/lib/commands/applications/menucontext.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MenuCommandContext = void 0;
-const types_1 = require("../../types");
+const transformers_1 = require("../../client/transformers");
 const common_1 = require("../../common");
+const types_1 = require("../../types");
 const basecontext_1 = require("../basecontext");
-const transformers_1 = require("../../client/transformers");
 class MenuCommandContext extends basecontext_1.BaseContext {
     client;
     interaction;
@@ -38,8 +38,8 @@ class MenuCommandContext extends basecontext_1.BaseContext {
     get fullCommandName() {
         return this.command.name;
     }
-    write(body, fetchReply) {
-        return this.interaction.write(body, fetchReply);
+    write(body, withResponse) {
+        return this.interaction.write(body, withResponse);
     }
     modal(body) {
         return this.interaction.modal(body);
@@ -53,8 +53,8 @@ class MenuCommandContext extends basecontext_1.BaseContext {
     deleteResponse() {
         return this.interaction.deleteResponse();
     }
-    editOrReply(body, fetchReply) {
-        return this.interaction.editOrReply(body, fetchReply);
+    editOrReply(body, withResponse) {
+        return this.interaction.editOrReply(body, withResponse);
     }
     fetchResponse() {
         return this.interaction.fetchResponse();

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

@@ -1,11 +1,11 @@
-import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
-import type { AutocompleteCallback, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import type { ModalContext } from '../../components';
+import type { ComponentContext } from '../../components/componentcontext';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
+import { type APIApplicationCommandOptionChoice, ApplicationCommandOptionType, type ChannelType } from '../../types';
 import type { CommandContext } from './chatcontext';
 import type { MiddlewareContext } from './shared';
-import type { ModalContext } from '../../components';
-import type { ComponentContext } from '../../components/componentcontext';
-export type SeyfertBasicOption<T extends keyof __TypesWrapper, D = {}> = __TypesWrapper[T] & D;
+export type SeyfertBasicOption<T extends keyof __TypesWrapper, D = object> = __TypesWrapper[T] & D;
 export type SeyfertStringOption = SeyfertBasicOption<'String'> & {
     autocomplete?: AutocompleteCallback;
     onAutocompleteError?: OnAutocompleteErrorCallback;
@@ -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/shared.d.ts

@@ -20,6 +20,9 @@ export interface ExtraProps {
 export interface UsingClient extends BaseClient {
 }
 export type ParseClient<T extends BaseClient> = T;
+export type ParseGlobalMiddlewares<T extends Record<string, MiddlewareContext>> = {
+    [K in keyof T]: MetadataMiddleware<T[K]>;
+};
 export interface InternalOptions {
 }
 export interface CustomStructures {
@@ -34,9 +37,9 @@ export type MetadataMiddleware<T extends MiddlewareContext> = IsStrictlyUndefine
 export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]> = T extends readonly [
     infer first,
     ...infer rest
-] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? {} : {
+] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? never : {
     [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
-}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
+}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : never) : never : never;
 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;

package/lib/commands/basecontext.d.ts

@@ -1,5 +1,5 @@
 import type { ModalContext } from '../components';
-import type { ContextComponentCommandInteractionMap, ComponentContext } from '../components/componentcontext';
+import type { ComponentContext, ContextComponentCommandInteractionMap } from '../components/componentcontext';
 import type { MessageCommandInteraction, UserCommandInteraction } from '../structures';
 import type { CommandContext } from './applications/chatcontext';
 import type { MenuCommandContext } from './applications/menucontext';

package/lib/commands/decorators.d.ts

@@ -1,10 +1,16 @@
-import { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, type LocaleString } from '../types';
 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 {
 }
-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,24 +22,12 @@ 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[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         name_localizations: {
@@ -45,7 +39,7 @@ export declare function Locales({ name: names, description: descriptions, }: {
     };
 } & T;
 export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, description?: FlatObjectKeys<DefaultLocale>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __t: {
@@ -60,7 +54,7 @@ export declare function GroupsT(groups: Record<string, {
     defaultDescription: string;
     aliases?: string[];
 }>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __tGroups: Record<string, {
@@ -78,7 +72,7 @@ export declare function Groups(groups: Record<string, {
     defaultDescription: string;
     aliases?: string[];
 }>): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         groups: Record<string, {
@@ -91,21 +85,21 @@ export declare function Groups(groups: Record<string, {
     };
 } & T;
 export declare function Group(groupName: string): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         group: string;
     };
 } & T;
 export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         options: SubCommand[] | CommandOption[];
     };
 } & T;
 export declare function AutoLoad(): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         __autoload: boolean;
@@ -115,14 +109,14 @@ 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[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         middlewares: readonly never[];
     };
 } & T;
-export declare function Declare(declare: DeclareOptions): <T extends {
-    new (...args: any[]): {};
+export declare function Declare(declare: CommandDeclareOptions): <T extends {
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         name: string;
@@ -137,6 +131,6 @@ export declare function Declare(declare: DeclareOptions): <T extends {
         guildId?: string[];
         ignore?: IgnoreCommand;
         aliases?: string[];
+        handler?: EntryPointCommandHandlerType;
     };
 } & T;
-export {};

package/lib/commands/decorators.js

@@ -9,6 +9,7 @@ exports.Options = Options;
 exports.AutoLoad = AutoLoad;
 exports.Middlewares = Middlewares;
 exports.Declare = Declare;
+const Permissions_1 = require("../structures/extra/Permissions");
 const types_1 = require("../types");
 function Locales({ name: names, description: descriptions, }) {
     return (target) => class extends target {
@@ -86,17 +87,18 @@ function Declare(declare) {
         integrationTypes = declare.integrationTypes?.map(i => types_1.ApplicationIntegrationType[i]) ?? [
             types_1.ApplicationIntegrationType.GuildInstall,
         ];
-        defaultMemberPermissions = Array.isArray(declare.defaultMemberPermissions)
-            ? declare.defaultMemberPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
+        defaultMemberPermissions = declare.defaultMemberPermissions
+            ? Permissions_1.PermissionsBitField.resolve(declare.defaultMemberPermissions)
             : declare.defaultMemberPermissions;
-        botPermissions = Array.isArray(declare.botPermissions)
-            ? declare.botPermissions?.reduce((acc, prev) => acc | types_1.PermissionFlagsBits[prev], BigInt(0))
+        botPermissions = declare.botPermissions
+            ? Permissions_1.PermissionsBitField.resolve(declare.botPermissions)
             : declare.botPermissions;
         description = '';
         type = types_1.ApplicationCommandType.ChatInput;
         guildId;
         ignore;
         aliases;
+        handler;
         constructor(...args) {
             super(...args);
             if ('description' in declare)
@@ -109,6 +111,8 @@ 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
         }
     };

package/lib/commands/handle.d.ts

@@ -1,9 +1,9 @@
-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 { Command, type CommandAutocompleteOption, CommandContext, type CommandOption, type ContextMenuCommand, type ContextOptionsResolved, type EntryPointCommand, EntryPointContext, MenuCommandContext, type MessageCommandOptionErrors, SubCommand, type UsingClient } from '.';
+import { type MessageStructure, type OptionResolverStructure, Transformers } from '../client/transformers';
 import type { MakeRequired } from '../common';
-import { type MessageStructure, Transformers, type OptionResolverStructure } from '../client/transformers';
+import { AutocompleteInteraction, type ChatInputCommandInteraction, type ComponentInteraction, type EntryPointInteraction, type MessageCommandInteraction, type ModalSubmitInteraction, type UserCommandInteraction, type __InternalReplyFunction } from '../structures';
+import type { PermissionsBitField } from '../structures/extra/Permissions';
+import { type APIApplicationCommandInteraction, type APIApplicationCommandInteractionDataOption, type APIInteraction, ApplicationCommandOptionType, type GatewayMessageCreateDispatchData } from '../types';
 export type CommandOptionWithType = CommandOption & {
     type: ApplicationCommandOptionType;
 };
@@ -18,6 +18,7 @@ export declare class HandleCommand {
     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>;
@@ -30,20 +31,20 @@ export declare class HandleCommand {
     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: {
+    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, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+    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;
+    runGlobalMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
         pass?: boolean;
     }>;
-    runMiddlewares(command: Command | ContextMenuCommand | SubCommand, context: CommandContext<{}, never> | MenuCommandContext<any>): Promise<false | {
+    runMiddlewares(command: Command | ContextMenuCommand | SubCommand | EntryPointCommand, context: CommandContext<{}, never> | MenuCommandContext<any> | EntryPointContext): Promise<false | {
         error?: string;
         pass?: boolean;
     }>;