disgroove 1.3.3-dev.2 → 1.3.3-dev.3

package/lib/structures/ApplicationCommand.ts

@@ -1,187 +0,0 @@
-import type { Client } from "../Client";
-import { Endpoints } from "../rest";
-import type {
-  JSONApplicationCommand,
-  JSONApplicationCommandOption,
-  JSONApplicationCommandPermission,
-  JSONGuildApplicationCommandPermissions,
-  RawApplicationCommand,
-  RawGuildApplicationCommandPermissions,
-} from "../types";
-import type { ApplicationCommandTypes, Locale } from "../constants";
-import { Base } from ".";
-
-/** https://discord.com/developers/docs/interactions/application-commands */
-export class ApplicationCommand extends Base {
-  protected override raw: RawApplicationCommand;
-  type?: ApplicationCommandTypes;
-  applicationId: string;
-  guildId?: string;
-  name: string;
-  nameLocalizations?: Partial<Record<Locale, string>> | null;
-  description: string;
-  descriptionLocalizations?: Partial<Record<Locale, string>> | null;
-  options?: Array<JSONApplicationCommandOption>;
-  defaultMemberPermissions: string | null;
-  dmPermission?: boolean;
-  defaultPermission?: boolean | null;
-  nsfw?: boolean;
-  version: string;
-
-  constructor(data: RawApplicationCommand, client: Client) {
-    super(data.id, client);
-
-    this.raw = data;
-    this.applicationId = data.application_id;
-    this.name = data.name;
-    this.description = data.description;
-    this.defaultMemberPermissions = data.default_member_permissions;
-    this.version = data.version;
-
-    this.patch(data);
-  }
-
-  protected override patch(data: RawApplicationCommand): void {
-    if (data.type !== undefined) this.type = data.type;
-    if (data.guild_id !== undefined) this.guildId = data.guild_id;
-    if (data.name_localizations !== undefined)
-      this.nameLocalizations = data.name_localizations;
-    if (data.description_localizations !== undefined)
-      this.descriptionLocalizations = data.description_localizations;
-    if (data.options !== undefined) this.options = data.options;
-    if (data.dm_permission !== undefined)
-      this.dmPermission = data.dm_permission;
-    if (data.default_permission !== undefined)
-      this.defaultPermission = data.default_permission;
-    if (data.nsfw !== undefined) this.nsfw = data.nsfw;
-  }
-
-  /** https://discord.com/developers/docs/interactions/application-commands#delete-guild-application-command */
-  delete(): void {
-    this.guildId !== undefined
-      ? this.client.rest.delete(
-          Endpoints.applicationGuildCommand(
-            this.applicationId,
-            this.guildId,
-            this.id
-          )
-        )
-      : this.client.rest.delete(
-          Endpoints.applicationCommand(this.applicationId, this.id)
-        );
-  }
-
-  /** https://discord.com/developers/docs/interactions/application-commands#edit-global-application-command */
-  async edit(options: {
-    name?: string;
-    nameLocalizations?: Partial<Record<Locale, string>> | null;
-    description?: string;
-    descriptionLocalizations?: Partial<Record<Locale, string>> | null;
-    options?: Array<JSONApplicationCommandOption>;
-    defaultMemberPermissions?: string | null;
-    defaultPermission?: boolean | null;
-    dmPermission?: boolean;
-    nsfw?: boolean;
-  }): Promise<ApplicationCommand> {
-    return new ApplicationCommand(
-      this.guildId !== undefined
-        ? await this.client.rest.patch<RawApplicationCommand>(
-            Endpoints.applicationGuildCommand(this.id, this.guildId, this.id),
-            {
-              json: this.client.util.applicationCommandToRaw(options),
-            }
-          )
-        : await this.client.rest.patch<RawApplicationCommand>(
-            Endpoints.applicationCommand(this.applicationId, this.id),
-            {
-              json: this.client.util.applicationCommandToRaw(options),
-            }
-          ),
-      this.client
-    );
-  }
-
-  /** https://discord.com/developers/docs/interactions/application-commands#edit-application-command-permissions */
-  async editPermissions(options: {
-    permissions: Array<JSONApplicationCommandPermission>;
-  }): Promise<JSONGuildApplicationCommandPermissions> {
-    if (!this.guildId)
-      throw new Error(
-        "[disgroove] Cannot edit the permissions of a global application command"
-      );
-
-    return this.client.rest
-      .put<RawGuildApplicationCommandPermissions>(
-        Endpoints.applicationCommandPermissions(
-          this.applicationId,
-          this.guildId,
-          this.id
-        ),
-        {
-          json: {
-            permissions: options.permissions,
-          },
-        }
-      )
-      .then((response) => ({
-        id: response.id,
-        applicationId: response.application_id,
-        guildId: response.guild_id,
-        permissions: response.permissions.map((permission) => ({
-          id: permission.id,
-          type: permission.type,
-          permission: permission.permission,
-        })),
-      }));
-  }
-
-  /** https://discord.com/developers/docs/interactions/application-commands#get-application-command-permissions */
-  async getPermissions(): Promise<JSONGuildApplicationCommandPermissions> {
-    if (!this.guildId)
-      throw new Error(
-        "[disgroove] Cannot get the permissions of a global application command"
-      );
-
-    return this.client.rest
-      .get<RawGuildApplicationCommandPermissions>(
-        Endpoints.applicationCommandPermissions(
-          this.applicationId,
-          this.guildId,
-          this.id
-        )
-      )
-      .then((response) => ({
-        id: response.id,
-        applicationId: response.application_id,
-        guildId: response.guild_id,
-        permissions: response.permissions.map((permission) => ({
-          id: permission.id,
-          type: permission.type,
-          permission: permission.permission,
-        })),
-      }));
-  }
-
-  override toRaw(): RawApplicationCommand {
-    return this.raw;
-  }
-
-  override toJSON(): JSONApplicationCommand {
-    return {
-      ...super.toJSON(),
-      type: this.type,
-      applicationId: this.applicationId,
-      guildId: this.guildId,
-      name: this.name,
-      nameLocalizations: this.nameLocalizations,
-      description: this.description,
-      descriptionLocalizations: this.descriptionLocalizations,
-      options: this.options,
-      defaultMemberPermissions: this.defaultMemberPermissions,
-      dmPermission: this.dmPermission,
-      defaultPermission: this.defaultPermission,
-      nsfw: this.nsfw,
-      version: this.version,
-    };
-  }
-}

package/lib/structures/AuditLog.ts

@@ -1,112 +0,0 @@
-import {
-  ApplicationCommand,
-  AutoModerationRule,
-  Channel,
-  GuildScheduledEvent,
-  Integration,
-  User,
-  Webhook,
-} from ".";
-import type { Client } from "../Client";
-import type { JSONAuditLog, JSONAuditLogEntry, RawAuditLog } from "../types";
-
-/** https://discord.com/developers/docs/resources/audit-log */
-export class AuditLog {
-  private client: Client;
-  private raw: RawAuditLog;
-  applicationCommands: Array<ApplicationCommand>;
-  auditLogEntries: Array<JSONAuditLogEntry>;
-  autoModerationRules: Array<AutoModerationRule>;
-  guildScheduledEvents: Array<GuildScheduledEvent>;
-  integrations: Array<Integration>;
-  threads: Array<Channel>;
-  users: Array<User>;
-  webhooks: Array<Webhook>;
-
-  constructor(data: RawAuditLog, client: Client) {
-    this.client = client;
-    this.raw = data;
-    this.applicationCommands = data.application_commands.map(
-      (applicationCommand) =>
-        new ApplicationCommand(applicationCommand, this.client)
-    );
-    this.auditLogEntries = data.audit_log_entries.map((auditLogEntry) => ({
-      targetId: auditLogEntry.target_id,
-      changes: auditLogEntry.changes?.map((change) => ({
-        newValue: change.new_value,
-        oldValue: change.old_value,
-        key: change.key,
-      })),
-      userId: auditLogEntry.user_id,
-      id: auditLogEntry.id,
-      actionType: auditLogEntry.action_type,
-      options:
-        auditLogEntry.options !== undefined
-          ? {
-              applicationId: auditLogEntry.options.application_id,
-              autoModerationRuleName:
-                auditLogEntry.options.auto_moderation_rule_name,
-              autoModerationRuleTriggerType:
-                auditLogEntry.options.auto_moderation_rule_trigger_type,
-              channelId: auditLogEntry.options.channel_id,
-              count: auditLogEntry.options.count,
-              deleteMemberDays: auditLogEntry.options.delete_member_days,
-              id: auditLogEntry.options.id,
-              membersRemoved: auditLogEntry.options.members_removed,
-              messageId: auditLogEntry.options.message_id,
-              roleName: auditLogEntry.options.role_name,
-              type: auditLogEntry.options.type,
-              integrationType: auditLogEntry.options.integration_type,
-            }
-          : undefined,
-      reason: auditLogEntry.reason,
-    }));
-    this.autoModerationRules = data.auto_moderation_rules.map(
-      (autoModerationRule) =>
-        new AutoModerationRule(autoModerationRule, this.client)
-    );
-    this.guildScheduledEvents = data.guild_scheduled_events.map(
-      (guildScheduledEvent) =>
-        new GuildScheduledEvent(guildScheduledEvent, this.client)
-    );
-    this.integrations = data.integrations.map(
-      (integration) => new Integration(integration, this.client)
-    );
-    this.threads = data.threads.map(
-      (thread) => new Channel(thread, this.client)
-    );
-    this.users = data.users.map((user) => new User(user, this.client));
-    this.webhooks = data.webhooks.map(
-      (webhook) => new Webhook(webhook, this.client)
-    );
-  }
-
-  toString(): string {
-    return `[${this.constructor.name}]`;
-  }
-
-  toRaw(): RawAuditLog {
-    return this.raw;
-  }
-
-  toJSON(): JSONAuditLog {
-    return {
-      applicationCommands: this.applicationCommands.map((applicationCommand) =>
-        applicationCommand.toJSON()
-      ),
-      auditLogEntries: this.auditLogEntries,
-      autoModerationRules: this.autoModerationRules.map((autoModerationRule) =>
-        autoModerationRule.toJSON()
-      ),
-      guildScheduledEvents: this.guildScheduledEvents.map(
-        (guildScheduledEvent) => guildScheduledEvent.toJSON()
-      ),
-      integrations: this.integrations.map((integration) =>
-        integration.toJSON()
-      ),
-      threads: this.threads.map((thread) => thread.toJSON()),
-      users: this.users.map((user) => user.toJSON()),
-      webhooks: this.webhooks.map((webhook) => webhook.toJSON()),
-    };
-  }
-}

package/lib/structures/AutoModerationRule.ts

@@ -1,127 +0,0 @@
-import type { Client } from "../Client";
-import { Endpoints } from "../rest";
-import type {
-  JSONAutoModerationAction,
-  JSONAutoModerationRule,
-  JSONTriggerMetadata,
-  RawAutoModerationRule,
-} from "../types";
-import { Base } from ".";
-import type { EventTypes, TriggerTypes } from "../constants";
-
-/** https://discord.com/developers/docs/resources/auto-moderation */
-export class AutoModerationRule extends Base {
-  protected override raw: RawAutoModerationRule;
-  guildId: string;
-  name: string;
-  creatorId: string;
-  eventType: EventTypes;
-  triggerType: TriggerTypes;
-  triggerMetadata: JSONTriggerMetadata;
-  actions: Array<JSONAutoModerationAction>;
-  enabled: boolean;
-  exemptRoles: Array<string>;
-  exemptChannels: Array<string>;
-
-  constructor(data: RawAutoModerationRule, client: Client) {
-    super(data.id, client);
-
-    this.raw = data;
-    this.guildId = data.guild_id;
-    this.name = data.name;
-    this.creatorId = data.creator_id;
-    this.eventType = data.event_type;
-    this.triggerType = data.trigger_type;
-    this.triggerMetadata = {
-      keywordFilter: data.trigger_metadata.keyword_filter,
-      regexPatterns: data.trigger_metadata.regex_patterns,
-      presets: data.trigger_metadata.presets,
-      allowList: data.trigger_metadata.allow_list,
-      mentionTotalLimit: data.trigger_metadata.mention_total_limit,
-      mentionRaidProtection: data.trigger_metadata.mention_raid_protection,
-    };
-    this.actions = data.actions.map((action) => ({
-      type: action.type,
-      metadata: {
-        channelId: action.metadata.channel_id,
-        durationSeconds: action.metadata.duration_seconds,
-        customMessage: action.metadata.custom_message,
-      },
-    }));
-    this.enabled = data.enabled;
-    this.exemptRoles = data.exempt_roles;
-    this.exemptChannels = data.exempt_channels;
-  }
-
-  /** https://discord.com/developers/docs/resources/auto-moderation#delete-auto-moderation-rule */
-  delete(reason?: string): void {
-    this.client.rest.delete(
-      Endpoints.guildAutoModerationRule(this.guildId, this.id),
-      {
-        reason,
-      }
-    );
-  }
-
-  /** https://discord.com/developers/docs/resources/auto-moderation#modify-auto-moderation-rule */
-  async edit(
-    options: {
-      name?: string;
-      eventType?: EventTypes;
-      triggerType?: TriggerTypes;
-      triggerMetadata?: JSONTriggerMetadata;
-      actions?: Array<JSONAutoModerationAction>;
-      enabled?: boolean;
-      exemptRoles?: Array<string>;
-      exemptChannels?: Array<string>;
-    },
-    reason?: string
-  ): Promise<AutoModerationRule> {
-    return new AutoModerationRule(
-      await this.client.rest.patch<RawAutoModerationRule>(
-        Endpoints.guildAutoModerationRule(this.guildId, this.id),
-        {
-          json: {
-            name: options.name,
-            event_type: options.eventType,
-            trigger_type: options.triggerType,
-            trigger_metadata: options.triggerMetadata,
-            actions: options.actions?.map((action) => ({
-              type: action.type,
-              metadata: {
-                channelId: action.metadata.channelId,
-                durationSeconds: action.metadata.durationSeconds,
-                customMessage: action.metadata.customMessage,
-              },
-            })),
-            enabled: options.enabled,
-            exempt_roles: options.exemptRoles,
-            exempt_channels: options.exemptChannels,
-          },
-          reason,
-        }
-      ),
-      this.client
-    );
-  }
-
-  override toRaw(): RawAutoModerationRule {
-    return this.raw;
-  }
-
-  override toJSON(): JSONAutoModerationRule {
-    return {
-      ...super.toJSON(),
-      guildId: this.guildId,
-      name: this.name,
-      creatorId: this.creatorId,
-      eventType: this.eventType,
-      triggerType: this.triggerType,
-      triggerMetadata: this.triggerMetadata,
-      actions: this.actions,
-      enabled: this.enabled,
-      exemptRoles: this.exemptRoles,
-      exemptChannels: this.exemptChannels,
-    };
-  }
-}

package/lib/structures/Base.ts

@@ -1,39 +0,0 @@
-import type { Client } from "../Client";
-
-export abstract class Base {
-  protected client: Client;
-  protected raw: {
-    id: string;
-  };
-  id: string;
-
-  constructor(id: string, client: Client) {
-    this.client = client;
-    this.raw = {
-      id,
-    };
-    this.id = id;
-  }
-
-  protected patch(data: unknown): void {}
-
-  toString(): string {
-    return `[${this.constructor.name}]`;
-  }
-
-  toRaw(): {
-    id: string;
-  } {
-    return {
-      id: this.id,
-    };
-  }
-
-  toJSON(): {
-    id: string;
-  } {
-    return {
-      id: this.id,
-    };
-  }
-}