editWebhookMessage,

getWebhookMessage,

} from "./api.js";

import type { Client } from "./client.js";

import { type ComponentData, type Modal } from "./components.js";

import { OptionsHandler } from "./interaction-options.js";

import {

InteractionResponseController,

import { extractModalFields, ModalFields } from "./modal-fields.js";

import { serializePayload, type MessagePayload } from "./payload.js";

import { assertDiscordInteractionPayload } from "./schemas.js";

import { channelFactory, Guild, Message, User, type DiscordChannel } from "./structures.js";

import {

channelFactory,

Guild,

Message,

User,

type DiscordChannel,

type StructureClient,

} from "./structures.js";

export { OptionsHandler } from "./interaction-options.js";

export { ModalFields } from "./modal-fields.js";

type InteractionClient = StructureClient & {

options: { clientId: string };

fetchChannel(id: string): Promise<DiscordChannel>;

};

type Modal = {

serialize: () => unknown;

};

type ComponentData = Record<string, unknown>;

export type RawInteraction = APIInteraction & {

token: string;

member?: { user?: APIUser; roles?: string[] };

return rawData as ModalSubmitRawInteraction;

}

function readInteractionUser(rawData: RawInteraction, client: Client): User | null {

function readInteractionUser(rawData: RawInteraction, client: InteractionClient): User | null {

const directUser = "user" in rawData ? rawData.user : undefined;

if (directUser && typeof directUser === "object" && "id" in directUser) {

return new User(client, directUser);

private readonly response = new InteractionResponseController();

constructor(

public client: Client,

public client: InteractionClient,

public rawData: RawInteraction,

) {

this.id = rawData.id;

export class CommandInteraction extends BaseInteraction {

readonly options: OptionsHandler;

constructor(client: Client, rawData: APIApplicationCommandInteraction & RawInteraction) {

constructor(

client: InteractionClient,

rawData: APIApplicationCommandInteraction & RawInteraction,

) {

super(client, rawData);

this.options = new OptionsHandler(

rawData.data.options,

export class BaseComponentInteraction extends BaseInteraction {

readonly values: string[];

constructor(client: Client, rawData: APIMessageComponentInteraction & RawInteraction) {

constructor(client: InteractionClient, rawData: APIMessageComponentInteraction & RawInteraction) {

super(client, rawData);

this.message =

rawData.message && typeof rawData.message === "object"

export class ModalInteraction extends BaseInteraction {

readonly fields: ModalFields;

constructor(client: Client, rawData: APIModalSubmitInteraction & RawInteraction) {

constructor(client: InteractionClient, rawData: APIModalSubmitInteraction & RawInteraction) {

super(client, rawData);

this.fields = new ModalFields(

extractModalFields(rawData.data.components ?? []),

}

}

export function createInteraction(client: Client, rawData: RawInteraction) {

export function createInteraction(client: InteractionClient, rawData: RawInteraction) {

assertDiscordInteractionPayload(rawData);

if (rawData.type === InteractionType.ApplicationCommandAutocomplete) {

return new AutocompleteInteraction(client, toCommandRawInteraction(rawData));