seyfert 2.1.0 → 2.1.1-dev-11316886063.0

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,48 +1,127 @@
-import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from '../../types';
-import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
-import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
-import type { CommandContext } from './chatcontext';
-import type { MiddlewareContext } from './shared';
+import type { AutocompleteCallback, EntryPointContext, MenuCommandContext, OnAutocompleteErrorCallback, ReturnOptionsTypes } from '..';
+import type { Awaitable, FlatObjectKeys } from '../../common';
 import type { ModalContext } from '../../components';
 import type { ComponentContext } from '../../components/componentcontext';
-export type SeyfertBasicOption<T extends keyof __TypesWrapper, D = {}> = __TypesWrapper[T] & D;
-export type SeyfertStringOption = SeyfertBasicOption<'String'> & {
+import type { MessageCommandInteraction, UserCommandInteraction } from '../../structures';
+import { type APIApplicationCommandBasicOption, type APIApplicationCommandOptionChoice, ApplicationCommandOptionType, type ChannelType } from '../../types';
+import type { CommandContext } from './chatcontext';
+import type { DefaultLocale, MiddlewareContext, OKFunction, StopFunction } from './shared';
+export interface SeyfertBasicOption<T extends keyof ReturnOptionsTypes> {
+    required?: boolean;
+    value?(data: {
+        context: CommandContext;
+        value: ReturnOptionsTypes[T];
+    }, ok: OKFunction<any>, fail: StopFunction): Awaitable<void>;
+    description: string;
+    description_localizations?: APIApplicationCommandBasicOption['description_localizations'];
+    name_localizations?: APIApplicationCommandBasicOption['name_localizations'];
+    locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
+}
+export interface SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never> {
+    required?: boolean;
+    choices?: C;
+    value?: ValueCallback<T, C>;
+    description: string;
+    description_localizations?: APIApplicationCommandBasicOption['description_localizations'];
+    name_localizations?: APIApplicationCommandBasicOption['name_localizations'];
+    locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
+}
+export type SeyfertChoice<T extends string | number> = {
+    readonly name: string;
+    readonly value: T;
+} | APIApplicationCommandOptionChoice<T>;
+export type ChoiceableTypes = ApplicationCommandOptionType.String | ApplicationCommandOptionType.Integer | ApplicationCommandOptionType.Number;
+export interface ChoiceableValues {
+    [ApplicationCommandOptionType.String]: string;
+    [ApplicationCommandOptionType.Number]: number;
+    [ApplicationCommandOptionType.Integer]: number;
+}
+export type ValueCallback<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never> = (data: {
+    context: CommandContext;
+    value: T extends ChoiceableTypes ? C extends SeyfertChoice<ChoiceableValues[T]>[] ? C[number]['value'] extends ReturnOptionsTypes[T] ? C[number]['value'] : ReturnOptionsTypes[T] : ReturnOptionsTypes[T] : ReturnOptionsTypes[T];
+}, ok: OKFunction<any>, fail: StopFunction) => Awaitable<void>;
+export type SeyfertStringOption<T = SeyfertChoice<string>[]> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, T> & {
     autocomplete?: AutocompleteCallback;
     onAutocompleteError?: OnAutocompleteErrorCallback;
-    choices?: readonly {
-        readonly name: string;
-        readonly value: string;
-    }[] | APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.String]>[];
     min_length?: number;
     max_length?: number;
 };
-export type SeyfertIntegerOption = SeyfertBasicOption<'Integer'> & {
+export type SeyfertIntegerOption<T = SeyfertChoice<number>[]> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Integer, T> & {
     autocomplete?: AutocompleteCallback;
     onAutocompleteError?: OnAutocompleteErrorCallback;
-    choices?: APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.Integer]>[];
     min_value?: number;
     max_value?: number;
 };
-export type SeyfertBooleanOption = SeyfertBasicOption<'Boolean'>;
-export type SeyfertUserOption = SeyfertBasicOption<'User'>;
-export type SeyfertChannelOption = SeyfertBasicOption<'Channel'> & {
-    channel_types?: ChannelType[];
-};
-export type SeyfertRoleOption = SeyfertBasicOption<'Role'>;
-export type SeyfertMentionableOption = SeyfertBasicOption<'Mentionable'>;
-export type SeyfertNumberOption = SeyfertBasicOption<'Number'> & {
+export type SeyfertNumberOption<T = SeyfertChoice<number>[]> = SeyfertBaseChoiceableOption<ApplicationCommandOptionType.Number, T> & {
     autocomplete?: AutocompleteCallback;
     onAutocompleteError?: OnAutocompleteErrorCallback;
-    choices?: APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.Number]>[];
     min_value?: number;
     max_value?: number;
 };
-export type SeyfertAttachmentOption = SeyfertBasicOption<'Attachment'>;
-export declare function createStringOption<T extends SeyfertStringOption = SeyfertStringOption>(data: T): T & {
+export type SeyfertBooleanOption = SeyfertBasicOption<ApplicationCommandOptionType.Boolean>;
+export type SeyfertUserOption = SeyfertBasicOption<ApplicationCommandOptionType.User>;
+export type SeyfertChannelOption = SeyfertBasicOption<ApplicationCommandOptionType.Channel> & {
+    channel_types?: ChannelType[];
+};
+export type SeyfertRoleOption = SeyfertBasicOption<ApplicationCommandOptionType.Role>;
+export type SeyfertMentionableOption = SeyfertBasicOption<ApplicationCommandOptionType.Mentionable>;
+export type SeyfertAttachmentOption = SeyfertBasicOption<ApplicationCommandOptionType.Attachment>;
+export declare function createStringOption<C extends SeyfertChoice<string>[] = SeyfertChoice<string>[]>(data: SeyfertStringOption<C>): {
     readonly type: ApplicationCommandOptionType.String;
+    readonly required?: boolean;
+    readonly choices?: C | undefined;
+    readonly value?: ValueCallback<ApplicationCommandOptionType.String, C> | undefined;
+    readonly description: string;
+    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
+    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
+    readonly locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
+    readonly autocomplete?: AutocompleteCallback;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly min_length?: number;
+    readonly max_length?: number;
 };
-export declare function createIntegerOption<T extends SeyfertIntegerOption = SeyfertIntegerOption>(data: T): T & {
+export declare function createIntegerOption<C extends SeyfertChoice<number>[] = SeyfertChoice<number>[]>(data: SeyfertIntegerOption<C>): {
     readonly type: ApplicationCommandOptionType.Integer;
+    readonly required?: boolean;
+    readonly choices?: C | undefined;
+    readonly value?: ValueCallback<ApplicationCommandOptionType.Integer, C> | undefined;
+    readonly description: string;
+    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
+    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
+    readonly locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
+    readonly autocomplete?: AutocompleteCallback;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly min_value?: number;
+    readonly max_value?: number;
+};
+export declare function createNumberOption<C extends SeyfertChoice<number>[] = SeyfertChoice<number>[]>(data: SeyfertNumberOption<C>): {
+    readonly type: ApplicationCommandOptionType.Number;
+    readonly required?: boolean;
+    readonly choices?: C | undefined;
+    readonly value?: ValueCallback<ApplicationCommandOptionType.Number, C> | undefined;
+    readonly description: string;
+    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
+    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
+    readonly locales?: {
+        name?: FlatObjectKeys<DefaultLocale>;
+        description?: FlatObjectKeys<DefaultLocale>;
+    };
+    readonly autocomplete?: AutocompleteCallback;
+    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
+    readonly min_value?: number;
+    readonly max_value?: number;
 };
 export declare function createBooleanOption<T extends SeyfertBooleanOption = SeyfertBooleanOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Boolean;
@@ -59,9 +138,6 @@ export declare function createRoleOption<T extends SeyfertRoleOption = SeyfertRo
 export declare function createMentionableOption<T extends SeyfertMentionableOption = SeyfertMentionableOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Mentionable;
 };
-export declare function createNumberOption<T extends SeyfertNumberOption = SeyfertNumberOption>(data: T): T & {
-    readonly type: ApplicationCommandOptionType.Number;
-};
 export declare function createAttachmentOption<T extends SeyfertAttachmentOption = SeyfertAttachmentOption>(data: T): T & {
     readonly type: ApplicationCommandOptionType.Attachment;
 };

package/lib/commands/applications/options.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStringOption = createStringOption;
 exports.createIntegerOption = createIntegerOption;
+exports.createNumberOption = createNumberOption;
 exports.createBooleanOption = createBooleanOption;
 exports.createUserOption = createUserOption;
 exports.createChannelOption = createChannelOption;
 exports.createRoleOption = createRoleOption;
 exports.createMentionableOption = createMentionableOption;
-exports.createNumberOption = createNumberOption;
 exports.createAttachmentOption = createAttachmentOption;
 exports.createMiddleware = createMiddleware;
 const types_1 = require("../../types");
@@ -17,6 +17,9 @@ function createStringOption(data) {
 function createIntegerOption(data) {
     return { ...data, type: types_1.ApplicationCommandOptionType.Integer };
 }
+function createNumberOption(data) {
+    return { ...data, type: types_1.ApplicationCommandOptionType.Number };
+}
 function createBooleanOption(data) {
     return { ...data, type: types_1.ApplicationCommandOptionType.Boolean };
 }
@@ -32,9 +35,6 @@ function createRoleOption(data) {
 function createMentionableOption(data) {
     return { ...data, type: types_1.ApplicationCommandOptionType.Mentionable };
 }
-function createNumberOption(data) {
-    return { ...data, type: types_1.ApplicationCommandOptionType.Number };
-}
 function createAttachmentOption(data) {
     return { ...data, type: types_1.ApplicationCommandOptionType.Attachment };
 }

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,5 +1,5 @@
-import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, 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 {
@@ -27,7 +27,7 @@ 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: {
@@ -39,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: {
@@ -54,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, {
@@ -72,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, {
@@ -85,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;
@@ -109,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: CommandDeclareOptions): <T extends {
-    new (...args: any[]): {};
+    new (...args: any[]): object;
 }>(target: T) => {
     new (...args: any[]): {
         name: string;

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,11 +87,11 @@ 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;

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, 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 { 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;
 };
@@ -36,10 +36,10 @@ export declare class HandleCommand {
         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>;
+    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;