seyfert 0.1.0

package/lib/structures/Interaction.d.ts

@@ -0,0 +1,152 @@
+import type { BaseClient } from '../client/base';
+import { OptionResolver, type UsingClient } from '../commands';
+import type { APIApplicationCommandAutocompleteInteraction, APIApplicationCommandInteraction, APIBaseInteraction, APIChatInputApplicationCommandInteraction, APIChatInputApplicationCommandInteractionData, APICommandAutocompleteInteractionResponseCallbackData, APIInteraction, APIInteractionResponse, APIInteractionResponseChannelMessageWithSource, APIInteractionResponseDeferredChannelMessageWithSource, APIInteractionResponseDeferredMessageUpdate, APIInteractionResponsePong, APIInteractionResponseUpdateMessage, APIMessageApplicationCommandInteraction, APIMessageApplicationCommandInteractionData, APIMessageButtonInteractionData, APIMessageComponentInteraction, APIMessageComponentSelectMenuInteraction, APIMessageStringSelectInteractionData, APIModalSubmission, APIModalSubmitInteraction, APIUserApplicationCommandInteraction, APIUserApplicationCommandInteractionData, GatewayInteractionCreateDispatchData, MessageFlags, ObjectToLower, OmitInsert, RESTPostAPIInteractionCallbackJSONBody, ToClass, When } from '../common';
+import { ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType } from '../common';
+import type { ComponentInteractionMessageUpdate, InteractionCreateBodyRequest, InteractionMessageUpdateBodyRequest, MessageCreateBodyRequest, MessageUpdateBodyRequest, MessageWebhookCreateBodyRequest, ModalCreateBodyRequest } from '../common/types/write';
+import { InteractionGuildMember, type AllChannels } from './';
+import { GuildRole } from './GuildRole';
+import { Message, type WebhookMessage } from './Message';
+import { User } from './User';
+import { DiscordBase } from './extra/DiscordBase';
+import { PermissionsBitField } from './extra/Permissions';
+export type ReplyInteractionBody = {
+    type: InteractionResponseType.Modal;
+    data: ModalCreateBodyRequest;
+} | {
+    type: InteractionResponseType.ChannelMessageWithSource | InteractionResponseType.UpdateMessage;
+    data: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest | ComponentInteractionMessageUpdate;
+} | Exclude<RESTPostAPIInteractionCallbackJSONBody, APIInteractionResponsePong>;
+export interface BaseInteraction extends ObjectToLower<Omit<APIBaseInteraction<InteractionType, any>, 'user' | 'member' | 'message' | 'channel' | 'type' | 'app_permissions'>> {
+}
+export declare class BaseInteraction<FromGuild extends boolean = boolean, Type extends APIInteraction = APIInteraction> extends DiscordBase<Type> {
+    readonly client: UsingClient;
+    protected __reply?: __InternalReplyFunction | undefined;
+    user: User;
+    member: When<FromGuild, InteractionGuildMember, undefined>;
+    channel?: AllChannels;
+    message?: Message;
+    replied?: Promise<boolean> | boolean;
+    appPermissions?: PermissionsBitField;
+    constructor(client: UsingClient, interaction: Type, __reply?: __InternalReplyFunction | undefined);
+    static transformBodyRequest(body: ReplyInteractionBody): APIInteractionResponse;
+    static transformBody<T>(body: InteractionMessageUpdateBodyRequest | MessageUpdateBodyRequest | MessageCreateBodyRequest | MessageWebhookCreateBodyRequest): T;
+    private matchReplied;
+    reply(body: ReplyInteractionBody): Promise<void>;
+    deferReply(flags?: MessageFlags): Promise<void>;
+    static from(client: BaseClient, gateway: GatewayInteractionCreateDispatchData, __reply?: __InternalReplyFunction): StringSelectMenuInteraction<string[]> | AutocompleteInteraction<boolean> | BaseInteraction<boolean, import("discord-api-types/payloads/v10/_interactions/ping").APIPingInteraction>;
+}
+export type AllInteractions = AutocompleteInteraction | ChatInputCommandInteraction | UserCommandInteraction | MessageCommandInteraction | ComponentInteraction | SelectMenuInteraction | ModalSubmitInteraction | BaseInteraction;
+export interface AutocompleteInteraction extends ObjectToLower<Omit<APIApplicationCommandAutocompleteInteraction, 'user' | 'member' | 'type' | 'data' | 'message' | 'channel' | 'app_permissions'>> {
+}
+export declare class AutocompleteInteraction<FromGuild extends boolean = boolean> extends BaseInteraction<FromGuild, APIApplicationCommandAutocompleteInteraction> {
+    protected __reply?: __InternalReplyFunction | undefined;
+    type: InteractionType.ApplicationCommandAutocomplete;
+    data: ObjectToLower<APIApplicationCommandAutocompleteInteraction['data']>;
+    options: OptionResolver;
+    constructor(client: BaseClient, interaction: APIApplicationCommandAutocompleteInteraction, __reply?: __InternalReplyFunction | undefined);
+    getInput(): string;
+    respond(choices: APICommandAutocompleteInteractionResponseCallbackData['choices']): Promise<void>;
+    /** @intenal */
+    reply(..._args: unknown[]): Promise<void>;
+}
+export declare class Interaction<FromGuild extends boolean = boolean, Type extends APIInteraction = APIInteraction> extends BaseInteraction<FromGuild, Type> {
+    fetchMessage(messageId: string): Promise<WebhookMessage | undefined>;
+    fetchResponse(): Promise<WebhookMessage | undefined>;
+    write<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
+    modal(body: ModalCreateBodyRequest): Promise<void>;
+    editOrReply<FR extends boolean = false>(body: InteractionCreateBodyRequest, fetchReply?: FR): Promise<When<FR, WebhookMessage, void>>;
+    editMessage(messageId: string, body: InteractionMessageUpdateBodyRequest): Promise<Message>;
+    editResponse(body: InteractionMessageUpdateBodyRequest): Promise<Message>;
+    deleteResponse(): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    createResponse({ files, ...body }: MessageWebhookCreateBodyRequest): Promise<Message>;
+}
+export declare class ApplicationCommandInteraction<FromGuild extends boolean = boolean, Type extends APIApplicationCommandInteraction = APIApplicationCommandInteraction> extends Interaction<FromGuild, Type> {
+    type: ApplicationCommandType;
+    respond(data: APIInteractionResponseChannelMessageWithSource | APIInteractionResponseDeferredChannelMessageWithSource | APIInteractionResponseDeferredMessageUpdate | APIInteractionResponseUpdateMessage): Promise<void>;
+}
+export interface ComponentInteraction extends ObjectToLower<Omit<APIMessageComponentInteraction, 'user' | 'member' | 'type' | 'data' | 'message' | 'channel' | 'app_permissions'>> {
+}
+export declare class ComponentInteraction<FromGuild extends boolean = boolean, Type extends APIMessageComponentInteraction = APIMessageComponentInteraction> extends Interaction<FromGuild, Type> {
+    data: ObjectToLower<APIMessageComponentInteraction['data']>;
+    channelId: string;
+    channel: AllChannels;
+    type: InteractionType.MessageComponent;
+    update(data: ComponentInteractionMessageUpdate): Promise<void>;
+    deferUpdate(): Promise<void>;
+    get customId(): string;
+    get componentType(): ComponentType.Button | ComponentType.StringSelect | ComponentType.UserSelect | ComponentType.RoleSelect | ComponentType.MentionableSelect | ComponentType.ChannelSelect;
+    isButton(): this is ButtonInteraction;
+    isChannelSelectMenu(): this is ChannelSelectMenuInteraction;
+    isRoleSelectMenu(): this is RoleSelectMenuInteraction;
+    isMentionableSelectMenu(): this is MentionableSelectMenuInteraction;
+    isUserSelectMenu(): this is UserSelectMenuInteraction;
+    isStringSelectMenu(): this is StringSelectMenuInteraction;
+}
+export declare class ButtonInteraction extends ComponentInteraction {
+    data: ObjectToLower<APIMessageButtonInteractionData>;
+}
+export declare class SelectMenuInteraction extends ComponentInteraction {
+    protected __reply?: __InternalReplyFunction | undefined;
+    data: ObjectToLower<APIMessageComponentSelectMenuInteraction['data']>;
+    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+    get values(): string[];
+}
+declare const StringSelectMenuInteraction_base: ToClass<Omit<SelectMenuInteraction, "data">, StringSelectMenuInteraction<string[]>>;
+export declare class StringSelectMenuInteraction<T extends any[] = string[]> extends StringSelectMenuInteraction_base {
+    data: OmitInsert<ObjectToLower<APIMessageStringSelectInteractionData>, 'values', {
+        values: T;
+    }>;
+    values: T;
+}
+export declare class ChannelSelectMenuInteraction extends SelectMenuInteraction {
+    protected __reply?: __InternalReplyFunction | undefined;
+    channels: AllChannels[];
+    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+}
+export declare class MentionableSelectMenuInteraction extends SelectMenuInteraction {
+    protected __reply?: __InternalReplyFunction | undefined;
+    roles: GuildRole[];
+    members: InteractionGuildMember[];
+    users: User[];
+    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+}
+export declare class RoleSelectMenuInteraction extends SelectMenuInteraction {
+    protected __reply?: __InternalReplyFunction | undefined;
+    roles: GuildRole[];
+    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+}
+export declare class UserSelectMenuInteraction extends SelectMenuInteraction {
+    protected __reply?: __InternalReplyFunction | undefined;
+    members: InteractionGuildMember[];
+    users: User[];
+    constructor(client: BaseClient, interaction: APIMessageComponentSelectMenuInteraction, __reply?: __InternalReplyFunction | undefined);
+}
+export declare class ChatInputCommandInteraction<FromGuild extends boolean = boolean> extends ApplicationCommandInteraction<FromGuild, APIChatInputApplicationCommandInteraction> {
+    data: ObjectToLower<APIChatInputApplicationCommandInteractionData>;
+}
+export declare class UserCommandInteraction<FromGuild extends boolean = boolean> extends ApplicationCommandInteraction<FromGuild, APIUserApplicationCommandInteraction> {
+    type: ApplicationCommandType.User;
+    data: ObjectToLower<APIUserApplicationCommandInteractionData>;
+}
+export declare class MessageCommandInteraction<FromGuild extends boolean = boolean> extends ApplicationCommandInteraction<FromGuild, APIMessageApplicationCommandInteraction> {
+    type: ApplicationCommandType.Message;
+    data: ObjectToLower<APIMessageApplicationCommandInteractionData>;
+}
+export interface ModalSubmitInteraction<FromGuild extends boolean = boolean> extends Omit<Interaction<FromGuild, APIModalSubmitInteraction>, 'modal'> {
+}
+export declare class ModalSubmitInteraction<FromGuild extends boolean = boolean> extends BaseInteraction<FromGuild> {
+    data: ObjectToLower<APIModalSubmission>;
+    get customId(): string;
+    get components(): {
+        components: {
+            type: ComponentType;
+            customId: string;
+            value: string;
+        }[];
+        type: ComponentType.ActionRow;
+    }[];
+    getInputValue(customId: string, required: true): string;
+    getInputValue(customId: string, required?: false): string | undefined;
+}
+export {};

package/lib/structures/Interaction.js

@@ -0,0 +1,409 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalSubmitInteraction = exports.MessageCommandInteraction = exports.UserCommandInteraction = exports.ChatInputCommandInteraction = exports.UserSelectMenuInteraction = exports.RoleSelectMenuInteraction = exports.MentionableSelectMenuInteraction = exports.ChannelSelectMenuInteraction = exports.StringSelectMenuInteraction = exports.SelectMenuInteraction = exports.ButtonInteraction = exports.ComponentInteraction = exports.ApplicationCommandInteraction = exports.Interaction = exports.AutocompleteInteraction = exports.BaseInteraction = void 0;
+const ts_mixer_1 = require("ts-mixer");
+const builders_1 = require("../builders");
+const commands_1 = require("../commands");
+const common_1 = require("../common");
+const listener_1 = require("../components/listener");
+const _1 = require("./");
+const GuildRole_1 = require("./GuildRole");
+const Message_1 = require("./Message");
+const User_1 = require("./User");
+const channels_1 = __importDefault(require("./channels"));
+const DiscordBase_1 = require("./extra/DiscordBase");
+const Permissions_1 = require("./extra/Permissions");
+class BaseInteraction extends DiscordBase_1.DiscordBase {
+    client;
+    __reply;
+    user;
+    member;
+    channel;
+    message;
+    replied;
+    appPermissions;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.client = client;
+        this.__reply = __reply;
+        if (interaction.member) {
+            this.member = new _1.InteractionGuildMember(client, interaction.member, interaction.member.user, interaction.guild_id);
+        }
+        if (interaction.message) {
+            this.message = new Message_1.Message(client, interaction.message);
+        }
+        if (interaction.app_permissions) {
+            this.appPermissions = new Permissions_1.PermissionsBitField(Number(interaction.app_permissions));
+        }
+        if (interaction.channel) {
+            this.channel = (0, channels_1.default)(interaction.channel, client);
+        }
+        this.user = this.member?.user ?? new User_1.User(client, interaction.user);
+    }
+    static transformBodyRequest(body) {
+        switch (body.type) {
+            case common_1.InteractionResponseType.ApplicationCommandAutocompleteResult:
+            case common_1.InteractionResponseType.DeferredMessageUpdate:
+            case common_1.InteractionResponseType.DeferredChannelMessageWithSource:
+                return body;
+            case common_1.InteractionResponseType.ChannelMessageWithSource:
+            case common_1.InteractionResponseType.UpdateMessage:
+                return {
+                    type: body.type,
+                    data: {
+                        ...(body.data ?? {}),
+                        // @ts-expect-error
+                        components: (body.data?.components instanceof listener_1.ComponentsListener
+                            ? body.data.components.components
+                            : body.data.components)?.map(x => (x instanceof builders_1.ActionRow ? x.toJSON() : x)) ?? undefined,
+                        embeds: body.data?.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
+                        attachments: body.data?.attachments?.map((x, i) => ({ id: i, ...(0, builders_1.resolveAttachment)(x) })) ?? undefined,
+                    },
+                };
+            case common_1.InteractionResponseType.Modal:
+                return {
+                    type: body.type,
+                    data: body.data instanceof builders_1.Modal
+                        ? body.data.toJSON()
+                        : {
+                            ...body.data,
+                            components: body.data?.components
+                                ? body.data.components.map(x => x instanceof builders_1.ActionRow
+                                    ? x.toJSON()
+                                    : x)
+                                : [],
+                        },
+                };
+            default:
+                return body;
+        }
+    }
+    static transformBody(body) {
+        return {
+            ...body,
+            components: (body?.components instanceof listener_1.ComponentsListener ? body.components.components : body.components)?.map(x => x instanceof builders_1.ActionRow ? x.toJSON() : x) ?? undefined,
+            embeds: body?.embeds?.map(x => (x instanceof builders_1.Embed ? x.toJSON() : x)) ?? undefined,
+            // attachments: body.attachments?.map((x, i) => ({ id: i, ...resolveAttachment(x) })) ?? undefined,
+        };
+    }
+    matchReplied(data, type, filesParsed) {
+        this.replied = (this.__reply ?? this.api.interactions(this.id)(this.token).callback.post)({
+            // @ts-expect-error
+            body: BaseInteraction.transformBodyRequest({ data, type }),
+            files: filesParsed,
+        }).then(() => (this.replied = true));
+    }
+    async reply(body) {
+        if (this.replied) {
+            throw new Error('Interaction already replied');
+        }
+        // @ts-expect-error
+        if (body.data?.files) {
+            // @ts-expect-error
+            const { files, ...rest } = body.data;
+            this.matchReplied(rest, body.type, await (0, builders_1.resolveFiles)(files));
+            // @ts-expect-error
+        }
+        else
+            this.matchReplied(body.data, body.type);
+        this.client.components.onRequestInteraction(body.type === common_1.InteractionResponseType.Modal
+            ? this.user.id
+            : body.type === common_1.InteractionResponseType.UpdateMessage
+                ? this.message.interaction.id
+                : this.id, body);
+        await this.replied;
+    }
+    deferReply(flags) {
+        return this.reply({
+            type: common_1.InteractionResponseType.DeferredChannelMessageWithSource,
+            data: {
+                flags,
+            },
+        });
+    }
+    static from(client, gateway, __reply) {
+        switch (gateway.type) {
+            case common_1.InteractionType.ApplicationCommandAutocomplete:
+                return new AutocompleteInteraction(client, gateway, __reply);
+            // biome-ignore lint/suspicious/noFallthroughSwitchClause: bad interaction  between biome and ts-server
+            case common_1.InteractionType.ApplicationCommand:
+                switch (gateway.data.type) {
+                    case common_1.ApplicationCommandType.ChatInput:
+                        return new ChatInputCommandInteraction(client, gateway, __reply);
+                    case common_1.ApplicationCommandType.User:
+                        return new UserCommandInteraction(client, gateway, __reply);
+                    case common_1.ApplicationCommandType.Message:
+                        return new MessageCommandInteraction(client, gateway, __reply);
+                }
+            // biome-ignore lint/suspicious/noFallthroughSwitchClause: bad interaction  between biome and ts-server
+            case common_1.InteractionType.MessageComponent:
+                switch (gateway.data.component_type) {
+                    case common_1.ComponentType.Button:
+                        return new ButtonInteraction(client, gateway, __reply);
+                    case common_1.ComponentType.ChannelSelect:
+                        return new ChannelSelectMenuInteraction(client, gateway, __reply);
+                    case common_1.ComponentType.RoleSelect:
+                        return new RoleSelectMenuInteraction(client, gateway, __reply);
+                    case common_1.ComponentType.MentionableSelect:
+                        return new MentionableSelectMenuInteraction(client, gateway, __reply);
+                    case common_1.ComponentType.UserSelect:
+                        return new UserSelectMenuInteraction(client, gateway, __reply);
+                    case common_1.ComponentType.StringSelect:
+                        return new StringSelectMenuInteraction(client, gateway, __reply);
+                }
+            case common_1.InteractionType.ModalSubmit:
+                return new ModalSubmitInteraction(client, gateway);
+            default:
+                return new BaseInteraction(client, gateway);
+        }
+    }
+}
+exports.BaseInteraction = BaseInteraction;
+class AutocompleteInteraction extends BaseInteraction {
+    __reply;
+    options;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+        this.options = new commands_1.OptionResolver(client, interaction.data.options, undefined, interaction.guild_id, interaction.data.resolved);
+    }
+    getInput() {
+        return this.options.getAutocompleteValue() ?? '';
+    }
+    respond(choices) {
+        return super.reply({ data: { choices }, type: common_1.InteractionResponseType.ApplicationCommandAutocompleteResult });
+    }
+    /** @intenal */
+    async reply(..._args) {
+        throw new Error('Cannot use reply in this interaction');
+    }
+}
+exports.AutocompleteInteraction = AutocompleteInteraction;
+class Interaction extends BaseInteraction {
+    fetchMessage(messageId) {
+        return this.client.webhooks.messages.fetch(this.applicationId, this.token, messageId);
+    }
+    fetchResponse() {
+        return this.fetchMessage('@original');
+    }
+    async write(body, fetchReply) {
+        (await this.reply({
+            type: common_1.InteractionResponseType.ChannelMessageWithSource,
+            data: body,
+        }));
+        if (fetchReply)
+            return this.fetchResponse();
+        return undefined;
+    }
+    modal(body) {
+        return this.reply({
+            type: common_1.InteractionResponseType.Modal,
+            data: body,
+        });
+    }
+    async editOrReply(body, fetchReply) {
+        if (await this.replied) {
+            const { content, embeds, allowed_mentions, components, files, attachments } = body;
+            return this.editResponse({ content, embeds, allowed_mentions, components, files, attachments });
+        }
+        return this.write(body, fetchReply);
+    }
+    async editMessage(messageId, body) {
+        const { files, ...data } = body;
+        const apiMessage = await this.api
+            .webhooks(this.applicationId)(this.token)
+            .messages(messageId)
+            .patch({
+            body: BaseInteraction.transformBody(data),
+            files: files ? await (0, builders_1.resolveFiles)(files) : undefined,
+        });
+        this.client.components.onRequestInteractionUpdate(body, apiMessage);
+        return new Message_1.Message(this.client, apiMessage);
+    }
+    editResponse(body) {
+        return this.editMessage('@original', body);
+    }
+    deleteResponse() {
+        return this.deleteMessage('@original');
+    }
+    deleteMessage(messageId) {
+        return this.api
+            .webhooks(this.applicationId)(this.token)
+            .messages(messageId)
+            .delete()
+            .then(() => this.client.components.onMessageDelete(messageId === '@original' ? this.id : messageId));
+    }
+    async createResponse({ files, ...body }) {
+        files ??= files ? await (0, builders_1.resolveFiles)(files) : undefined;
+        const apiMessage = await this.api
+            .webhooks(this.applicationId)(this.token)
+            .post({
+            body: BaseInteraction.transformBody(body),
+            files: files,
+        });
+        this.client.components.onRequestMessage(body, apiMessage);
+        return new Message_1.Message(this.client, apiMessage);
+    }
+}
+exports.Interaction = Interaction;
+class ApplicationCommandInteraction extends Interaction {
+    type = common_1.ApplicationCommandType.ChatInput;
+    respond(data) {
+        return this.reply(data);
+    }
+}
+exports.ApplicationCommandInteraction = ApplicationCommandInteraction;
+class ComponentInteraction extends Interaction {
+    update(data) {
+        return this.reply({
+            type: common_1.InteractionResponseType.UpdateMessage,
+            data,
+        });
+    }
+    deferUpdate() {
+        return this.reply({
+            type: common_1.InteractionResponseType.DeferredMessageUpdate,
+        });
+    }
+    get customId() {
+        return this.data.customId;
+    }
+    get componentType() {
+        return this.data.componentType;
+    }
+    isButton() {
+        return this.data.componentType === common_1.ComponentType.Button;
+    }
+    isChannelSelectMenu() {
+        return this.componentType === common_1.ComponentType.ChannelSelect;
+    }
+    isRoleSelectMenu() {
+        return this.componentType === common_1.ComponentType.RoleSelect;
+    }
+    isMentionableSelectMenu() {
+        return this.componentType === common_1.ComponentType.MentionableSelect;
+    }
+    isUserSelectMenu() {
+        return this.componentType === common_1.ComponentType.UserSelect;
+    }
+    isStringSelectMenu() {
+        return this.componentType === common_1.ComponentType.StringSelect;
+    }
+}
+exports.ComponentInteraction = ComponentInteraction;
+class ButtonInteraction extends ComponentInteraction {
+}
+exports.ButtonInteraction = ButtonInteraction;
+class SelectMenuInteraction extends ComponentInteraction {
+    __reply;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+    }
+    get values() {
+        return this.data.values;
+    }
+}
+exports.SelectMenuInteraction = SelectMenuInteraction;
+class StringSelectMenuInteraction extends SelectMenuInteraction {
+}
+exports.StringSelectMenuInteraction = StringSelectMenuInteraction;
+class ChannelSelectMenuInteraction extends SelectMenuInteraction {
+    __reply;
+    channels;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+        const resolved = interaction.data.resolved;
+        this.channels = this.values.map(x => (0, channels_1.default)(resolved.channels[x], this.client));
+    }
+}
+exports.ChannelSelectMenuInteraction = ChannelSelectMenuInteraction;
+class MentionableSelectMenuInteraction extends SelectMenuInteraction {
+    __reply;
+    roles;
+    members;
+    users;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+        const resolved = interaction.data.resolved;
+        this.roles = resolved.roles
+            ? this.values.map(x => new GuildRole_1.GuildRole(this.client, resolved.roles[x], this.guildId))
+            : [];
+        this.members = resolved.members
+            ? this.values.map(x => new _1.InteractionGuildMember(this.client, resolved.members[x], this.users.find(u => u.id === x), this.guildId))
+            : [];
+        this.users = resolved.users ? this.values.map(x => new User_1.User(this.client, resolved.users[x])) : [];
+    }
+}
+exports.MentionableSelectMenuInteraction = MentionableSelectMenuInteraction;
+class RoleSelectMenuInteraction extends SelectMenuInteraction {
+    __reply;
+    roles;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+        const resolved = interaction.data.resolved;
+        this.roles = this.values.map(x => new GuildRole_1.GuildRole(this.client, resolved.roles[x], this.guildId));
+    }
+}
+exports.RoleSelectMenuInteraction = RoleSelectMenuInteraction;
+class UserSelectMenuInteraction extends SelectMenuInteraction {
+    __reply;
+    members;
+    users;
+    constructor(client, interaction, __reply) {
+        super(client, interaction);
+        this.__reply = __reply;
+        const resolved = interaction.data.resolved;
+        this.users = this.values.map(x => new User_1.User(this.client, resolved.users[x]));
+        this.members = resolved.members
+            ? this.values.map(x => new _1.InteractionGuildMember(this.client, resolved.members[x], this.users.find(u => u.id === x), this.guildId))
+            : [];
+    }
+}
+exports.UserSelectMenuInteraction = UserSelectMenuInteraction;
+class ChatInputCommandInteraction extends ApplicationCommandInteraction {
+}
+exports.ChatInputCommandInteraction = ChatInputCommandInteraction;
+class UserCommandInteraction extends ApplicationCommandInteraction {
+}
+exports.UserCommandInteraction = UserCommandInteraction;
+class MessageCommandInteraction extends ApplicationCommandInteraction {
+}
+exports.MessageCommandInteraction = MessageCommandInteraction;
+let ModalSubmitInteraction = class ModalSubmitInteraction extends BaseInteraction {
+    get customId() {
+        return this.data.customId;
+    }
+    get components() {
+        return this.data.components;
+    }
+    getInputValue(customId, required) {
+        let value;
+        for (const { components } of this.components) {
+            const get = components.find(x => x.customId === customId);
+            if (get) {
+                value = get.value;
+                break;
+            }
+        }
+        if (!value && required)
+            throw new Error(`${customId} component doesn't have a value`);
+        return value;
+    }
+};
+exports.ModalSubmitInteraction = ModalSubmitInteraction;
+exports.ModalSubmitInteraction = ModalSubmitInteraction = __decorate([
+    (0, ts_mixer_1.mix)(Interaction)
+], ModalSubmitInteraction);

package/lib/structures/Message.d.ts

@@ -0,0 +1,53 @@
+import type { BaseClient } from '../client/base';
+import type { APIChannelMention, APIMessage, GatewayMessageCreateDispatchData, ObjectToLower } from '../common';
+import type { EmojiResolvable } from '../common/types/resolvables';
+import type { MessageCreateBodyRequest, MessageUpdateBodyRequest } from '../common/types/write';
+import type { ActionRowMessageComponents } from '../components';
+import { MessageActionRowComponent } from '../components/ActionRow';
+import { GuildMember } from './GuildMember';
+import { User } from './User';
+import type { MessageWebhookMethodEditParams, MessageWebhookMethodWriteParams } from './Webhook';
+import { DiscordBase } from './extra/DiscordBase';
+export type MessageData = APIMessage | GatewayMessageCreateDispatchData;
+export interface BaseMessage extends DiscordBase, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
+}
+export declare class BaseMessage extends DiscordBase {
+    guildId: string | undefined;
+    timestamp?: number;
+    author: User;
+    member?: GuildMember;
+    components: MessageActionRowComponent<ActionRowMessageComponents>[];
+    mentions: {
+        roles: string[];
+        channels: APIChannelMention[];
+        users: (GuildMember | User)[];
+    };
+    constructor(client: BaseClient, data: MessageData);
+    get url(): string;
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api"> | undefined>;
+    channel(force?: boolean): Promise<import("./channels").AllChannels>;
+    react(emoji: EmojiResolvable): Promise<never>;
+    private patch;
+}
+export interface Message extends BaseMessage, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
+}
+export declare class Message extends BaseMessage {
+    constructor(client: BaseClient, data: MessageData);
+    fetch(): Promise<Message>;
+    reply(body: Omit<MessageCreateBodyRequest, 'message_reference'>): Promise<Message>;
+    edit(body: MessageUpdateBodyRequest): Promise<Message>;
+    write(body: MessageCreateBodyRequest): Promise<Message>;
+    delete(reason?: string): Promise<void>;
+    crosspost(reason?: string): Promise<Message>;
+}
+export type EditMessageWebhook = Omit<MessageWebhookMethodEditParams, 'messageId'>;
+export type WriteMessageWebhook = MessageWebhookMethodWriteParams;
+export declare class WebhookMessage extends BaseMessage {
+    readonly webhookId: string;
+    readonly webhookToken: string;
+    constructor(client: BaseClient, data: MessageData, webhookId: string, webhookToken: string);
+    fetch(): Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+    edit(body: EditMessageWebhook): Promise<WebhookMessage>;
+    write(body: WriteMessageWebhook): Promise<WebhookMessage | null>;
+    delete(reason?: string): Promise<never>;
+}