diff --git a/packages/discord.js/src/structures/CommandInteraction.js b/packages/discord.js/src/structures/CommandInteraction.js
index 0d435deeb446..d872c4d5956b 100644
--- a/packages/discord.js/src/structures/CommandInteraction.js
+++ b/packages/discord.js/src/structures/CommandInteraction.js
@@ -148,15 +148,15 @@ class CommandInteraction extends BaseInteraction {
   /* eslint-disable no-empty-function */
   deferReply() {}
   reply() {}
-  fetchReply() {}
-  editReply() {}
-  deleteReply() {}
+  fetchResponse() {}
+  editResponse() {}
+  deleteResponse() {}
   followUp() {}
   showModal() {}
   sendPremiumRequired() {}
   awaitModalSubmit() {}
 }
 
-InteractionResponses.applyToClass(CommandInteraction, ['deferUpdate', 'update']);
+InteractionResponses.applyToClass(CommandInteraction, ['deferMessageUpdate', 'updateMessage']);
 
 module.exports = CommandInteraction;
diff --git a/packages/discord.js/src/structures/MessageComponentInteraction.js b/packages/discord.js/src/structures/MessageComponentInteraction.js
index 2e6df11e5611..aa8e7badf0f5 100644
--- a/packages/discord.js/src/structures/MessageComponentInteraction.js
+++ b/packages/discord.js/src/structures/MessageComponentInteraction.js
@@ -92,12 +92,12 @@ class MessageComponentInteraction extends BaseInteraction {
   /* eslint-disable no-empty-function */
   deferReply() {}
   reply() {}
-  fetchReply() {}
-  editReply() {}
-  deleteReply() {}
+  fetchResponse() {}
+  editResponse() {}
+  deleteResponse() {}
   followUp() {}
-  deferUpdate() {}
-  update() {}
+  deferMessageUpdate() {}
+  updateMessage() {}
   showModal() {}
   sendPremiumRequired() {}
   awaitModalSubmit() {}
diff --git a/packages/discord.js/src/structures/MessagePayload.js b/packages/discord.js/src/structures/MessagePayload.js
index dad8ffedb026..ba358dd4250b 100644
--- a/packages/discord.js/src/structures/MessagePayload.js
+++ b/packages/discord.js/src/structures/MessagePayload.js
@@ -321,7 +321,7 @@ module.exports = MessagePayload;
 /**
  * A possible payload option.
  * @typedef {MessageCreateOptions|MessageEditOptions|WebhookMessageCreateOptions|WebhookMessageEditOptions|
- * InteractionReplyOptions|InteractionUpdateOptions} MessagePayloadOption
+ * InteractionReplyOptions|InteractionUpdateMessageOptions} MessagePayloadOption
  */
 
 /**
diff --git a/packages/discord.js/src/structures/ModalSubmitInteraction.js b/packages/discord.js/src/structures/ModalSubmitInteraction.js
index ba94190436da..73bff747f450 100644
--- a/packages/discord.js/src/structures/ModalSubmitInteraction.js
+++ b/packages/discord.js/src/structures/ModalSubmitInteraction.js
@@ -112,12 +112,12 @@ class ModalSubmitInteraction extends BaseInteraction {
   /* eslint-disable no-empty-function */
   deferReply() {}
   reply() {}
-  fetchReply() {}
-  editReply() {}
-  deleteReply() {}
+  fetchResponse() {}
+  editResponse() {}
+  deleteResponse() {}
   followUp() {}
-  deferUpdate() {}
-  update() {}
+  deferMessageUpdate() {}
+  updateMessage() {}
   sendPremiumRequired() {}
 }
 
diff --git a/packages/discord.js/src/structures/interfaces/InteractionResponses.js b/packages/discord.js/src/structures/interfaces/InteractionResponses.js
index 9f711b517b49..386119dd09ff 100644
--- a/packages/discord.js/src/structures/interfaces/InteractionResponses.js
+++ b/packages/discord.js/src/structures/interfaces/InteractionResponses.js
@@ -25,13 +25,13 @@ class InteractionResponses {
    * Options for deferring the reply to an {@link BaseInteraction}.
    * @typedef {Object} InteractionDeferReplyOptions
    * @property {boolean} [ephemeral] Whether the reply should be ephemeral
-   * @property {boolean} [fetchReply] Whether to fetch the reply
+   * @property {boolean} [fetchResponse] Whether to fetch the reply
    */
 
   /**
    * Options for deferring and updating the reply to a {@link MessageComponentInteraction}.
-   * @typedef {Object} InteractionDeferUpdateOptions
-   * @property {boolean} [fetchReply] Whether to fetch the reply
+   * @typedef {Object} InteractionDeferMessageUpdateOptions
+   * @property {boolean} [fetchResponse] Whether to fetch the reply
    */
 
   /**
@@ -39,7 +39,7 @@ class InteractionResponses {
    * @typedef {BaseMessageOptions} InteractionReplyOptions
    * @property {boolean} [tts=false] Whether the message should be spoken aloud
    * @property {boolean} [ephemeral] Whether the reply should be ephemeral
-   * @property {boolean} [fetchReply] Whether to fetch the reply
+   * @property {boolean} [fetchResponse] Whether to fetch the reply
    * @property {MessageFlags} [flags] Which flags to set for the message.
    * <info>Only `MessageFlags.Ephemeral`, `MessageFlags.SuppressEmbeds`, and `MessageFlags.SuppressNotifications`
    * can be set.</info>
@@ -47,8 +47,8 @@ class InteractionResponses {
 
   /**
    * Options for updating the message received from a {@link MessageComponentInteraction}.
-   * @typedef {MessageEditOptions} InteractionUpdateOptions
-   * @property {boolean} [fetchReply] Whether to fetch the reply
+   * @typedef {MessageEditOptions} InteractionUpdateMessageOptions
+   * @property {boolean} [fetchResponse] Whether to fetch the reply
    */
 
   /**
@@ -80,17 +80,17 @@ class InteractionResponses {
     });
     this.deferred = true;
 
-    return options.fetchReply ? this.fetchReply() : new InteractionResponse(this);
+    return options.fetchResponse ? this.fetchResponse() : new InteractionResponse(this);
   }
 
   /**
    * Creates a reply to this interaction.
-   * <info>Use the `fetchReply` option to get the bot's reply message.</info>
+   * <info>Use the `fetchResponse` option to get the bot's reply message.</info>
    * @param {string|MessagePayload|InteractionReplyOptions} options The options for the reply
    * @returns {Promise<Message|InteractionResponse>}
    * @example
    * // Reply to the interaction and fetch the response
-   * interaction.reply({ content: 'Pong!', fetchReply: true })
+   * interaction.reply({ content: 'Pong!', fetchResponse: true })
    *   .then((message) => console.log(`Reply sent with content ${message.content}`))
    *   .catch(console.error);
    * @example
@@ -122,7 +122,7 @@ class InteractionResponses {
     });
     this.replied = true;
 
-    return options.fetchReply ? this.fetchReply() : new InteractionResponse(this);
+    return options.fetchResponse ? this.fetchResponse() : new InteractionResponse(this);
   }
 
   /**
@@ -132,32 +132,32 @@ class InteractionResponses {
    * @returns {Promise<Message>}
    * @example
    * // Fetch the initial reply to this interaction
-   * interaction.fetchReply()
+   * interaction.fetchResponse()
    *   .then(reply => console.log(`Replied with ${reply.content}`))
    *   .catch(console.error);
    */
-  fetchReply(message = '@original') {
+  fetchResponse(message = '@original') {
     return this.webhook.fetchMessage(message);
   }
 
   /**
-   * Options that can be passed into {@link InteractionResponses#editReply}.
-   * @typedef {WebhookMessageEditOptions} InteractionEditReplyOptions
+   * Options that can be passed into {@link InteractionResponses#editResponse}.
+   * @typedef {WebhookMessageEditOptions} InteractionEditResponseOptions
    * @property {MessageResolvable|'@original'} [message='@original'] The response to edit
    */
 
   /**
    * Edits a reply to this interaction.
    * @see Webhook#editMessage
-   * @param {string|MessagePayload|InteractionEditReplyOptions} options The new options for the message
+   * @param {string|MessagePayload|InteractionEditResponseOptions} options The new options for the message
    * @returns {Promise<Message>}
    * @example
    * // Edit the initial reply to this interaction
-   * interaction.editReply('New content')
+   * interaction.editResponse('New content')
    *   .then(console.log)
    *   .catch(console.error);
    */
-  async editReply(options) {
+  async editResponse(options) {
     if (!this.deferred && !this.replied) throw new DiscordjsError(ErrorCodes.InteractionNotReplied);
     const msg = await this.webhook.editMessage(options.message ?? '@original', options);
     this.replied = true;
@@ -171,11 +171,11 @@ class InteractionResponses {
    * @returns {Promise<void>}
    * @example
    * // Delete the initial reply to this interaction
-   * interaction.deleteReply()
+   * interaction.deleteResponse()
    *   .then(console.log)
    *   .catch(console.error);
    */
-  async deleteReply(message = '@original') {
+  async deleteResponse(message = '@original') {
     await this.webhook.deleteMessage(message);
   }
 
@@ -191,15 +191,15 @@ class InteractionResponses {
 
   /**
    * Defers an update to the message to which the component was attached.
-   * @param {InteractionDeferUpdateOptions} [options] Options for deferring the update to this interaction
+   * @param {InteractionDeferMessageUpdateOptions} [options] Options for deferring the update to this interaction
    * @returns {Promise<Message|InteractionResponse>}
    * @example
    * // Defer updating and reset the component's loading state
-   * interaction.deferUpdate()
+   * interaction.deferMessageUpdate()
    *   .then(console.log)
    *   .catch(console.error);
    */
-  async deferUpdate(options = {}) {
+  async deferMessageUpdate(options = {}) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
     await this.client.rest.post(Routes.interactionCallback(this.id, this.token), {
       body: {
@@ -209,23 +209,23 @@ class InteractionResponses {
     });
     this.deferred = true;
 
-    return options.fetchReply ? this.fetchReply() : new InteractionResponse(this, this.message?.interaction?.id);
+    return options.fetchResponse ? this.fetchResponse() : new InteractionResponse(this, this.message?.interaction?.id);
   }
 
   /**
    * Updates the original message of the component on which the interaction was received on.
-   * @param {string|MessagePayload|InteractionUpdateOptions} options The options for the updated message
+   * @param {string|MessagePayload|InteractionUpdateMessageOptions} options The options for the updated message
    * @returns {Promise<Message|void>}
    * @example
    * // Remove the components from the message
-   * interaction.update({
+   * interaction.updateMessage({
    *   content: "A component interaction was received",
    *   components: []
    * })
    *   .then(console.log)
    *   .catch(console.error);
    */
-  async update(options) {
+  async updateMessage(options) {
     if (this.deferred || this.replied) throw new DiscordjsError(ErrorCodes.InteractionAlreadyReplied);
 
     let messagePayload;
@@ -244,7 +244,7 @@ class InteractionResponses {
     });
     this.replied = true;
 
-    return options.fetchReply ? this.fetchReply() : new InteractionResponse(this, this.message.interaction?.id);
+    return options.fetchResponse ? this.fetchResponse() : new InteractionResponse(this, this.message.interaction?.id);
   }
 
   /**
@@ -317,12 +317,12 @@ class InteractionResponses {
     const props = [
       'deferReply',
       'reply',
-      'fetchReply',
-      'editReply',
-      'deleteReply',
+      'fetchResponse',
+      'editResponse',
+      'deleteResponse',
       'followUp',
-      'deferUpdate',
-      'update',
+      'deferMessageUpdate',
+      'updateMessage',
       'showModal',
       'sendPremiumRequired',
       'awaitModalSubmit',
diff --git a/packages/discord.js/typings/index.d.ts b/packages/discord.js/typings/index.d.ts
index a7b00f808e01..3f9a45db2f48 100644
--- a/packages/discord.js/typings/index.d.ts
+++ b/packages/discord.js/typings/index.d.ts
@@ -572,16 +572,16 @@ export abstract class CommandInteraction<Cached extends CacheType = CacheType> e
   public inCachedGuild(): this is CommandInteraction<'cached'>;
   public inRawGuild(): this is CommandInteraction<'raw'>;
   public deferReply(
-    options: InteractionDeferReplyOptions & { fetchReply: true },
+    options: InteractionDeferReplyOptions & { fetchResponse: true },
   ): Promise<Message<BooleanCache<Cached>>>;
   public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
-  public editReply(
-    options: string | MessagePayload | InteractionEditReplyOptions,
+  public deleteResponse(message?: MessageResolvable | '@original'): Promise<void>;
+  public editResponse(
+    options: string | MessagePayload | InteractionEditResponseOptions,
   ): Promise<Message<BooleanCache<Cached>>>;
-  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public fetchResponse(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
   public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
-  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(options: InteractionReplyOptions & { fetchResponse: true }): Promise<Message<BooleanCache<Cached>>>;
   public reply(
     options: string | MessagePayload | InteractionReplyOptions,
   ): Promise<InteractionResponse<BooleanCache<Cached>>>;
@@ -2276,26 +2276,30 @@ export class MessageComponentInteraction<Cached extends CacheType = CacheType> e
   public inCachedGuild(): this is MessageComponentInteraction<'cached'>;
   public inRawGuild(): this is MessageComponentInteraction<'raw'>;
   public deferReply(
-    options: InteractionDeferReplyOptions & { fetchReply: true },
+    options: InteractionDeferReplyOptions & { fetchResponse: true },
   ): Promise<Message<BooleanCache<Cached>>>;
   public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public deferUpdate(
-    options: InteractionDeferUpdateOptions & { fetchReply: true },
+  public deferMessageUpdate(
+    options: InteractionDeferMessageUpdateOptions & { fetchResponse: true },
   ): Promise<Message<BooleanCache<Cached>>>;
-  public deferUpdate(options?: InteractionDeferUpdateOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
-  public editReply(
-    options: string | MessagePayload | InteractionEditReplyOptions,
+  public deferMessageUpdate(
+    options?: InteractionDeferMessageUpdateOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deleteResponse(message?: MessageResolvable | '@original'): Promise<void>;
+  public editResponse(
+    options: string | MessagePayload | InteractionEditResponseOptions,
   ): Promise<Message<BooleanCache<Cached>>>;
-  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public fetchResponse(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
   public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
-  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(options: InteractionReplyOptions & { fetchResponse: true }): Promise<Message<BooleanCache<Cached>>>;
   public reply(
     options: string | MessagePayload | InteractionReplyOptions,
   ): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public update(options: InteractionUpdateOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
-  public update(
-    options: string | MessagePayload | InteractionUpdateOptions,
+  public updateMessage(
+    options: InteractionUpdateMessageOptions & { fetchResponse: true },
+  ): Promise<Message<BooleanCache<Cached>>>;
+  public updateMessage(
+    options: string | MessagePayload | InteractionUpdateMessageOptions,
   ): Promise<InteractionResponse<BooleanCache<Cached>>>;
   public showModal(
     modal:
@@ -2382,7 +2386,7 @@ export type MessagePayloadOption =
   | WebhookMessageCreateOptions
   | WebhookMessageEditOptions
   | InteractionReplyOptions
-  | InteractionUpdateOptions;
+  | InteractionUpdateMessageOptions;
 
 export class MessagePayload {
   public constructor(target: MessageTarget, options: MessagePayloadOption);
@@ -2465,9 +2469,9 @@ export interface ModalMessageModalSubmitInteraction<Cached extends CacheType = C
   extends ModalSubmitInteraction<Cached> {
   message: Message<BooleanCache<Cached>>;
   channelId: Snowflake;
-  update(options: InteractionUpdateOptions & { fetchReply: true }): Promise<Message>;
-  update(
-    options: string | MessagePayload | InteractionUpdateOptions,
+  updateMessage(options: InteractionUpdateMessageOptions & { fetchResponse: true }): Promise<Message>;
+  updateMessage(
+    options: string | MessagePayload | InteractionUpdateMessageOptions,
   ): Promise<InteractionResponse<BooleanCache<Cached>>>;
   inGuild(): this is ModalMessageModalSubmitInteraction<'raw' | 'cached'>;
   inCachedGuild(): this is ModalMessageModalSubmitInteraction<'cached'>;
@@ -2485,24 +2489,26 @@ export class ModalSubmitInteraction<Cached extends CacheType = CacheType> extend
   public message: Message<BooleanCache<Cached>> | null;
   public replied: boolean;
   public readonly webhook: InteractionWebhook;
-  public reply(options: InteractionReplyOptions & { fetchReply: true }): Promise<Message<BooleanCache<Cached>>>;
+  public reply(options: InteractionReplyOptions & { fetchResponse: true }): Promise<Message<BooleanCache<Cached>>>;
   public reply(
     options: string | MessagePayload | InteractionReplyOptions,
   ): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public deleteReply(message?: MessageResolvable | '@original'): Promise<void>;
-  public editReply(
-    options: string | MessagePayload | InteractionEditReplyOptions,
+  public deleteResponse(message?: MessageResolvable | '@original'): Promise<void>;
+  public editResponse(
+    options: string | MessagePayload | InteractionEditResponseOptions,
   ): Promise<Message<BooleanCache<Cached>>>;
   public deferReply(
-    options: InteractionDeferReplyOptions & { fetchReply: true },
+    options: InteractionDeferReplyOptions & { fetchResponse: true },
   ): Promise<Message<BooleanCache<Cached>>>;
   public deferReply(options?: InteractionDeferReplyOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
-  public fetchReply(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
+  public fetchResponse(message?: Snowflake | '@original'): Promise<Message<BooleanCache<Cached>>>;
   public followUp(options: string | MessagePayload | InteractionReplyOptions): Promise<Message<BooleanCache<Cached>>>;
-  public deferUpdate(
-    options: InteractionDeferUpdateOptions & { fetchReply: true },
+  public deferMessageUpdate(
+    options: InteractionDeferMessageUpdateOptions & { fetchResponse: true },
   ): Promise<Message<BooleanCache<Cached>>>;
-  public deferUpdate(options?: InteractionDeferUpdateOptions): Promise<InteractionResponse<BooleanCache<Cached>>>;
+  public deferMessageUpdate(
+    options?: InteractionDeferMessageUpdateOptions,
+  ): Promise<InteractionResponse<BooleanCache<Cached>>>;
   /** @deprecated Sending a premium-style button is the new Discord behaviour. */
   public sendPremiumRequired(): Promise<void>;
   public inGuild(): this is ModalSubmitInteraction<'raw' | 'cached'>;
@@ -6230,23 +6236,23 @@ export interface InteractionCollectorOptions<
 
 export interface InteractionDeferReplyOptions {
   ephemeral?: boolean;
-  fetchReply?: boolean;
+  fetchResponse?: boolean;
 }
 
-export interface InteractionDeferUpdateOptions extends Omit<InteractionDeferReplyOptions, 'ephemeral'> {}
+export interface InteractionDeferMessageUpdateOptions extends Omit<InteractionDeferReplyOptions, 'ephemeral'> {}
 
 export interface InteractionReplyOptions extends BaseMessageOptions {
   tts?: boolean;
   ephemeral?: boolean;
-  fetchReply?: boolean;
+  fetchResponse?: boolean;
   flags?: BitFieldResolvable<
     Extract<MessageFlagsString, 'Ephemeral' | 'SuppressEmbeds' | 'SuppressNotifications'>,
     MessageFlags.Ephemeral | MessageFlags.SuppressEmbeds | MessageFlags.SuppressNotifications
   >;
 }
 
-export interface InteractionUpdateOptions extends MessageEditOptions {
-  fetchReply?: boolean;
+export interface InteractionUpdateMessageOptions extends MessageEditOptions {
+  fetchResponse?: boolean;
 }
 
 export interface InviteGenerationOptions {
@@ -6908,7 +6914,7 @@ export interface WebhookMessageEditOptions extends Omit<MessageEditOptions, 'fla
   threadId?: Snowflake;
 }
 
-export interface InteractionEditReplyOptions extends WebhookMessageEditOptions {
+export interface InteractionEditResponseOptions extends WebhookMessageEditOptions {
   message?: MessageResolvable | '@original';
 }
 
diff --git a/packages/discord.js/typings/index.test-d.ts b/packages/discord.js/typings/index.test-d.ts
index 78093fc55654..53b02c8483f2 100644
--- a/packages/discord.js/typings/index.test-d.ts
+++ b/packages/discord.js/typings/index.test-d.ts
@@ -433,7 +433,7 @@ client.on('messageCreate', async message => {
     expectAssignable<Message<true>>(message);
     const component = await message.awaitMessageComponent({ componentType: ComponentType.Button });
     expectType<ButtonInteraction<'cached'>>(component);
-    expectType<Message<true>>(await component.reply({ fetchReply: true }));
+    expectType<Message<true>>(await component.reply({ fetchResponse: true }));
 
     const buttonCollector = message.createMessageComponentCollector({ componentType: ComponentType.Button });
     expectType<InteractionCollector<ButtonInteraction<'cached'>>>(buttonCollector);
@@ -1786,36 +1786,36 @@ client.on('interactionCreate', async interaction => {
       expectType<MessageActionRowComponent>(interaction.component);
       expectType<Message<true>>(interaction.message);
       expectType<Guild>(interaction.guild);
-      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<true>>>(interaction.fetchReply());
-      expectType<Promise<Message<true>>>(interaction.update({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<true>>>(interaction.fetchResponse());
+      expectType<Promise<Message<true>>>(interaction.updateMessage({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message<true>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inRawGuild()) {
       expectAssignable<MessageComponentInteraction>(interaction);
       expectType<APIButtonComponent | APISelectMenuComponent>(interaction.component);
       expectType<Message<false>>(interaction.message);
       expectType<null>(interaction.guild);
-      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<false>>>(interaction.fetchReply());
-      expectType<Promise<Message<false>>>(interaction.update({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<false>>>(interaction.fetchResponse());
+      expectType<Promise<Message<false>>>(interaction.updateMessage({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message<false>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inGuild()) {
       expectAssignable<MessageComponentInteraction>(interaction);
       expectType<MessageActionRowComponent | APIButtonComponent | APISelectMenuComponent>(interaction.component);
       expectType<Message>(interaction.message);
       expectType<Guild | null>(interaction.guild);
-      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message>>(interaction.fetchReply());
-      expectType<Promise<Message>>(interaction.update({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message>>(interaction.fetchResponse());
+      expectType<Promise<Message>>(interaction.updateMessage({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message>>(interaction.followUp({ content: 'a' }));
     }
   }
@@ -1849,26 +1849,26 @@ client.on('interactionCreate', async interaction => {
       expectAssignable<ContextMenuCommandInteraction>(interaction);
       expectAssignable<Guild>(interaction.guild);
       expectAssignable<CommandInteraction<'cached'>>(interaction);
-      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<true>>>(interaction.fetchReply());
+      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<true>>>(interaction.fetchResponse());
       expectType<Promise<Message<true>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inRawGuild()) {
       expectAssignable<ContextMenuCommandInteraction>(interaction);
       expectType<null>(interaction.guild);
-      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<false>>>(interaction.fetchReply());
+      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<false>>>(interaction.fetchResponse());
       expectType<Promise<Message<false>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inGuild()) {
       expectAssignable<ContextMenuCommandInteraction>(interaction);
       expectType<Guild | null>(interaction.guild);
-      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message>>(interaction.fetchReply());
+      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message>>(interaction.fetchResponse());
       expectType<Promise<Message>>(interaction.followUp({ content: 'a' }));
     }
   }
@@ -1920,19 +1920,19 @@ client.on('interactionCreate', async interaction => {
       expectType<ButtonComponent>(interaction.component);
       expectType<Message<true>>(interaction.message);
       expectType<Guild>(interaction.guild);
-      expectType<Promise<Message<true>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<true>>>(interaction.reply({ fetchResponse: true }));
     } else if (interaction.inRawGuild()) {
       expectAssignable<ButtonInteraction>(interaction);
       expectType<APIButtonComponent>(interaction.component);
       expectType<Message<false>>(interaction.message);
       expectType<null>(interaction.guild);
-      expectType<Promise<Message<false>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<false>>>(interaction.reply({ fetchResponse: true }));
     } else if (interaction.inGuild()) {
       expectAssignable<ButtonInteraction>(interaction);
       expectType<ButtonComponent | APIButtonComponent>(interaction.component);
       expectType<Message>(interaction.message);
       expectAssignable<Guild | null>(interaction.guild);
-      expectType<Promise<Message>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message>>(interaction.reply({ fetchResponse: true }));
     }
   }
 
@@ -1948,19 +1948,19 @@ client.on('interactionCreate', async interaction => {
       expectType<SelectMenuComponent>(interaction.component);
       expectType<Message<true>>(interaction.message);
       expectType<Guild>(interaction.guild);
-      expectType<Promise<Message<true>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<true>>>(interaction.reply({ fetchResponse: true }));
     } else if (interaction.inRawGuild()) {
       expectAssignable<StringSelectMenuInteraction>(interaction);
       expectType<APIStringSelectComponent>(interaction.component);
       expectType<Message<false>>(interaction.message);
       expectType<null>(interaction.guild);
-      expectType<Promise<Message<false>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<false>>>(interaction.reply({ fetchResponse: true }));
     } else if (interaction.inGuild()) {
       expectAssignable<StringSelectMenuInteraction>(interaction);
       expectType<SelectMenuComponent | APIStringSelectComponent>(interaction.component);
       expectType<Message>(interaction.message);
       expectType<Guild | null>(interaction.guild);
-      expectType<Promise<Message>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message>>(interaction.reply({ fetchResponse: true }));
     }
   }
 
@@ -1972,13 +1972,13 @@ client.on('interactionCreate', async interaction => {
     if (interaction.inRawGuild()) {
       expectNotAssignable<Interaction<'cached'>>(interaction);
       expectAssignable<ChatInputCommandInteraction>(interaction);
-      expectType<Promise<Message<false>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<false>>>(interaction.reply({ fetchResponse: true }));
       expectType<APIInteractionDataResolvedGuildMember | null>(interaction.options.getMember('test'));
 
       expectType<APIInteractionDataResolvedChannel>(interaction.options.getChannel('test', true));
       expectType<APIRole>(interaction.options.getRole('test', true));
     } else if (interaction.inCachedGuild()) {
-      const msg = await interaction.reply({ fetchReply: true });
+      const msg = await interaction.reply({ fetchResponse: true });
       const btn = await msg.awaitMessageComponent({ componentType: ComponentType.Button });
 
       expectType<Message<true>>(msg);
@@ -1986,7 +1986,7 @@ client.on('interactionCreate', async interaction => {
 
       expectType<GuildMember | null>(interaction.options.getMember('test'));
       expectAssignable<ChatInputCommandInteraction>(interaction);
-      expectType<Promise<Message<true>>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message<true>>>(interaction.reply({ fetchResponse: true }));
 
       expectType<GuildBasedChannel>(interaction.options.getChannel('test', true));
       expectType<Role>(interaction.options.getRole('test', true));
@@ -2012,7 +2012,7 @@ client.on('interactionCreate', async interaction => {
       // @ts-expect-error
       consumeCachedCommand(interaction);
       expectType<ChatInputCommandInteraction>(interaction);
-      expectType<Promise<Message>>(interaction.reply({ fetchReply: true }));
+      expectType<Promise<Message>>(interaction.reply({ fetchResponse: true }));
       expectType<APIInteractionDataResolvedGuildMember | GuildMember | null>(interaction.options.getMember('test'));
 
       expectType<GuildBasedChannel | APIInteractionDataResolvedChannel>(interaction.options.getChannel('test', true));
@@ -2066,29 +2066,29 @@ client.on('interactionCreate', async interaction => {
     if (interaction.inCachedGuild()) {
       expectAssignable<ModalSubmitInteraction>(interaction);
       expectType<Guild>(interaction.guild);
-      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<true>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<true>>>(interaction.fetchReply());
-      expectType<Promise<Message<true>>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message<true>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<true>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<true>>>(interaction.fetchResponse());
+      expectType<Promise<Message<true>>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message<true>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inRawGuild()) {
       expectAssignable<ModalSubmitInteraction>(interaction);
       expectType<null>(interaction.guild);
-      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message<false>>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message<false>>>(interaction.fetchReply());
-      expectType<Promise<Message<false>>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message<false>>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message<false>>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message<false>>>(interaction.fetchResponse());
+      expectType<Promise<Message<false>>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message<false>>>(interaction.followUp({ content: 'a' }));
     } else if (interaction.inGuild()) {
       expectAssignable<ModalSubmitInteraction>(interaction);
       expectType<Guild | null>(interaction.guild);
-      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchReply: true }));
-      expectType<Promise<Message>>(interaction.deferReply({ fetchReply: true }));
-      expectType<Promise<Message>>(interaction.editReply({ content: 'a' }));
-      expectType<Promise<Message>>(interaction.fetchReply());
-      expectType<Promise<Message>>(interaction.deferUpdate({ fetchReply: true }));
+      expectType<Promise<Message>>(interaction.reply({ content: 'a', fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.deferReply({ fetchResponse: true }));
+      expectType<Promise<Message>>(interaction.editResponse({ content: 'a' }));
+      expectType<Promise<Message>>(interaction.fetchResponse());
+      expectType<Promise<Message>>(interaction.deferMessageUpdate({ fetchResponse: true }));
       expectType<Promise<Message>>(interaction.followUp({ content: 'a' }));
     }
   }