fix(GuildAuditLogs): typings and consistency (#7445)

packages/discord.js/src/structures/GuildAuditLogs.js

@@ -14,19 +14,19 @@ const Util = require('../util/Util');
 
 /**
  * The target type of an entry. Here are the available types:
- * * GUILD
+ * * Guild
- * * CHANNEL
+ * * Channel
- * * USER
+ * * User
- * * ROLE
+ * * Role
- * * INVITE
+ * * Invite
- * * WEBHOOK
+ * * Webhook
- * * EMOJI
+ * * Emoji
- * * MESSAGE
+ * * Message
- * * INTEGRATION
+ * * Integration
- * * STAGE_INSTANCE
+ * * StageInstance
- * * STICKER
+ * * Sticker
- * * THREAD
+ * * Thread
- * * GUILD_SCHEDULED_EVENT
+ * * GuildScheduledEvent
  * @typedef {string} AuditLogTargetType
  */
 
@@ -36,21 +36,21 @@ const Util = require('../util/Util');
  * @type {Object<string, string>}
  */
 const Targets = {
-  ALL: 'ALL',
+  All: 'All',
-  GUILD: 'GUILD',
+  Guild: 'Guild',
-  GUILD_SCHEDULED_EVENT: 'GUILD_SCHEDULED_EVENT',
+  GuildScheduledEvent: 'GuildScheduledEvent',
-  CHANNEL: 'CHANNEL',
+  Channel: 'Channel',
-  USER: 'USER',
+  User: 'User',
-  ROLE: 'ROLE',
+  Role: 'Role',
-  INVITE: 'INVITE',
+  Invite: 'Invite',
-  WEBHOOK: 'WEBHOOK',
+  Webhook: 'Webhook',
-  EMOJI: 'EMOJI',
+  Emoji: 'Emoji',
-  MESSAGE: 'MESSAGE',
+  Message: 'Message',
-  INTEGRATION: 'INTEGRATION',
+  Integration: 'Integration',
-  STAGE_INSTANCE: 'STAGE_INSTANCE',
+  StageInstance: 'StageInstance',
-  STICKER: 'STICKER',
+  Sticker: 'Sticker',
-  THREAD: 'THREAD',
+  Thread: 'Thread',
-  UNKNOWN: 'UNKNOWN',
+  Unknown: 'Unknown',
 };
 
 /**
@@ -132,28 +132,28 @@ class GuildAuditLogs {
    * @returns {AuditLogTargetType}
    */
   static targetType(target) {
-    if (target < 10) return Targets.GUILD;
+    if (target < 10) return Targets.Guild;
-    if (target < 20) return Targets.CHANNEL;
+    if (target < 20) return Targets.Channel;
-    if (target < 30) return Targets.USER;
+    if (target < 30) return Targets.User;
-    if (target < 40) return Targets.ROLE;
+    if (target < 40) return Targets.Role;
-    if (target < 50) return Targets.INVITE;
+    if (target < 50) return Targets.Invite;
-    if (target < 60) return Targets.WEBHOOK;
+    if (target < 60) return Targets.Webhook;
-    if (target < 70) return Targets.EMOJI;
+    if (target < 70) return Targets.Emoji;
-    if (target < 80) return Targets.MESSAGE;
+    if (target < 80) return Targets.Message;
-    if (target < 83) return Targets.INTEGRATION;
+    if (target < 83) return Targets.Integration;
-    if (target < 86) return Targets.STAGE_INSTANCE;
+    if (target < 86) return Targets.StageInstance;
-    if (target < 100) return Targets.STICKER;
+    if (target < 100) return Targets.Sticker;
-    if (target < 110) return Targets.GUILD_SCHEDULED_EVENT;
+    if (target < 110) return Targets.GuildScheduledEvent;
-    if (target < 120) return Targets.THREAD;
+    if (target < 120) return Targets.Thread;
-    return Targets.UNKNOWN;
+    return Targets.Unknown;
   }
 
   /**
-   * The action type of an entry, e.g. `CREATE`. Here are the available types:
+   * The action type of an entry, e.g. `Create`. Here are the available types:
-   * * CREATE
+   * * Create
-   * * DELETE
+   * * Delete
-   * * UPDATE
+   * * Update
-   * * ALL
+   * * All
    * @typedef {string} AuditLogActionType
    */
 
@@ -181,7 +181,7 @@ class GuildAuditLogs {
         AuditLogEvent.ThreadCreate,
       ].includes(action)
     ) {
-      return 'CREATE';
+      return 'Create';
     }
 
     if (
@@ -206,7 +206,7 @@ class GuildAuditLogs {
         AuditLogEvent.ThreadDelete,
       ].includes(action)
     ) {
-      return 'DELETE';
+      return 'Delete';
     }
 
     if (
@@ -228,10 +228,10 @@ class GuildAuditLogs {
         AuditLogEvent.ThreadUpdate,
       ].includes(action)
     ) {
-      return 'UPDATE';
+      return 'Update';
     }
 
-    return 'ALL';
+    return 'All';
   }
 
   toJSON() {
@@ -376,20 +376,20 @@ class GuildAuditLogsEntry {
      * @type {?AuditLogEntryTarget}
      */
     this.target = null;
-    if (targetType === Targets.UNKNOWN) {
+    if (targetType === Targets.Unknown) {
       this.target = this.changes.reduce((o, c) => {
         o[c.key] = c.new ?? c.old;
         return o;
       }, {});
       this.target.id = data.target_id;
-      // MEMBER_DISCONNECT and similar types do not provide a target_id.
+      // MemberDisconnect and similar types do not provide a target_id.
-    } else if (targetType === Targets.USER && data.target_id) {
+    } else if (targetType === Targets.User && data.target_id) {
       this.target = guild.client.options.partials.includes(Partials.User)
         ? guild.client.users._add({ id: data.target_id })
         : guild.client.users.cache.get(data.target_id);
-    } else if (targetType === Targets.GUILD) {
+    } else if (targetType === Targets.Guild) {
       this.target = guild.client.guilds.cache.get(data.target_id);
-    } else if (targetType === Targets.WEBHOOK) {
+    } else if (targetType === Targets.Webhook) {
       this.target =
         logs.webhooks.get(data.target_id) ??
         new Webhook(
@@ -405,7 +405,7 @@ class GuildAuditLogsEntry {
             },
           ),
         );
-    } else if (targetType === Targets.INVITE) {
+    } else if (targetType === Targets.Invite) {
       let change = this.changes.find(c => c.key === 'code');
       change = change.new ?? change.old;
 
@@ -421,13 +421,13 @@ class GuildAuditLogsEntry {
             { guild },
           ),
         );
-    } else if (targetType === Targets.MESSAGE) {
+    } else if (targetType === Targets.Message) {
-      // Discord sends a channel id for the MESSAGE_BULK_DELETE action type.
+      // Discord sends a channel id for the MessageBulkDelete action type.
       this.target =
         data.action_type === AuditLogEvent.MessageBulkDelete
           ? guild.channels.cache.get(data.target_id) ?? { id: data.target_id }
           : guild.client.users.cache.get(data.target_id);
-    } else if (targetType === Targets.INTEGRATION) {
+    } else if (targetType === Targets.Integration) {
       this.target =
         logs.integrations.get(data.target_id) ??
         new Integration(
@@ -441,7 +441,7 @@ class GuildAuditLogsEntry {
           ),
           guild,
         );
-    } else if (targetType === Targets.CHANNEL || targetType === Targets.THREAD) {
+    } else if (targetType === Targets.Channel || targetType === Targets.Thread) {
       this.target =
         guild.channels.cache.get(data.target_id) ??
         this.changes.reduce(
@@ -451,7 +451,7 @@ class GuildAuditLogsEntry {
           },
           { id: data.target_id },
         );
-    } else if (targetType === Targets.STAGE_INSTANCE) {
+    } else if (targetType === Targets.StageInstance) {
       this.target =
         guild.stageInstances.cache.get(data.target_id) ??
         new StageInstance(
@@ -468,7 +468,7 @@ class GuildAuditLogsEntry {
             },
           ),
         );
-    } else if (targetType === Targets.STICKER) {
+    } else if (targetType === Targets.Sticker) {
       this.target =
         guild.stickers.cache.get(data.target_id) ??
         new Sticker(
@@ -481,7 +481,7 @@ class GuildAuditLogsEntry {
             { id: data.target_id },
           ),
         );
-    } else if (targetType === Targets.GUILD_SCHEDULED_EVENT) {
+    } else if (targetType === Targets.GuildScheduledEvent) {
       this.target =
         guild.scheduledEvents.cache.get(data.target_id) ??
         new GuildScheduledEvent(

packages/discord.js/src/util/EnumResolvers.js

@@ -20,6 +20,7 @@ const {
   TeamMemberMembershipState,
   GuildScheduledEventEntityType,
   IntegrationExpireBehavior,
+  AuditLogEvent,
 } = require('discord-api-types/v9');
 
 function unknownKeyStrategy(val) {
@@ -633,6 +634,157 @@ class EnumResolvers extends null {
         return unknownKeyStrategy(key);
     }
   }
+
+  /**
+   * A string that can be resolved to a {@link AuditLogEvent} enum value. Here are the available types:
+   * * GUILD_UPDATE
+   * * CHANNEL_CREATE
+   * * CHANNEL_UPDATE
+   * * CHANNEL_DELETE
+   * * CHANNEL_OVERWRITE_CREATE
+   * * CHANNEL_OVERWRITE_UPDATE
+   * * CHANNEL_OVERWRITE_DELETE
+   * * MEMBER_KICK
+   * * MEMBER_PRUNE
+   * * MEMBER_BAN_ADD
+   * * MEMBER_BAN_REMOVE
+   * * MEMBER_UPDATE
+   * * MEMBER_ROLE_UPDATE
+   * * MEMBER_MOVE
+   * * MEMBER_DISCONNECT
+   * * BOT_ADD
+   * * ROLE_CREATE
+   * * ROLE_UPDATE
+   * * ROLE_DELETE
+   * * INVITE_CREATE
+   * * INVITE_UPDATE
+   * * INVITE_DELETE
+   * * WEBHOOK_CREATE
+   * * WEBHOOK_UPDATE
+   * * WEBHOOK_DELETE
+   * * INTEGRATION_CREATE
+   * * INTEGRATION_UPDATE
+   * * INTEGRATION_DELETE
+   * * STAGE_INSTANCE_CREATE
+   * * STAGE_INSTANCE_UPDATE
+   * * STAGE_INSTANCE_DELETE
+   * * STICKER_CREATE
+   * * STICKER_UPDATE
+   * * STICKER_DELETE
+   * * GUILD_SCHEDULED_EVENT_CREATE
+   * * GUILD_SCHEDULED_EVENT_UPDATE
+   * * GUILD_SCHEDULED_EVENT_DELETE
+   * * THREAD_CREATE
+   * * THREAD_UPDATE
+   * * THREAD_DELETE
+   * @typedef {string} AuditLogEventEnumResolvable
+   */
+
+  /**
+   * Resolves enum key to {@link AuditLogEvent} enum value
+   * @param {AuditLogEventEnumResolvable|AuditLogEvent} key The key to lookup
+   * @returns {AuditLogEvent}
+   */
+  static resolveAuditLogEvent(key) {
+    switch (key) {
+      case 'GUILD_UPDATE':
+        return AuditLogEvent.GuildUpdate;
+      case 'CHANNEL_CREATE':
+        return AuditLogEvent.ChannelCreate;
+      case 'CHANNEL_UPDATE':
+        return AuditLogEvent.ChannelUpdate;
+      case 'CHANNEL_DELETE':
+        return AuditLogEvent.ChannelDelete;
+      case 'CHANNEL_OVERWRITE_CREATE':
+        return AuditLogEvent.ChannelOverwriteCreate;
+      case 'CHANNEL_OVERWRITE_UPDATE':
+        return AuditLogEvent.ChannelOverwriteUpdate;
+      case 'CHANNEL_OVERWRITE_DELETE':
+        return AuditLogEvent.ChannelOverwriteDelete;
+      case 'MEMBER_KICK':
+        return AuditLogEvent.MemberKick;
+      case 'MEMBER_PRUNE':
+        return AuditLogEvent.MemberPrune;
+      case 'MEMBER_BAN_ADD':
+        return AuditLogEvent.MemberBanAdd;
+      case 'MEMBER_BAN_REMOVE':
+        return AuditLogEvent.MemberBanRemove;
+      case 'MEMBER_UPDATE':
+        return AuditLogEvent.MemberUpdate;
+      case 'MEMBER_ROLE_UPDATE':
+        return AuditLogEvent.MemberRoleUpdate;
+      case 'MEMBER_MOVE':
+        return AuditLogEvent.MemberMove;
+      case 'MEMBER_DISCONNECT':
+        return AuditLogEvent.MemberDisconnect;
+      case 'BOT_ADD':
+        return AuditLogEvent.BotAdd;
+      case 'ROLE_CREATE':
+        return AuditLogEvent.RoleCreate;
+      case 'ROLE_UPDATE':
+        return AuditLogEvent.RoleUpdate;
+      case 'ROLE_DELETE':
+        return AuditLogEvent.RoleDelete;
+      case 'INVITE_CREATE':
+        return AuditLogEvent.InviteCreate;
+      case 'INVITE_UPDATE':
+        return AuditLogEvent.InviteUpdate;
+      case 'INVITE_DELETE':
+        return AuditLogEvent.InviteDelete;
+      case 'WEBHOOK_CREATE':
+        return AuditLogEvent.WebhookCreate;
+      case 'WEBHOOK_UPDATE':
+        return AuditLogEvent.WebhookUpdate;
+      case 'WEBHOOK_DELETE':
+        return AuditLogEvent.WebhookDelete;
+      case 'EMOJI_CREATE':
+        return AuditLogEvent.EmojiCreate;
+      case 'EMOJI_UPDATE':
+        return AuditLogEvent.EmojiUpdate;
+      case 'EMOJI_DELETE':
+        return AuditLogEvent.EmojiDelete;
+      case 'MESSAGE_DELETE':
+        return AuditLogEvent.MessageDelete;
+      case 'MESSAGE_BULK_DELETE':
+        return AuditLogEvent.MessageBulkDelete;
+      case 'MESSAGE_PIN':
+        return AuditLogEvent.MessagePin;
+      case 'MESSAGE_UNPIN':
+        return AuditLogEvent.MessageUnpin;
+      case 'INTEGRATION_CREATE':
+        return AuditLogEvent.IntegrationCreate;
+      case 'INTEGRATION_UPDATE':
+        return AuditLogEvent.IntegrationUpdate;
+      case 'INTEGRATION_DELETE':
+        return AuditLogEvent.IntegrationDelete;
+      case 'STAGE_INSTANCE_CREATE':
+        return AuditLogEvent.StageInstanceCreate;
+      case 'STAGE_INSTANCE_UPDATE':
+        return AuditLogEvent.StageInstanceUpdate;
+      case 'STAGE_INSTANCE_DELETE':
+        return AuditLogEvent.StageInstanceDelete;
+      case 'STICKER_CREATE':
+        return AuditLogEvent.StickerCreate;
+      case 'STICKER_UPDATE':
+        return AuditLogEvent.StickerUpdate;
+      case 'STICKER_DELETE':
+        return AuditLogEvent.StickerDelete;
+      case 'GUILD_SCHEDULED_EVENT_CREATE':
+        return AuditLogEvent.GuildScheduledEventCreate;
+      case 'GUILD_SCHEDULED_EVENT_UPDATE':
+        return AuditLogEvent.GuildScheduledEventUpdate;
+      case 'GUILD_SCHEDULED_EVENT_DELETE':
+        return AuditLogEvent.GuildScheduledEventDelete;
+      case 'THREAD_CREATE':
+        return AuditLogEvent.ThreadCreate;
+      case 'THREAD_UPDATE':
+        return AuditLogEvent.ThreadUpdate;
+      case 'THREAD_DELETE':
+        return AuditLogEvent.ThreadDelete;
+      default:
+        return unknownKeyStrategy(key);
+    }
+  }
 }
 
 // Precondition logic wrapper

packages/discord.js/typings/index.d.ts

@@ -91,6 +91,7 @@ import {
   GuildSystemChannelFlags,
   GatewayIntentBits,
   ActivityFlags,
+  AuditLogEvent,
   APIMessageComponentEmoji,
   EmbedType,
 } from 'discord-api-types/v9';
@@ -908,6 +909,7 @@ export class EnumResolvers extends null {
   public static resolveIntegrationExpireBehavior(
     key: IntegrationExpireBehaviorEnumResolvable | IntegrationExpireBehavior,
   ): IntegrationExpireBehavior;
+  public static resolveAuditLogEvent(key: AuditLogEventEnumResolvable | AuditLogEvent): AuditLogEvent;
 }
 
 export class DMChannel extends TextBasedChannelMixin(Channel, ['bulkDelete']) {
@@ -991,7 +993,7 @@ export class Guild extends AnonymousGuild {
   public edit(data: GuildEditData, reason?: string): Promise<Guild>;
   public editWelcomeScreen(data: WelcomeScreenEditData): Promise<WelcomeScreen>;
   public equals(guild: Guild): boolean;
-  public fetchAuditLogs<T extends GuildAuditLogsResolvable = 'All'>(
+  public fetchAuditLogs<T extends GuildAuditLogsResolvable = null>(
     options?: GuildAuditLogsFetchOptions<T>,
   ): Promise<GuildAuditLogs<T>>;
   public fetchIntegrations(): Promise<Collection<Snowflake | string, Integration>>;
@@ -1031,14 +1033,13 @@ export class Guild extends AnonymousGuild {
   public toJSON(): unknown;
 }
 
-export class GuildAuditLogs<T extends GuildAuditLogsResolvable = 'All'> {
+export class GuildAuditLogs<T extends GuildAuditLogsResolvable = null> {
   private constructor(guild: Guild, data: RawGuildAuditLogData);
   private webhooks: Collection<Snowflake, Webhook>;
   private integrations: Collection<Snowflake | string, Integration>;
 
   public entries: Collection<Snowflake, GuildAuditLogsEntry<T>>;
 
-  public static Actions: GuildAuditLogsActions;
   public static Targets: GuildAuditLogsTargets;
   public static Entry: typeof GuildAuditLogsEntry;
   public static actionType(action: number): GuildAuditLogsActionType;
@@ -1048,12 +1049,7 @@ export class GuildAuditLogs<T extends GuildAuditLogsResolvable = 'All'> {
 }
 
 export class GuildAuditLogsEntry<
-  TActionRaw extends GuildAuditLogsResolvable = 'All',
+  TAction extends GuildAuditLogsResolvable = null,
-  TAction = TActionRaw extends keyof GuildAuditLogsIds
-    ? GuildAuditLogsIds[TActionRaw]
-    : TActionRaw extends null
-    ? 'All'
-    : TActionRaw,
   TActionType extends GuildAuditLogsActionType = TAction extends keyof GuildAuditLogsTypes
     ? GuildAuditLogsTypes[TAction][1]
     : 'All',
@@ -3994,6 +3990,48 @@ export type GuildScheduledEventEntityTypeEnumResolvable = 'STAGE_INSTANCE' | 'VO
 
 export type IntegrationExpireBehaviorEnumResolvable = 'REMOVE_ROLE' | 'KICK';
 
+export type AuditLogEventEnumResolvable =
+  | 'GUILD_UPDATE'
+  | 'CHANNEL_CREATE'
+  | 'CHANNEL_UPDATE'
+  | 'CHANNEL_DELETE'
+  | 'CHANNEL_OVERWRITE_CREATE'
+  | 'CHANNEL_OVERWRITE_UPDATE'
+  | 'CHANNEL_OVERWRITE_DELETE'
+  | 'MEMBER_KICK'
+  | 'MEMBER_PRUNE'
+  | 'MEMBER_BAN_ADD'
+  | 'MEMBER_BAN_REMOVE'
+  | 'MEMBER_UPDATE'
+  | 'MEMBER_ROLE_UPDATE'
+  | 'MEMBER_MOVE'
+  | 'MEMBER_DISCONNECT'
+  | 'BOT_ADD'
+  | 'ROLE_CREATE'
+  | 'ROLE_UPDATE'
+  | 'ROLE_DELETE'
+  | 'INVITE_CREATE'
+  | 'INVITE_UPDATE'
+  | 'INVITE_DELETE'
+  | 'WEBHOOK_CREATE'
+  | 'WEBHOOK_UPDATE'
+  | 'WEBHOOK_DELETE'
+  | 'INTEGRATION_CREATE'
+  | 'INTEGRATION_UPDATE'
+  | 'INTEGRATION_DELETE'
+  | 'STAGE_INSTANCE_CREATE'
+  | 'STAGE_INSTANCE_UPDATE'
+  | 'STAGE_INSTANCE_DELETE'
+  | 'STICKER_CREATE'
+  | 'STICKER_UPDATE'
+  | 'STICKER_DELETE'
+  | 'GUILD_SCHEDULED_EVENT_CREATE'
+  | 'GUILD_SCHEDULED_EVENT_UPDATE'
+  | 'GUILD_SCHEDULED_EVENT_DELETE'
+  | 'THREAD_CREATE'
+  | 'THREAD_UPDATE'
+  | 'THREAD_DELETE';
+
 export interface ErrorEvent {
   error: unknown;
   message: string;
@@ -4114,137 +4152,83 @@ export interface GuildApplicationCommandPermissionData {
 }
 
 interface GuildAuditLogsTypes {
-  GuildUpdate: ['Guild', 'Update'];
+  [AuditLogEvent.GuildUpdate]: ['Guild', 'Update'];
-  ChannelCreate: ['Channel', 'Create'];
+  [AuditLogEvent.ChannelCreate]: ['Channel', 'Create'];
-  ChannelUpdate: ['Channel', 'Update'];
+  [AuditLogEvent.ChannelUpdate]: ['Channel', 'Update'];
-  ChannelDelete: ['Channel', 'Delete'];
+  [AuditLogEvent.ChannelDelete]: ['Channel', 'Delete'];
-  ChannelOverwriteCreate: ['Channel', 'Create'];
+  [AuditLogEvent.ChannelOverwriteCreate]: ['Channel', 'Create'];
-  ChannelOverwriteUpdate: ['Channel', 'Update'];
+  [AuditLogEvent.ChannelOverwriteUpdate]: ['Channel', 'Update'];
-  ChannelOverwriteDelete: ['Channel', 'Delete'];
+  [AuditLogEvent.ChannelOverwriteDelete]: ['Channel', 'Delete'];
-  MemberKick: ['User', 'Delete'];
+  [AuditLogEvent.MemberKick]: ['User', 'Delete'];
-  MemberPrune: ['User', 'Delete'];
+  [AuditLogEvent.MemberPrune]: ['User', 'Delete'];
-  MemberBanAdd: ['User', 'Delete'];
+  [AuditLogEvent.MemberBanAdd]: ['User', 'Delete'];
-  MemberBanRemove: ['User', 'Create'];
+  [AuditLogEvent.MemberBanRemove]: ['User', 'Create'];
-  MemberUpdate: ['User', 'Update'];
+  [AuditLogEvent.MemberUpdate]: ['User', 'Update'];
-  MemberRoleUpdate: ['User', 'Update'];
+  [AuditLogEvent.MemberRoleUpdate]: ['User', 'Update'];
-  MemberMove: ['User', 'Update'];
+  [AuditLogEvent.MemberMove]: ['User', 'Update'];
-  MemberDisconnect: ['User', 'Delete'];
+  [AuditLogEvent.MemberDisconnect]: ['User', 'Delete'];
-  BotAdd: ['User', 'Create'];
+  [AuditLogEvent.BotAdd]: ['User', 'Create'];
-  RoleCreate: ['Role', 'Create'];
+  [AuditLogEvent.RoleCreate]: ['Role', 'Create'];
-  RoleUpdate: ['Role', 'Update'];
+  [AuditLogEvent.RoleUpdate]: ['Role', 'Update'];
-  RoleDelete: ['Role', 'Delete'];
+  [AuditLogEvent.RoleDelete]: ['Role', 'Delete'];
-  InviteCreate: ['Invite', 'Create'];
+  [AuditLogEvent.InviteCreate]: ['Invite', 'Create'];
-  InviteUpdate: ['Invite', 'Update'];
+  [AuditLogEvent.InviteUpdate]: ['Invite', 'Update'];
-  InviteDelete: ['Invite', 'Delete'];
+  [AuditLogEvent.InviteDelete]: ['Invite', 'Delete'];
-  WebhookCreate: ['Webhook', 'Create'];
+  [AuditLogEvent.WebhookCreate]: ['Webhook', 'Create'];
-  WebhookUpdate: ['Webhook', 'Update'];
+  [AuditLogEvent.WebhookUpdate]: ['Webhook', 'Update'];
-  WebhookDelete: ['Webhook', 'Delete'];
+  [AuditLogEvent.WebhookDelete]: ['Webhook', 'Delete'];
-  EmojiCreate: ['Emoji', 'Create'];
+  [AuditLogEvent.EmojiCreate]: ['Emoji', 'Create'];
-  EmojiUpdate: ['Emoji', 'Update'];
+  [AuditLogEvent.EmojiUpdate]: ['Emoji', 'Update'];
-  EmojiDelete: ['Emoji', 'Delete'];
+  [AuditLogEvent.EmojiDelete]: ['Emoji', 'Delete'];
-  MessageDelete: ['Message', 'Delete'];
+  [AuditLogEvent.MessageDelete]: ['Message', 'Delete'];
-  MessageBulkDelete: ['Message', 'Delete'];
+  [AuditLogEvent.MessageBulkDelete]: ['Message', 'Delete'];
-  MessagePin: ['Message', 'Create'];
+  [AuditLogEvent.MessagePin]: ['Message', 'Create'];
-  MessageUnpin: ['Message', 'Delete'];
+  [AuditLogEvent.MessageUnpin]: ['Message', 'Delete'];
-  IntegrationCreate: ['Integration', 'Create'];
+  [AuditLogEvent.IntegrationCreate]: ['Integration', 'Create'];
-  IntegrationUpdate: ['Integration', 'Update'];
+  [AuditLogEvent.IntegrationUpdate]: ['Integration', 'Update'];
-  IntegrationDelete: ['Integration', 'Delete'];
+  [AuditLogEvent.IntegrationDelete]: ['Integration', 'Delete'];
-  StageInstanceCreate: ['StageInstance', 'Create'];
+  [AuditLogEvent.StageInstanceCreate]: ['StageInstance', 'Create'];
-  StageInstanceUpdate: ['StageInstance', 'Update'];
+  [AuditLogEvent.StageInstanceUpdate]: ['StageInstance', 'Update'];
-  StageInstanceDelete: ['StageInstance', 'Delete'];
+  [AuditLogEvent.StageInstanceDelete]: ['StageInstance', 'Delete'];
-  StickerCreate: ['Sticker', 'Create'];
+  [AuditLogEvent.StickerCreate]: ['Sticker', 'Create'];
-  StickerUpdate: ['Sticker', 'Update'];
+  [AuditLogEvent.StickerUpdate]: ['Sticker', 'Update'];
-  StickerDelete: ['Sticker', 'Delete'];
+  [AuditLogEvent.StickerDelete]: ['Sticker', 'Delete'];
-  GuildScheduledEventCreate: ['GuildScheduledEvent', 'Create'];
+  [AuditLogEvent.GuildScheduledEventCreate]: ['GuildScheduledEvent', 'Create'];
-  GuildScheduledEventUpdate: ['GuildScheduledEvent', 'Update'];
+  [AuditLogEvent.GuildScheduledEventUpdate]: ['GuildScheduledEvent', 'Update'];
-  GuildScheduledEventDelete: ['GuildScheduledEvent', 'Delete'];
+  [AuditLogEvent.GuildScheduledEventDelete]: ['GuildScheduledEvent', 'Delete'];
-  ThreadCreate: ['Thread', 'Create'];
+  [AuditLogEvent.ThreadCreate]: ['Thread', 'Create'];
-  ThreadUpdate: ['Thread', 'Update'];
+  [AuditLogEvent.ThreadUpdate]: ['Thread', 'Update'];
-  ThreadDelete: ['Thread', 'Delete'];
+  [AuditLogEvent.ThreadDelete]: ['Thread', 'Delete'];
 }
 
-export interface GuildAuditLogsIds {
-  1: 'GuildUpdate';
-  10: 'ChannelCreate';
-  11: 'ChannelUpdate';
-  12: 'ChannelDelete';
-  13: 'ChannelOverwriteCreate';
-  14: 'ChannelOverwriteUpdate';
-  15: 'ChannelOverwriteDelete';
-  20: 'MemberKick';
-  21: 'MemberPrune';
-  22: 'MemberBanAdd';
-  23: 'MemberBanRemove';
-  24: 'MemberUpdate';
-  25: 'MemberRoleUpdate';
-  26: 'MemberMove';
-  27: 'MemberDisconnect';
-  28: 'BotAdd';
-  30: 'RoleCreate';
-  31: 'RoleUpdate';
-  32: 'RoleDelete';
-  40: 'InviteCreate';
-  41: 'InviteUpdate';
-  42: 'InviteDelete';
-  50: 'WebhookCreate';
-  51: 'WebhookUpdate';
-  52: 'WebhookDelete';
-  60: 'EmojiCreate';
-  61: 'EmojiUpdate';
-  62: 'EmojiDelete';
-  72: 'MessageDelete';
-  73: 'MessageBulkDelete';
-  74: 'MessagePin';
-  75: 'MessageUnpin';
-  80: 'IntegrationCreate';
-  81: 'IntegrationUpdate';
-  82: 'IntegrationDelete';
-  83: 'StageInstanceCreate';
-  84: 'StageInstanceUpdate';
-  85: 'StageInstanceDelete';
-  90: 'StickerCreate';
-  91: 'StickerUpdate';
-  92: 'StickerDelete';
-  100: 'GuildScheduledEventCreate';
-  101: 'GuildScheduledEventUpdate';
-  102: 'GuildScheduledEventDelete';
-  110: 'ThreadCreate';
-  111: 'ThreadUpdate';
-  112: 'ThreadDelete';
-}
-
-export type GuildAuditLogsActions = { [Key in keyof GuildAuditLogsIds as GuildAuditLogsIds[Key]]: Key } & { All: null };
-
-export type GuildAuditLogsAction = keyof GuildAuditLogsActions;
-
 export type GuildAuditLogsActionType = GuildAuditLogsTypes[keyof GuildAuditLogsTypes][1] | 'All';
 
 export interface GuildAuditLogsEntryExtraField {
-  MemberPrune: { removed: number; days: number };
+  [AuditLogEvent.MemberPrune]: { removed: number; days: number };
-  MemberMove: { channel: VoiceBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MemberMove]: { channel: VoiceBasedChannel | { id: Snowflake }; count: number };
-  MessageDelete: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MessageDelete]: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
-  MessageBulkDelete: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
+  [AuditLogEvent.MessageBulkDelete]: { channel: GuildTextBasedChannel | { id: Snowflake }; count: number };
-  MessagePin: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
+  [AuditLogEvent.MessagePin]: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
-  MessageUnpin: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
+  [AuditLogEvent.MessageUnpin]: { channel: GuildTextBasedChannel | { id: Snowflake }; messageId: Snowflake };
-  MemberDisconnect: { count: number };
+  [AuditLogEvent.MemberDisconnect]: { count: number };
-  ChannelOverwriteCreate:
+  [AuditLogEvent.ChannelOverwriteCreate]:
     | Role
     | GuildMember
     | { id: Snowflake; name: string; type: 'Role' }
     | { id: Snowflake; type: 'Member' };
-  ChannelOverwriteUpdate:
+  [AuditLogEvent.ChannelOverwriteUpdate]:
     | Role
     | GuildMember
     | { id: Snowflake; name: string; type: 'Role' }
     | { id: Snowflake; type: 'Member' };
-  ChannelOverwriteDelete:
+  [AuditLogEvent.ChannelOverwriteDelete]:
     | Role
     | GuildMember
     | { id: Snowflake; name: string; type: OverwriteType.Role }
     | { id: Snowflake; type: OverwriteType.Member };
-  StageInstanceCreate: StageChannel | { id: Snowflake };
+  [AuditLogEvent.StageInstanceCreate]: StageChannel | { id: Snowflake };
-  StageInstanceDelete: StageChannel | { id: Snowflake };
+  [AuditLogEvent.StageInstanceDelete]: StageChannel | { id: Snowflake };
-  StageInstanceUpdate: StageChannel | { id: Snowflake };
+  [AuditLogEvent.StageInstanceUpdate]: StageChannel | { id: Snowflake };
 }
 
 export interface GuildAuditLogsEntryTargetField<TActionType extends GuildAuditLogsActionType> {
@@ -4252,7 +4236,7 @@ export interface GuildAuditLogsEntryTargetField<TActionType extends GuildAuditLo
   Guild: Guild;
   Webhook: Webhook;
   Invite: Invite;
-  Message: TActionType extends 'MESSAGE_BULK_DELETE' ? Guild | { id: Snowflake } : User;
+  Message: TActionType extends AuditLogEvent.MessageBulkDelete ? Guild | { id: Snowflake } : User;
   Integration: Integration;
   Channel: NonThreadGuildBasedChannel | { id: Snowflake; [x: string]: unknown };
   Thread: ThreadChannel | { id: Snowflake; [x: string]: unknown };
@@ -4268,12 +4252,12 @@ export interface GuildAuditLogsFetchOptions<T extends GuildAuditLogsResolvable>
   type?: T;
 }
 
-export type GuildAuditLogsResolvable = keyof GuildAuditLogsIds | GuildAuditLogsAction | null;
+export type GuildAuditLogsResolvable = AuditLogEvent | null;
 
 export type GuildAuditLogsTarget = GuildAuditLogsTypes[keyof GuildAuditLogsTypes][0] | 'All' | 'Unknown';
 
 export type GuildAuditLogsTargets = {
-  [key in GuildAuditLogsTarget]?: string;
+  [key in GuildAuditLogsTarget]: GuildAuditLogsTarget;
 };
 
 export type GuildBanResolvable = GuildBan | UserResolvable;

packages/discord.js/typings/index.test-d.ts

@@ -16,9 +16,9 @@ import {
   InteractionType,
   GatewayIntentBits,
   PermissionFlagsBits,
+  AuditLogEvent,
   ButtonStyle,
 } from 'discord-api-types/v9';
-import { AuditLogEvent } from 'discord-api-types/v9';
 import {
   ApplicationCommand,
   ApplicationCommandData,
@@ -1226,84 +1226,51 @@ collector.on('end', (collection, reason) => {
 expectType<Promise<number | null>>(shard.eval(c => c.readyTimestamp));
 
 // Test audit logs
-expectType<Promise<GuildAuditLogs<'MemberKick'>>>(guild.fetchAuditLogs({ type: 'MemberKick' }));
-expectAssignable<Promise<GuildAuditLogs<AuditLogEvent.MemberKick>>>(
-  guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.MemberKick }),
-);
 expectType<Promise<GuildAuditLogs<AuditLogEvent.MemberKick>>>(guild.fetchAuditLogs({ type: AuditLogEvent.MemberKick }));
 
-expectType<Promise<GuildAuditLogs<'ChannelCreate'>>>(guild.fetchAuditLogs({ type: 'ChannelCreate' }));
-expectAssignable<Promise<GuildAuditLogs<AuditLogEvent.ChannelCreate>>>(
-  guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.ChannelCreate }),
-);
 expectType<Promise<GuildAuditLogs<AuditLogEvent.ChannelCreate>>>(
   guild.fetchAuditLogs({ type: AuditLogEvent.ChannelCreate }),
 );
 
-expectType<Promise<GuildAuditLogs<'IntegrationUpdate'>>>(guild.fetchAuditLogs({ type: 'IntegrationUpdate' }));
-expectAssignable<Promise<GuildAuditLogs<AuditLogEvent.IntegrationUpdate>>>(
-  guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.IntegrationUpdate }),
-);
 expectType<Promise<GuildAuditLogs<AuditLogEvent.IntegrationUpdate>>>(
   guild.fetchAuditLogs({ type: AuditLogEvent.IntegrationUpdate }),
 );
 
-expectType<Promise<GuildAuditLogs<'All'>>>(guild.fetchAuditLogs({ type: 'All' }));
+expectType<Promise<GuildAuditLogs<null>>>(guild.fetchAuditLogs({ type: null }));
-expectType<Promise<GuildAuditLogs<null>>>(guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.All }));
+expectType<Promise<GuildAuditLogs<null>>>(guild.fetchAuditLogs());
-expectType<Promise<GuildAuditLogs<'All'>>>(guild.fetchAuditLogs());
 
-expectType<Promise<GuildAuditLogsEntry<'MemberKick', 'MemberKick', 'Delete', 'User'> | undefined>>(
+expectType<Promise<GuildAuditLogsEntry<AuditLogEvent.MemberKick, 'Delete', 'User'> | undefined>>(
-  guild.fetchAuditLogs({ type: 'MemberKick' }).then(al => al.entries.first()),
+  guild.fetchAuditLogs({ type: AuditLogEvent.MemberKick }).then(al => al.entries.first()),
 );
-expectType<Promise<GuildAuditLogsEntry<'MemberKick', 'MemberKick', 'Delete', 'User'> | undefined>>(
+expectAssignable<Promise<GuildAuditLogsEntry<AuditLogEvent.MemberKick, 'Delete', 'User'> | undefined>>(
-  guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.MemberKick }).then(al => al.entries.first()),
-);
-expectAssignable<Promise<GuildAuditLogsEntry<'MemberKick', 'MemberKick', 'Delete', 'User'> | undefined>>(
   guild.fetchAuditLogs({ type: AuditLogEvent.MemberKick }).then(al => al.entries.first()),
 );
 
-expectType<Promise<GuildAuditLogsEntry<'All', 'All', 'All', 'Unknown'> | undefined>>(
+expectType<Promise<GuildAuditLogsEntry<null, 'All', 'Unknown'> | undefined>>(
-  guild.fetchAuditLogs({ type: 'All' }).then(al => al.entries.first()),
-);
-expectType<Promise<GuildAuditLogsEntry<'All', 'All', 'All', 'Unknown'> | undefined>>(
-  guild.fetchAuditLogs({ type: GuildAuditLogs.Actions.All }).then(al => al.entries.first()),
-);
-expectType<Promise<GuildAuditLogsEntry<'All', 'All', 'All', 'Unknown'> | undefined>>(
   guild.fetchAuditLogs({ type: null }).then(al => al.entries.first()),
 );
-expectType<Promise<GuildAuditLogsEntry<'All', 'All', 'All', 'Unknown'> | undefined>>(
+expectType<Promise<GuildAuditLogsEntry<null, 'All', 'Unknown'> | undefined>>(
   guild.fetchAuditLogs().then(al => al.entries.first()),
 );
 
-expectType<Promise<null | undefined>>(
-  guild.fetchAuditLogs({ type: 'MemberKick' }).then(al => al.entries.first()?.extra),
-);
 expectType<Promise<null | undefined>>(
   guild.fetchAuditLogs({ type: AuditLogEvent.MemberKick }).then(al => al.entries.first()?.extra),
 );
 expectType<Promise<StageChannel | { id: Snowflake } | undefined>>(
-  guild.fetchAuditLogs({ type: 'StageInstanceCreate' }).then(al => al.entries.first()?.extra),
+  guild.fetchAuditLogs({ type: AuditLogEvent.StageInstanceCreate }).then(al => al.entries.first()?.extra),
 );
 expectType<Promise<{ channel: GuildTextBasedChannel | { id: Snowflake }; count: number } | undefined>>(
-  guild.fetchAuditLogs({ type: 'MessageDelete' }).then(al => al.entries.first()?.extra),
+  guild.fetchAuditLogs({ type: AuditLogEvent.MessageDelete }).then(al => al.entries.first()?.extra),
 );
 
-expectType<Promise<User | null | undefined>>(
-  guild.fetchAuditLogs({ type: 'MemberKick' }).then(al => al.entries.first()?.target),
-);
 expectType<Promise<User | null | undefined>>(
   guild.fetchAuditLogs({ type: AuditLogEvent.MemberKick }).then(al => al.entries.first()?.target),
 );
 expectType<Promise<StageInstance | undefined>>(
-  guild.fetchAuditLogs({ type: 'StageInstanceCreate' }).then(al => al.entries.first()?.target),
+  guild.fetchAuditLogs({ type: AuditLogEvent.StageInstanceCreate }).then(al => al.entries.first()?.target),
 );
 expectType<Promise<User | undefined>>(
-  guild.fetchAuditLogs({ type: 'MessageDelete' }).then(al => al.entries.first()?.target),
+  guild.fetchAuditLogs({ type: AuditLogEvent.MessageDelete }).then(al => al.entries.first()?.target),
-);
-
-expectType<Promise<User | undefined>>(
-  // @ts-expect-error Invalid audit log ID
-  guild.fetchAuditLogs({ type: 2000 }).then(al => al.entries.first()?.target),
 );
 
 declare const TextBasedChannel: TextBasedChannel;