seyfert 4.4.1 → 5.0.0

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

@@ -1,43 +1,46 @@
 import type { ReturnCache } from '../../cache';
-import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, MessageStructure, OptionResolverStructure, UserStructure, WebhookMessageStructure } from '../../client/transformers';
-import type { If, MakeRequired, UnionToTuple, When } from '../../common';
-import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MessageWebhookCreateBodyRequest } from '../../common/types/write';
-import { type AllChannels, ChatInputCommandInteraction } from '../../structures';
+import type { BaseGuildChannelStructure, GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, MessageStructure, OptionResolverStructure, UserStructure, WebhookMessageStructure } from '../../client/transformers';
+import { type If, type MakeRequired, type When } from '../../common';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions } from '../../common/types/write';
+import { type AllChannels, type AllGuildChannels, ChatInputCommandInteraction, type ModalSubmitInteraction } from '../../structures';
 import { type RESTGetAPIGuildQuery } from '../../types';
 import { BaseContext } from '../basecontext';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } from '../decorators';
 import type { Command, ContextOptions, OptionsRecord, SubCommand } from './chat';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, InferWithPrefix, UsingClient } from './shared';
-export interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext, ExtendContext {
+type GuildCommandChannel = AllGuildChannels | BaseGuildChannelStructure;
+export interface CommandContext<T extends OptionsRecord = {}, M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
-export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+export declare class CommandContext<T extends OptionsRecord = {}, M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
     readonly resolver: OptionResolverStructure;
     readonly shardId: number;
     readonly command: Command | SubCommand;
     message: If<InferWithPrefix, MessageStructure | undefined, undefined>;
     interaction: If<InferWithPrefix, ChatInputCommandInteraction | undefined, ChatInputCommandInteraction>;
-    messageResponse?: If<InferWithPrefix, MessageStructure | undefined>;
+    messageResponse?: If<InferWithPrefix, MessageStructure | undefined, undefined>;
     constructor(client: UsingClient, data: ChatInputCommandInteraction | MessageStructure, resolver: OptionResolverStructure, shardId: number, command: Command | SubCommand);
     options: ContextOptions<T>;
-    metadata: CommandMetadata<UnionToTuple<M>>;
+    metadata: CommandMetadata<M>;
     globalMetadata: GlobalMetadata;
-    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
-        get(locale?: string): import("./shared").DefaultLocale;
-    };
+    get t(): import("../..").SeyfertLocale;
     get fullCommandName(): string;
     get deferred(): boolean;
-    write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void | WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>>>;
+    write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void>>;
+    modal(body: ModalCreateBodyRequest, options?: undefined): Promise<undefined>;
+    modal(body: ModalCreateBodyRequest, options: ModalCreateOptions): Promise<ModalSubmitInteraction | null>;
     deferReply<WR extends boolean = false>(ephemeral?: boolean, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, When<InferWithPrefix, MessageStructure, never> | undefined>>;
     editResponse(body: InteractionMessageUpdateBodyRequest): Promise<When<InferWithPrefix, WebhookMessageStructure | MessageStructure, WebhookMessageStructure>>;
     deleteResponse(): Promise<void>;
-    editOrReply<WR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void | WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>>>;
+    editOrReply<WR extends boolean = false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure | When<InferWithPrefix, MessageStructure, never>, void>>;
     followup(body: MessageWebhookCreateBodyRequest): Promise<If<InferWithPrefix, WebhookMessageStructure | MessageStructure, WebhookMessageStructure>>;
     fetchResponse(): Promise<If<InferWithPrefix, WebhookMessageStructure | MessageStructure, WebhookMessageStructure>>;
     channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
     channel(mode: 'cache'): ReturnCache<If<InferWithPrefix, AllChannels | undefined, AllChannels>>;
     me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure | undefined>;
     me(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    fetchMember(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure | undefined>;
+    fetchMember(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
     guild(mode?: 'rest' | 'flow', query?: RESTGetAPIGuildQuery): Promise<GuildStructure<'cached' | 'api'> | undefined>;
     guild(mode: 'cache', query?: RESTGetAPIGuildQuery): ReturnCache<GuildStructure<'cached'> | undefined>;
     get guildId(): string | undefined;
@@ -47,9 +50,14 @@ export declare class CommandContext<T extends OptionsRecord = {}, M extends keyo
     isChat(): this is CommandContext<T, M>;
     inGuild(): this is GuildCommandContext<T, M>;
 }
-export interface GuildCommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never> extends Omit<MakeRequired<CommandContext<T, M>, 'guildId' | 'member'>, 'guild' | 'me'> {
+export interface GuildCommandContext<T extends OptionsRecord = {}, M extends keyof ResolvedRegisteredMiddlewares = never> extends Omit<MakeRequired<CommandContext<T, M>, 'guildId' | 'member'>, 'channel' | 'guild' | 'me' | 'fetchMember'> {
+    channel(mode?: 'rest' | 'flow'): Promise<GuildCommandChannel>;
+    channel(mode: 'cache'): ReturnCache<If<InferWithPrefix, GuildCommandChannel | undefined, GuildCommandChannel>>;
     guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'>>;
     guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
     me(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
+    fetchMember(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;
+    fetchMember(mode: 'cache'): ReturnCache<GuildMemberStructure | undefined>;
 }
+export {};

package/lib/commands/applications/chatcontext.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContext = void 0;
+const common_1 = require("../../common");
 const structures_1 = require("../../structures");
 const types_1 = require("../../types");
 const basecontext_1 = require("../basecontext");
@@ -29,7 +30,9 @@ class CommandContext extends basecontext_1.BaseContext {
     metadata = {};
     globalMetadata = {};
     get t() {
-        return this.client.t(this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US');
+        return this.client.t(this.client.langs.preferGuildLocale
+            ? (this.interaction?.guildLocale ?? this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US')
+            : (this.interaction?.locale ?? this.client.langs.defaultLang ?? 'en-US'));
     }
     get fullCommandName() {
         return this.resolver.fullCommandName;
@@ -43,6 +46,13 @@ class CommandContext extends basecontext_1.BaseContext {
         const options = this.client.options?.commands;
         return (this.messageResponse = await this.message[!this.messageResponse && (await options?.reply?.(this)) ? 'reply' : 'write'](body));
     }
+    modal(body, options) {
+        if (!this.interaction)
+            throw new common_1.SeyfertError('CANNOT_USE_MODAL');
+        if (options === undefined)
+            return this.interaction.modal(body);
+        return this.interaction.modal(body, options);
+    }
     async deferReply(ephemeral = false, withResponse) {
         if (this.interaction)
             return this.interaction.deferReply(ephemeral ? types_1.MessageFlags.Ephemeral : undefined, withResponse);
@@ -83,7 +93,7 @@ class CommandContext extends basecontext_1.BaseContext {
     async fetchResponse() {
         if (this.interaction)
             return this.interaction.fetchResponse();
-        return (this.messageResponse = (await this.messageResponse.fetch()));
+        return (this.messageResponse = await this.messageResponse.fetch());
     }
     channel(mode = 'flow') {
         if (this.interaction && mode === 'cache')
@@ -107,6 +117,17 @@ class CommandContext extends basecontext_1.BaseContext {
                 return this.client.members.fetch(this.guildId, this.client.botId, mode === 'rest');
         }
     }
+    fetchMember(mode = 'flow') {
+        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.author.id, this.guildId) ||
+                    (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined));
+            default:
+                return this.client.members.fetch(this.guildId, this.author.id, mode === 'rest');
+        }
+    }
     guild(mode = 'flow', query) {
         if (!this.guildId)
             return mode === 'cache' ? (this.client.cache.adapter.isAsync ? Promise.resolve() : undefined) : Promise.resolve();

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

@@ -1,10 +1,11 @@
+import type { PluginMiddlewareDenialMetadata } from '../../client/plugins/types';
 import { type PermissionStrings } from '../../common';
 import { ApplicationCommandType, type ApplicationIntegrationType, type EntryPointCommandHandlerType, type InteractionContextType, type LocaleString } from '../../types';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } from '../decorators';
 import type { EntryPointContext } from './entrycontext';
 import type { ExtraProps, UsingClient } from './shared';
 export declare abstract class EntryPointCommand {
-    middlewares: (keyof RegisteredMiddlewares)[];
+    middlewares: readonly (keyof ResolvedRegisteredMiddlewares)[];
     __filePath?: string;
     __t?: {
         name: string | undefined;
@@ -41,7 +42,7 @@ export declare abstract class EntryPointCommand {
     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;
+    onMiddlewaresError(context: EntryPointContext<never>, error: string, _metadata: PluginMiddlewareDenialMetadata): any;
     onBotPermissionsFail(context: EntryPointContext<never>, permissions: PermissionStrings): any;
     onInternalError(client: UsingClient, command: EntryPointCommand, error?: unknown): any;
 }

package/lib/commands/applications/entryPoint.js

@@ -43,7 +43,7 @@ class EntryPointCommand {
     onRunError(context, error) {
         context.client.logger.fatal(`${this.name}.<onRunError>`, context.author.id, error);
     }
-    onMiddlewaresError(context, error) {
+    onMiddlewaresError(context, error, _metadata) {
         context.client.logger.fatal(`${this.name}.<onMiddlewaresError>`, context.author.id, error);
     }
     onBotPermissionsFail(context, permissions) {

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

@@ -1,25 +1,23 @@
 import type { ReturnCache } from '../../cache';
 import type { GuildMemberStructure, GuildStructure, InteractionGuildMemberStructure, UserStructure, WebhookMessageStructure } from '../../client/transformers';
-import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions, UnionToTuple, When } from '../../common';
+import type { InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MakeRequired, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest, ModalCreateOptions, When } from '../../common';
 import type { AllChannels, EntryPointInteraction, ModalSubmitInteraction } from '../../structures';
 import { type RESTGetAPIGuildQuery } from '../../types';
 import { BaseContext } from '../basecontext';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } 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 interface EntryPointContext<M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
-export declare class EntryPointContext<M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+export declare class EntryPointContext<M extends keyof ResolvedRegisteredMiddlewares = 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>>;
+    metadata: CommandMetadata<M>;
     globalMetadata: GlobalMetadata;
-    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
-        get(locale?: string): import("./shared").DefaultLocale;
-    };
+    get t(): import("../..").SeyfertLocale;
     get fullCommandName(): string;
     get deferred(): boolean;
     write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure, void>>;
@@ -44,7 +42,7 @@ export declare class EntryPointContext<M extends keyof RegisteredMiddlewares = n
     isEntryPoint(): this is EntryPointContext<M>;
     inGuild(): this is GuildEntryPointContext<M>;
 }
-export interface GuildEntryPointContext<M extends keyof RegisteredMiddlewares = never> extends Omit<MakeRequired<EntryPointContext<M>, 'guildId' | 'member'>, 'guild' | 'me'> {
+export interface GuildEntryPointContext<M extends keyof ResolvedRegisteredMiddlewares = never> extends Omit<MakeRequired<EntryPointContext<M>, 'guildId' | 'member'>, 'guild' | 'me'> {
     guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'>>;
     guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
     me(mode?: 'rest' | 'flow'): Promise<GuildMemberStructure>;

package/lib/commands/applications/entrycontext.js

@@ -18,7 +18,9 @@ class EntryPointContext extends basecontext_1.BaseContext {
     metadata = {};
     globalMetadata = {};
     get t() {
-        return this.client.t(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
+        return this.client.t(this.client.langs.preferGuildLocale
+            ? (this.interaction.guildLocale ?? this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US')
+            : (this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US'));
     }
     get fullCommandName() {
         return this.command.name;

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

@@ -1,10 +1,11 @@
+import type { PluginMiddlewareDenialMetadata } from '../../client/plugins/types';
 import { type PermissionStrings } from '../../common';
 import type { ApplicationCommandType, ApplicationIntegrationType, InteractionContextType, LocaleString } from '../../types';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } from '../decorators';
 import type { MenuCommandContext } from './menucontext';
 import type { ExtraProps, UsingClient } from './shared';
 export declare abstract class ContextMenuCommand {
-    middlewares: (keyof RegisteredMiddlewares)[];
+    middlewares: readonly (keyof ResolvedRegisteredMiddlewares)[];
     __filePath?: string;
     __t?: {
         name: string | undefined;
@@ -41,7 +42,7 @@ export declare abstract class ContextMenuCommand {
     abstract run?(context: MenuCommandContext<any>): any;
     onAfterRun?(context: MenuCommandContext<any>, error: unknown | undefined): any;
     onRunError?(context: MenuCommandContext<any, never>, error: unknown): any;
-    onMiddlewaresError?(context: MenuCommandContext<any, never>, error: string): any;
+    onMiddlewaresError?(context: MenuCommandContext<any, never>, error: string, metadata: PluginMiddlewareDenialMetadata): any;
     onBotPermissionsFail?(context: MenuCommandContext<any, never>, permissions: PermissionStrings): any;
     onInternalError?(client: UsingClient, command: ContextMenuCommand, error?: unknown): any;
 }

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

@@ -1,26 +1,24 @@
 import type { ContextMenuCommand, InteractionGuildMemberStructure, ReturnCache } from '../..';
 import { type GuildMemberStructure, type GuildStructure, type MessageStructure, type UserStructure, type WebhookMessageStructure } from '../../client/transformers';
-import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type MakeRequired, type MessageWebhookCreateBodyRequest, type ModalCreateBodyRequest, type ModalCreateOptions, type UnionToTuple, type When } from '../../common';
+import { type InteractionCreateBodyRequest, type InteractionMessageUpdateBodyRequest, type MakeRequired, type MessageWebhookCreateBodyRequest, type ModalCreateBodyRequest, type ModalCreateOptions, type When } from '../../common';
 import type { AllChannels, MessageCommandInteraction, ModalSubmitInteraction, UserCommandInteraction } from '../../structures';
 import { type RESTGetAPIGuildQuery } from '../../types';
 import { BaseContext } from '../basecontext';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } from '../decorators';
 import type { CommandMetadata, ExtendContext, GlobalMetadata, UsingClient } from './shared';
 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 interface MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext, ExtendContext {
 }
-export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends BaseContext {
+export declare class MenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof ResolvedRegisteredMiddlewares = never> extends BaseContext {
     readonly client: UsingClient;
     readonly interaction: T;
     readonly shardId: number;
     readonly command: ContextMenuCommand;
     constructor(client: UsingClient, interaction: T, shardId: number, command: ContextMenuCommand);
-    metadata: CommandMetadata<UnionToTuple<M>>;
+    metadata: CommandMetadata<M>;
     globalMetadata: GlobalMetadata;
     get target(): InteractionTarget<T>;
-    get t(): import("../..").__InternalParseLocale<import("./shared").DefaultLocale> & {
-        get(locale?: string): import("./shared").DefaultLocale;
-    };
+    get t(): import("../..").SeyfertLocale;
     get fullCommandName(): string;
     get deferred(): boolean;
     write<WR extends boolean = false>(body: InteractionCreateBodyRequest, withResponse?: WR): Promise<When<WR, WebhookMessageStructure, void>>;
@@ -47,7 +45,7 @@ export declare class MenuCommandContext<T extends MessageCommandInteraction | Us
     isMenuMessage(): this is MenuCommandContext<MessageCommandInteraction>;
     inGuild(): this is GuildMenuCommandContext<T, M>;
 }
-export interface GuildMenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof RegisteredMiddlewares = never> extends Omit<MakeRequired<MenuCommandContext<T, M>, 'guildId' | 'member'>, 'guild'> {
+export interface GuildMenuCommandContext<T extends MessageCommandInteraction | UserCommandInteraction, M extends keyof ResolvedRegisteredMiddlewares = never> extends Omit<MakeRequired<MenuCommandContext<T, M>, 'guildId' | 'member'>, 'guild'> {
     guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'>>;
     guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
 }

package/lib/commands/applications/menucontext.js

@@ -32,7 +32,9 @@ class MenuCommandContext extends basecontext_1.BaseContext {
         }
     }
     get t() {
-        return this.client.t(this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US');
+        return this.client.t(this.client.langs.preferGuildLocale
+            ? (this.interaction.guildLocale ?? this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US')
+            : (this.interaction.locale ?? this.client.langs.defaultLang ?? 'en-US'));
     }
     get fullCommandName() {
         return this.command.name;

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

@@ -21,7 +21,7 @@ export interface SeyfertBasicOption<T extends keyof ReturnOptionsTypes, R = true
         description?: FlatObjectKeys<DefaultLocale>;
     };
 }
-export interface SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never, R = true | false, VC = never> {
+export interface SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? readonly SeyfertChoice<ChoiceableValues[T]>[] : never, R = true | false, VC = never> {
     required?: R;
     choices?: C;
     value?: ValueCallback<T, C, VC>;
@@ -47,25 +47,25 @@ export interface ChoiceableValues {
     [ApplicationCommandOptionType.Number]: number;
     [ApplicationCommandOptionType.Integer]: number;
 }
-export type ValueCallback<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : keyof SeyfertChannelMap, I = any> = (data: {
+export type ValueCallback<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? readonly SeyfertChoice<ChoiceableValues[T]>[] : keyof SeyfertChannelMap, I = any> = (data: {
     context: CommandContext;
-    value: T extends ChoiceableTypes ? C extends SeyfertChoice<ChoiceableValues[T]>[] ? C[number]['value'] extends ReturnOptionsTypes[T] ? C[number]['value'] : never : never : C extends keyof SeyfertChannelMap ? SeyfertChannelMap[C] : never;
+    value: T extends ChoiceableTypes ? C extends readonly SeyfertChoice<ChoiceableValues[T]>[] ? C[number]['value'] extends ReturnOptionsTypes[T] ? C[number]['value'] : never : never : C extends keyof SeyfertChannelMap ? SeyfertChannelMap[C] : never;
 }, ok: OKFunction<I>, fail: StopFunction) => Awaitable<void>;
-export type SeyfertStringOption<T = SeyfertChoice<string>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, T, R, VC> & {
-    autocomplete?: AutocompleteCallback;
-    onAutocompleteError?: OnAutocompleteErrorCallback;
+export type SeyfertStringOption<T = readonly SeyfertChoice<string>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, T, R, VC> & {
+    autocomplete?: AutocompleteCallback<string>;
+    onAutocompleteError?: OnAutocompleteErrorCallback<string>;
     min_length?: number;
     max_length?: number;
 };
-export type SeyfertIntegerOption<T = SeyfertChoice<number>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Integer, T, R, VC> & {
-    autocomplete?: AutocompleteCallback;
-    onAutocompleteError?: OnAutocompleteErrorCallback;
+export type SeyfertIntegerOption<T = readonly SeyfertChoice<number>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Integer, T, R, VC> & {
+    autocomplete?: AutocompleteCallback<number>;
+    onAutocompleteError?: OnAutocompleteErrorCallback<number>;
     min_value?: number;
     max_value?: number;
 };
-export type SeyfertNumberOption<T = SeyfertChoice<number>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Number, T, R, VC> & {
-    autocomplete?: AutocompleteCallback;
-    onAutocompleteError?: OnAutocompleteErrorCallback;
+export type SeyfertNumberOption<T = readonly SeyfertChoice<number>[], R = boolean, VC = never> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Number, T, R, VC> & {
+    autocomplete?: AutocompleteCallback<number>;
+    onAutocompleteError?: OnAutocompleteErrorCallback<number>;
     min_value?: number;
     max_value?: number;
 };
@@ -81,12 +81,12 @@ export type SeyfertChannelOption<C = keyof SeyfertChannelMap, R = true | false,
         name?: FlatObjectKeys<DefaultLocale>;
         description?: FlatObjectKeys<DefaultLocale>;
     };
-    channel_types?: C[];
+    channel_types?: readonly C[];
 };
 export type SeyfertRoleOption<R = boolean> = SeyfertBasicOption<ApplicationCommandOptionType.Role, R>;
 export type SeyfertMentionableOption<R = boolean> = SeyfertBasicOption<ApplicationCommandOptionType.Mentionable, R>;
 export type SeyfertAttachmentOption<R = boolean> = SeyfertBasicOption<ApplicationCommandOptionType.Attachment, R>;
-export declare function createStringOption<R extends boolean, C extends SeyfertChoice<string>[] = SeyfertChoice<string>[], VC = never>(data: SeyfertStringOption<C, R, VC>): {
+export declare function createStringOption<R extends boolean, C extends readonly SeyfertChoice<string>[] = readonly SeyfertChoice<string>[], VC = never>(data: SeyfertStringOption<C, R, VC>): {
     readonly type: ApplicationCommandOptionType.String;
     readonly required?: R | undefined;
     readonly choices?: C | undefined;
@@ -98,12 +98,12 @@ export declare function createStringOption<R extends boolean, C extends SeyfertC
         name?: FlatObjectKeys<DefaultLocale>;
         description?: FlatObjectKeys<DefaultLocale>;
     };
-    readonly autocomplete?: AutocompleteCallback;
-    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly autocomplete?: AutocompleteCallback<string>;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback<string>;
     readonly min_length?: number;
     readonly max_length?: number;
 };
-export declare function createIntegerOption<R extends boolean, C extends SeyfertChoice<number>[] = SeyfertChoice<number>[], VC = never>(data: SeyfertIntegerOption<C, R, VC>): {
+export declare function createIntegerOption<R extends boolean, C extends readonly SeyfertChoice<number>[] = readonly SeyfertChoice<number>[], VC = never>(data: SeyfertIntegerOption<C, R, VC>): {
     readonly type: ApplicationCommandOptionType.Integer;
     readonly required?: R | undefined;
     readonly choices?: C | undefined;
@@ -115,12 +115,12 @@ export declare function createIntegerOption<R extends boolean, C extends Seyfert
         name?: FlatObjectKeys<DefaultLocale>;
         description?: FlatObjectKeys<DefaultLocale>;
     };
-    readonly autocomplete?: AutocompleteCallback;
-    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly autocomplete?: AutocompleteCallback<number>;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback<number>;
     readonly min_value?: number;
     readonly max_value?: number;
 };
-export declare function createNumberOption<R extends boolean, C extends SeyfertChoice<number>[] = SeyfertChoice<number>[], VC = never>(data: SeyfertNumberOption<C, R, VC>): {
+export declare function createNumberOption<R extends boolean, C extends readonly SeyfertChoice<number>[] = readonly SeyfertChoice<number>[], VC = never>(data: SeyfertNumberOption<C, R, VC>): {
     readonly type: ApplicationCommandOptionType.Number;
     readonly required?: R | undefined;
     readonly choices?: C | undefined;
@@ -132,8 +132,8 @@ export declare function createNumberOption<R extends boolean, C extends SeyfertC
         name?: FlatObjectKeys<DefaultLocale>;
         description?: FlatObjectKeys<DefaultLocale>;
     };
-    readonly autocomplete?: AutocompleteCallback;
-    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly autocomplete?: AutocompleteCallback<number>;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback<number>;
     readonly min_value?: number;
     readonly max_value?: number;
 };
@@ -148,7 +148,7 @@ export declare function createChannelOption<R extends boolean, C extends keyof S
         name?: FlatObjectKeys<DefaultLocale>;
         description?: FlatObjectKeys<DefaultLocale>;
     };
-    readonly channel_types?: C[] | undefined;
+    readonly channel_types?: readonly C[] | undefined;
 };
 export declare function createBooleanOption<R extends boolean, T extends SeyfertBooleanOption<R> = SeyfertBooleanOption<R>>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Boolean;

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

@@ -1,25 +1,31 @@
 import type { CategoryChannelStructure, DirectoryChannelStructure, DMChannelStructure, ForumChannelStructure, MediaChannelStructure, NewsChannelStructure, StageChannelStructure, TextGuildChannelStructure, ThreadChannelStructure, VoiceChannelStructure } from '../../client';
 import type { BaseClient } from '../../client/base';
+import type { RegisteredPluginContext, RegisteredPluginExtension, SeyfertRegistry } from '../../client/plugins';
 import type { IsStrictlyUndefined } from '../../common';
 import type { ChannelType } from '../../types';
-import type { RegisteredMiddlewares } from '../decorators';
+import type { ResolvedRegisteredMiddlewares } from '../decorators';
 export type OKFunction<T> = (value: T) => void;
-export type StopFunction = (error: string) => void;
+export type StopFunction = (error?: string | null) => void;
 export type NextFunction<T = unknown> = IsStrictlyUndefined<T> extends true ? () => void : (data: T) => void;
-export type PassFunction = () => void;
 export type InferWithPrefix = InternalOptions extends {
     withPrefix: infer P;
 } ? P : false;
 export interface GlobalMetadata {
 }
-export interface DefaultLocale {
-}
-export interface ExtendContext {
+export type DefaultLocale = SeyfertRegistry extends {
+    langs: infer L extends Record<string, any>;
+} ? L : {};
+export interface ExtendContext extends RegisteredPluginContext {
 }
 export interface ExtraProps {
 }
-export interface UsingClient extends BaseClient {
-}
+declare const __seyfertClientType: unique symbol;
+type RegisteredClient = SeyfertRegistry extends {
+    client: infer C;
+} ? [C] extends [{
+    readonly [__seyfertClientType]?: infer T;
+}] ? [T] extends [never] ? BaseClient : unknown extends T ? C extends BaseClient ? C : BaseClient : T & Omit<C, typeof __seyfertClientType> : C extends BaseClient ? C : BaseClient : BaseClient;
+export type UsingClient = BaseClient & RegisteredPluginExtension & RegisteredClient;
 export interface CustomWorkerClientEvents {
 }
 export interface CustomWorkerManagerEvents {
@@ -28,8 +34,10 @@ export interface ExtendedRC {
 }
 export interface ExtendedRCLocations {
 }
-export type ParseClient<T extends BaseClient> = T;
-export type ParseGlobalMiddlewares<T extends Record<string, MiddlewareContext>> = {
+export type ParseClient<T extends BaseClient> = T & {
+    readonly [__seyfertClientType]?: T;
+};
+export type ParseGlobalMiddlewares<T extends Record<string, AnyMiddlewareContext>> = {
     [K in keyof T]: MetadataMiddleware<T[K]>;
 };
 export interface InternalOptions {
@@ -40,16 +48,29 @@ export type MiddlewareContext<T = any, C = any> = (context: {
     context: C;
     next: NextFunction<T>;
     stop: StopFunction;
-    pass: PassFunction;
 }) => any;
-export type MetadataMiddleware<T extends MiddlewareContext> = IsStrictlyUndefined<Parameters<Parameters<T>[0]['next']>[0]> extends true ? never : Parameters<Parameters<T>[0]['next']>[0];
-export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]> = T extends readonly [
+export type AnyMiddlewareContext = (context: {
+    context: any;
+    next: any;
+    stop: StopFunction;
+}) => any;
+export type MetadataMiddleware<T extends AnyMiddlewareContext> = T extends (context: infer Payload) => any ? Payload extends {
+    next: (...args: infer Args) => unknown;
+} ? IsStrictlyUndefined<Args[0]> extends true ? never : Args[0] : never : never;
+type MetadataForMiddleware<T extends keyof ResolvedRegisteredMiddlewares> = ResolvedRegisteredMiddlewares[T] extends infer Middleware extends AnyMiddlewareContext ? MetadataMiddleware<Middleware> : never;
+type OmitNever<T extends object> = {
+    [key in keyof T as [T[key]] extends [never] ? never : key]: T[key];
+};
+type MiddlewareMetadata<T extends keyof ResolvedRegisteredMiddlewares> = OmitNever<{
+    [key in T]: MetadataForMiddleware<key>;
+}>;
+type CommandMetadataFromUnion<T extends keyof ResolvedRegisteredMiddlewares> = [T] extends [never] ? {} : MiddlewareMetadata<T>;
+type CommandMetadataFromTuple<T extends readonly (keyof ResolvedRegisteredMiddlewares)[]> = T extends readonly [
     infer first,
     ...infer rest
-] ? first extends keyof RegisteredMiddlewares ? (MetadataMiddleware<RegisteredMiddlewares[first]> extends never ? {} : {
-    [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
-}) & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : never) : {} : {};
-export type MessageCommandOptionErrors = ['CHANNEL_TYPES', type: ChannelType[]] | ['STRING_MIN_LENGTH', min: number] | ['STRING_MAX_LENGTH', max: number] | ['STRING_INVALID_CHOICE', choices: readonly {
+] ? first extends keyof ResolvedRegisteredMiddlewares ? MiddlewareMetadata<first> & (rest extends readonly (keyof ResolvedRegisteredMiddlewares)[] ? CommandMetadataFromTuple<rest> : never) : {} : {};
+export type CommandMetadata<T extends readonly (keyof ResolvedRegisteredMiddlewares)[] | keyof ResolvedRegisteredMiddlewares> = [T] extends [never] ? {} : [T] extends [readonly (keyof ResolvedRegisteredMiddlewares)[]] ? CommandMetadataFromTuple<T> : [T] extends [keyof ResolvedRegisteredMiddlewares] ? CommandMetadataFromUnion<T> : {};
+export type MessageCommandOptionErrors = ['CHANNEL_TYPES', type: readonly ChannelType[]] | ['STRING_MIN_LENGTH', min: number] | ['STRING_MAX_LENGTH', max: number] | ['STRING_INVALID_CHOICE', choices: readonly {
     name: string;
     value: string;
 }[]] | ['NUMBER_NAN', value: string] | ['NUMBER_MIN_VALUE', min: number] | ['NUMBER_MAX_VALUE', max: number] | ['NUMBER_INVALID_CHOICE', choices: readonly {
@@ -84,3 +105,4 @@ export interface SeyfertChannelMap {
     [ChannelType.GuildForum]: ForumChannelStructure;
     [ChannelType.GuildMedia]: MediaChannelStructure;
 }
+export {};