seyfert 0.1.0

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

@@ -0,0 +1,67 @@
+import { ApplicationCommandOptionType, type APIApplicationCommandOptionChoice, type ChannelType } from 'discord-api-types/v10';
+import type { AutocompleteCallback, OnAutocompleteErrorCallback, ReturnOptionsTypes, __TypesWrapper } from '..';
+import type { CommandContext } from './chatcontext';
+import type { MiddlewareContext } from './shared';
+type SeyfertBasicOption<T extends keyof __TypesWrapper, D = {}> = __TypesWrapper[T] & D;
+type SeyfertStringOption = SeyfertBasicOption<'String'> & {
+    autocomplete?: AutocompleteCallback;
+    onAutocompleteError?: OnAutocompleteErrorCallback;
+    choices?: readonly {
+        readonly name: string;
+        readonly value: string;
+    }[] | APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.String]>[];
+    min_length?: number;
+    max_length?: number;
+};
+type SeyfertIntegerOption = SeyfertBasicOption<'Integer'> & {
+    autocomplete?: AutocompleteCallback;
+    onAutocompleteError?: OnAutocompleteErrorCallback;
+    choices?: APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.Integer]>[];
+    min_value?: number;
+    max_value?: number;
+};
+type SeyfertBooleanOption = SeyfertBasicOption<'Boolean'>;
+type SeyfertUserOption = SeyfertBasicOption<'User'>;
+type SeyfertChannelOption = SeyfertBasicOption<'Channel'> & {
+    channel_types?: ChannelType[];
+};
+type SeyfertRoleOption = SeyfertBasicOption<'Role'>;
+type SeyfertMentionableOption = SeyfertBasicOption<'Mentionable'>;
+type SeyfertNumberOption = SeyfertBasicOption<'Number'> & {
+    autocomplete?: AutocompleteCallback;
+    onAutocompleteError?: OnAutocompleteErrorCallback;
+    choices?: APIApplicationCommandOptionChoice<ReturnOptionsTypes[ApplicationCommandOptionType.Number]>[];
+    min_value?: number;
+    max_value?: number;
+};
+type SeyfertAttachmentOption = SeyfertBasicOption<'Attachment'>;
+export declare function createStringOption<T extends SeyfertStringOption = SeyfertStringOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.String;
+};
+export declare function createIntegerOption<T extends SeyfertIntegerOption = SeyfertIntegerOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.Integer;
+};
+export declare function createBooleanOption<T extends SeyfertBooleanOption = SeyfertBooleanOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.Boolean;
+};
+export declare function createUserOption<T extends SeyfertUserOption = SeyfertUserOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.User;
+};
+export declare function createChannelOption<T extends SeyfertChannelOption = SeyfertChannelOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.Channel;
+};
+export declare function createRoleOption<T extends SeyfertRoleOption = SeyfertRoleOption>(data: T): T & {
+    readonly type: ApplicationCommandOptionType.Role;
+};
+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;
+};
+export type ParseMiddlewareType<T> = T extends MiddlewareContext<any, CommandContext> ? T : MiddlewareContext<T, CommandContext>;
+export declare function createMiddleware<T = ParseMiddlewareType<unknown>>(data: ParseMiddlewareType<T>): ParseMiddlewareType<T>;
+export {};

package/lib/commands/applications/options.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMiddleware = exports.createAttachmentOption = exports.createNumberOption = exports.createMentionableOption = exports.createRoleOption = exports.createChannelOption = exports.createUserOption = exports.createBooleanOption = exports.createIntegerOption = exports.createStringOption = void 0;
+const v10_1 = require("discord-api-types/v10");
+function createStringOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.String };
+}
+exports.createStringOption = createStringOption;
+function createIntegerOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Integer };
+}
+exports.createIntegerOption = createIntegerOption;
+function createBooleanOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Boolean };
+}
+exports.createBooleanOption = createBooleanOption;
+function createUserOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.User };
+}
+exports.createUserOption = createUserOption;
+function createChannelOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Channel };
+}
+exports.createChannelOption = createChannelOption;
+function createRoleOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Role };
+}
+exports.createRoleOption = createRoleOption;
+function createMentionableOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Mentionable };
+}
+exports.createMentionableOption = createMentionableOption;
+function createNumberOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Number };
+}
+exports.createNumberOption = createNumberOption;
+function createAttachmentOption(data) {
+    return { ...data, type: v10_1.ApplicationCommandOptionType.Attachment };
+}
+exports.createAttachmentOption = createAttachmentOption;
+function createMiddleware(data) {
+    return data;
+}
+exports.createMiddleware = createMiddleware;

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

@@ -0,0 +1,35 @@
+import type { BaseClient } from '../../client/base';
+import type { RegisteredMiddlewares } from '../decorators';
+export type OKFunction<T> = (value: T) => void;
+export type StopFunction = (error: Error) => void;
+export type NextFunction<T = unknown> = (data: T) => void;
+export type PassFunction = () => void;
+export interface GlobalMetadata {
+}
+export interface DefaultLocale {
+}
+export interface ExtendContext {
+}
+export interface UsingClient extends BaseClient {
+}
+export type ParseClient<T extends BaseClient> = T;
+export type MiddlewareContext<T = any, C = any> = (context: {
+    context: C;
+    next: NextFunction<T>;
+    stop: StopFunction;
+    pass: PassFunction;
+}) => any;
+export type MetadataMiddleware<T extends MiddlewareContext> = Parameters<Parameters<T>[0]['next']>[0];
+export type CommandMetadata<T extends readonly (keyof RegisteredMiddlewares)[]> = T extends readonly [
+    infer first,
+    ...infer rest
+] ? first extends keyof RegisteredMiddlewares ? {
+    [key in first]: MetadataMiddleware<RegisteredMiddlewares[first]>;
+} & (rest extends readonly (keyof RegisteredMiddlewares)[] ? CommandMetadata<rest> : {}) : {} : {};
+export type OnOptionsReturnObject = Record<string, {
+    failed: false;
+    value: unknown;
+} | {
+    failed: true;
+    value: Error;
+}>;

package/lib/commands/applications/shared.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commands/decorators.d.ts

@@ -0,0 +1,107 @@
+import { ApplicationCommandType, type LocaleString, type PermissionStrings } from '../common';
+import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
+import type { MiddlewareContext } from './applications/shared';
+export interface RegisteredMiddlewares {
+}
+type DeclareOptions = {
+    name: string;
+    description: string;
+    permissions?: PermissionStrings | bigint;
+    defaultPermissions?: PermissionStrings | bigint;
+    guildId?: string[];
+    dm?: boolean;
+    nsfw?: boolean;
+} | (Omit<{
+    name: string;
+    description: string;
+    permissions?: PermissionStrings | bigint;
+    defaultPermissions?: PermissionStrings | bigint;
+    guildId?: string[];
+    dm?: boolean;
+    nsfw?: boolean;
+}, 'type' | 'description'> & {
+    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+});
+export declare function Locales({ name: names, description: descriptions, }: {
+    name?: [language: LocaleString, value: string][];
+    description?: [language: LocaleString, value: string][];
+}): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        name_localizations: {
+            [k: string]: string;
+        } | undefined;
+        description_localizations: {
+            [k: string]: string;
+        } | undefined;
+    };
+} & T;
+export declare function LocalesT(name: string, description: string): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        __t: {
+            name: string;
+            description: string;
+        };
+    };
+} & T;
+export declare function GroupsT(groups: Record<string, {
+    name: string;
+    description: string;
+    defaultDescription: string;
+}>): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        __tGroups: Record<string, {
+            name: string;
+            description: string;
+            defaultDescription: string;
+        }>;
+    };
+} & T;
+export declare function Groups(groups: Record<string, {
+    name?: [language: LocaleString, value: string][];
+    description?: [language: LocaleString, value: string][];
+    defaultDescription: string;
+}>): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        groups: Record<string, {
+            name?: [language: "id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", value: string][] | undefined;
+            description?: [language: "id" | "en-US" | "en-GB" | "bg" | "zh-CN" | "zh-TW" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "lt" | "no" | "pl" | "pt-BR" | "ro" | "ru" | "es-ES" | "es-419" | "sv-SE" | "th" | "tr" | "uk" | "vi", value: string][] | undefined;
+            defaultDescription: string;
+        }>;
+    };
+} & T;
+export declare function Group(groupName: string): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        group: string;
+    };
+} & T;
+export declare function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        options: SubCommand[] | CommandOption[];
+    };
+} & T;
+export declare function AutoLoad(): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        __d: boolean;
+    };
+} & T;
+export type ParseMiddlewares<T extends Record<string, MiddlewareContext>> = {
+    [k in keyof T]: T[k];
+};
+export declare function Middlewares(cbs: readonly (keyof RegisteredMiddlewares)[]): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        middlewares: readonly never[];
+    };
+} & T;
+export declare function Declare(declare: DeclareOptions): <T extends new (...args: any[]) => {}>(target: T) => {
+    new (...args: any[]): {
+        name: string;
+        dm: boolean;
+        nsfw: boolean | undefined;
+        guild_id: string[] | undefined;
+        default_member_permissions: string | bigint | undefined;
+        permissions: bigint | undefined;
+        description: string;
+        type: ApplicationCommandType;
+    };
+} & T;
+export {};

package/lib/commands/decorators.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Declare = exports.Middlewares = exports.AutoLoad = exports.Options = exports.Group = exports.Groups = exports.GroupsT = exports.LocalesT = exports.Locales = void 0;
+const common_1 = require("../common");
+function Locales({ name: names, description: descriptions, }) {
+    return (target) => class extends target {
+        name_localizations = names ? Object.fromEntries(names) : undefined;
+        description_localizations = descriptions ? Object.fromEntries(descriptions) : undefined;
+    };
+}
+exports.Locales = Locales;
+function LocalesT(name, description) {
+    return (target) => class extends target {
+        __t = { name, description };
+    };
+}
+exports.LocalesT = LocalesT;
+function GroupsT(groups) {
+    return (target) => class extends target {
+        __tGroups = groups;
+    };
+}
+exports.GroupsT = GroupsT;
+function Groups(groups) {
+    return (target) => class extends target {
+        groups = groups;
+    };
+}
+exports.Groups = Groups;
+function Group(groupName) {
+    return (target) => class extends target {
+        group = groupName;
+    };
+}
+exports.Group = Group;
+function Options(options) {
+    return (target) => class extends target {
+        options = Array.isArray(options)
+            ? options.map(x => new x())
+            : Object.entries(options).map(([name, option]) => {
+                return {
+                    name,
+                    ...option,
+                };
+            });
+    };
+}
+exports.Options = Options;
+function AutoLoad() {
+    return (target) => class extends target {
+        __d = true;
+    };
+}
+exports.AutoLoad = AutoLoad;
+function Middlewares(cbs) {
+    return (target) => class extends target {
+        middlewares = cbs;
+    };
+}
+exports.Middlewares = Middlewares;
+function Declare(declare) {
+    return (target) => class extends target {
+        name = declare.name;
+        dm = !!declare.dm;
+        nsfw = declare.nsfw;
+        guild_id = declare.guildId;
+        default_member_permissions = Array.isArray(declare.defaultPermissions)
+            ? declare.defaultPermissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0)).toString()
+            : declare.defaultPermissions;
+        permissions = Array.isArray(declare.permissions)
+            ? declare.permissions?.reduce((acc, prev) => acc | common_1.PermissionFlagsBits[prev], BigInt(0))
+            : declare.permissions;
+        description = '';
+        type = common_1.ApplicationCommandType.ChatInput;
+        constructor(...args) {
+            super(...args);
+            if ('description' in declare)
+                this.description = declare.description;
+            if ('type' in declare)
+                this.type = declare.type;
+            // check if all properties are valid
+        }
+    };
+}
+exports.Declare = Declare;

package/lib/commands/handler.d.ts

@@ -0,0 +1,15 @@
+import type { BaseClient } from '../client/base';
+import type { Logger } from '../common';
+import { BaseHandler } from '../common';
+import { Command } from './applications/chat';
+import { ContextMenuCommand } from './applications/menu';
+export declare class CommandHandler extends BaseHandler {
+    protected logger: Logger;
+    values: (Command | ContextMenuCommand)[];
+    protected filter: (path: string) => boolean;
+    constructor(logger: Logger);
+    reload(resolve: string | Command): Promise<void>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
+    load(commandsDir: string, client: BaseClient): Promise<(Command | ContextMenuCommand)[]>;
+    private __parseLocales;
+}

package/lib/commands/handler.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandler = void 0;
+const node_path_1 = require("node:path");
+const common_1 = require("../common");
+const chat_1 = require("./applications/chat");
+const menu_1 = require("./applications/menu");
+class CommandHandler extends common_1.BaseHandler {
+    logger;
+    values = [];
+    filter = (path) => path.endsWith('.js') || path.endsWith('.ts');
+    constructor(logger) {
+        super(logger);
+        this.logger = logger;
+    }
+    async reload(resolve) {
+        if (typeof resolve === 'string') {
+            return this.values.find(x => x.name === resolve)?.reload();
+        }
+        return resolve.reload();
+    }
+    async reloadAll(stopIfFail = true) {
+        for (const command of this.values) {
+            try {
+                await this.reload(command.name);
+            }
+            catch (e) {
+                if (stopIfFail) {
+                    throw e;
+                }
+            }
+        }
+    }
+    async load(commandsDir, client) {
+        const result = (await this.loadFilesK(await this.getFiles(commandsDir))).filter(x => x.file);
+        this.values = [];
+        for (const command of result) {
+            let commandInstance;
+            try {
+                commandInstance = new command.file();
+            }
+            catch (e) {
+                if (e instanceof Error && e.message === 'command.file is not a constructor') {
+                    this.logger.warn(`${command.path
+                        .split(process.cwd())
+                        .slice(1)
+                        .join(process.cwd())} doesn't export the class by \`export default <Command>\``);
+                }
+                else
+                    this.logger.warn(e, command);
+                continue;
+            }
+            if (commandInstance instanceof menu_1.ContextMenuCommand) {
+                this.values.push(commandInstance);
+                commandInstance.__filePath = command.path;
+                continue;
+            }
+            if (!(commandInstance instanceof chat_1.Command)) {
+                continue;
+            }
+            commandInstance.__filePath = command.path;
+            commandInstance.options ??= [];
+            if (commandInstance.__d) {
+                const options = await this.getFiles((0, node_path_1.dirname)(command.path));
+                for (const option of options) {
+                    if (command.name === (0, node_path_1.basename)(option)) {
+                        continue;
+                    }
+                    try {
+                        const subCommand = new (result.find(x => x.path === option).file)();
+                        if (subCommand instanceof chat_1.SubCommand) {
+                            commandInstance.options.push(subCommand);
+                        }
+                    }
+                    catch {
+                        //pass
+                    }
+                }
+            }
+            for (const option of commandInstance.options ?? []) {
+                if (option instanceof chat_1.SubCommand) {
+                    option.middlewares = (commandInstance.middlewares ?? []).concat(option.middlewares ?? []);
+                    option.onMiddlewaresError =
+                        option.onMiddlewaresError?.bind(option) ?? commandInstance.onMiddlewaresError?.bind(commandInstance);
+                    option.onRunError = option.onRunError?.bind(option) ?? commandInstance.onRunError?.bind(commandInstance);
+                    option.onOptionsError =
+                        option.onOptionsError?.bind(option) ?? commandInstance.onOptionsError?.bind(commandInstance);
+                    option.onInternalError =
+                        option.onInternalError?.bind(option) ?? commandInstance.onInternalError?.bind(commandInstance);
+                    option.onAfterRun = option.onAfterRun?.bind(option) ?? commandInstance.onAfterRun?.bind(commandInstance);
+                }
+            }
+            this.values.push(commandInstance);
+            this.__parseLocales(commandInstance, client);
+            for (const i of commandInstance.options ?? []) {
+                if (i instanceof chat_1.SubCommand) {
+                    this.__parseLocales(i, client);
+                }
+            }
+        }
+        return this.values;
+    }
+    __parseLocales(command, client) {
+        if (command.__t) {
+            command.name_localizations = {};
+            command.description_localizations = {};
+            for (const locale of Object.keys(client.langs.values)) {
+                const valueName = client.langs.getKey(locale, command.__t.name);
+                if (valueName) {
+                    command.name_localizations[locale] = valueName;
+                }
+                const valueKey = client.langs.getKey(locale, command.__t.description);
+                if (valueKey) {
+                    command.description_localizations[locale] = valueKey;
+                }
+            }
+        }
+        if (command instanceof chat_1.Command && command.__tGroups) {
+            command.groups = {};
+            for (const locale of Object.keys(client.langs.values)) {
+                for (const group in command.__tGroups) {
+                    command.groups[group] ??= {
+                        defaultDescription: command.__tGroups[group].defaultDescription,
+                        description: [],
+                        name: [],
+                    };
+                    const valueName = client.langs.getKey(locale, command.__tGroups[group].name);
+                    if (valueName) {
+                        command.groups[group].name.push([locale, valueName]);
+                    }
+                    const valueKey = client.langs.getKey(locale, command.__tGroups[group].description);
+                    if (valueKey) {
+                        command.groups[group].description.push([locale, valueKey]);
+                    }
+                }
+            }
+        }
+    }
+}
+exports.CommandHandler = CommandHandler;

package/lib/commands/index.d.ts

@@ -0,0 +1,8 @@
+export * from './applications/chat';
+export * from './applications/chatcontext';
+export * from './applications/menu';
+export * from './applications/menucontext';
+export * from './applications/options';
+export * from './applications/shared';
+export * from './decorators';
+export * from './optionresolver';

package/lib/commands/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./applications/chat"), exports);
+__exportStar(require("./applications/chatcontext"), exports);
+__exportStar(require("./applications/menu"), exports);
+__exportStar(require("./applications/menucontext"), exports);
+__exportStar(require("./applications/options"), exports);
+__exportStar(require("./applications/shared"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./optionresolver"), exports);

package/lib/commands/optionresolver.d.ts

@@ -0,0 +1,49 @@
+import type { APIApplicationCommandInteractionDataOption, APIAttachment, APIInteractionDataResolved, MakeRequired } from '../common';
+import { ApplicationCommandOptionType } from '../common';
+import type { AllChannels } from '../structures';
+import { GuildRole, InteractionGuildMember, User } from '../structures';
+import type { Command, CommandAutocompleteOption, SubCommand } from './applications/chat';
+import type { UsingClient } from './applications/shared';
+export declare class OptionResolver {
+    private client;
+    parent?: Command | undefined;
+    guildId?: string | undefined;
+    resolved?: APIInteractionDataResolved | undefined;
+    readonly options: OptionResolved[];
+    hoistedOptions: OptionResolved[];
+    private subCommand;
+    private group;
+    constructor(client: UsingClient, options: APIApplicationCommandInteractionDataOption[], parent?: Command | undefined, guildId?: string | undefined, resolved?: APIInteractionDataResolved | undefined);
+    get fullCommandName(): string;
+    getCommand(): SubCommand | Command | undefined;
+    getAutocompleteValue(): string | undefined;
+    getAutocomplete(): CommandAutocompleteOption | undefined;
+    getParent(): string | undefined;
+    getSubCommand(): string | null;
+    getGroup(): string | null;
+    get(name: string): OptionResolved | undefined;
+    getHoisted(name: string): OptionResolved | undefined;
+    getValue(name: string): string | number | boolean | APIAttachment | InteractionGuildMember | User | import("../structures").BaseChannel<import("discord-api-types/payloads/v10/channel").ChannelType> | import("../structures").DMChannel | import("../structures").CategoryChannel | GuildRole | undefined;
+    private getTypedOption;
+    getChannel(name: string, required?: true): AllChannels;
+    getString(name: string, required?: true): string;
+    transformOption(option: APIApplicationCommandInteractionDataOption, resolved?: APIInteractionDataResolved): OptionResolved;
+}
+export interface OptionResolved {
+    name: string;
+    type: ApplicationCommandOptionType;
+    value?: string | number | boolean;
+    options?: OptionResolved[];
+    user?: User;
+    member?: InteractionGuildMember;
+    attachment?: APIAttachment;
+    channel?: AllChannels;
+    role?: GuildRole;
+    focused?: boolean;
+}
+export type OptionResolvedWithValue = MakeRequired<Pick<OptionResolved, 'name' | 'value' | 'focused'>, 'value'> & {
+    type: ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Integer | ApplicationCommandOptionType.Number | ApplicationCommandOptionType.String;
+};
+export type OptionResolvedWithProp = Exclude<OptionResolved, {
+    type: ApplicationCommandOptionType.Boolean | ApplicationCommandOptionType.Integer | ApplicationCommandOptionType.Number | ApplicationCommandOptionType.String;
+}>;