disgroove 1.3.1 → 1.3.3-dev.1

package/lib/structures/ClientApplication.ts

@@ -0,0 +1,515 @@
+import {
+  Base,
+  ApplicationCommand,
+  Application,
+  SKU,
+  Entitlement,
+  TestEntitlement,
+} from ".";
+import type {
+  JSONGuildApplicationCommandPermissions,
+  RawApplication,
+  RawGuildApplicationCommandPermissions,
+  RawApplicationCommand,
+  JSONApplication,
+  JSONApplicationRoleConnectionMetadata,
+  RawApplicationRoleConnectionMetadata,
+  RawEntitlement,
+  RawSKU,
+  JSONInstallParams,
+  JSONApplicationCommandOption,
+} from "../types";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  ApplicationCommandTypes,
+  ApplicationFlags,
+  Locale,
+} from "../constants";
+
+export class ClientApplication extends Base {
+  protected override raw: Pick<RawApplication, "id" | "flags">;
+  flags?: ApplicationFlags;
+
+  constructor(data: Pick<RawApplication, "id" | "flags">, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: Pick<RawApplication, "id" | "flags">) {
+    if (data.flags !== undefined) this.flags = data.flags;
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#create-global-application-command */
+  async createGlobalApplicationCommand(options: {
+    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;
+    type?: ApplicationCommandTypes;
+    nsfw?: boolean;
+  }): Promise<ApplicationCommand> {
+    return new ApplicationCommand(
+      await this.client.rest.post<RawApplicationCommand>(
+        Endpoints.applicationCommands(this.id),
+        {
+          json: this.client.util.applicationCommandToRaw(options),
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#create-guild-application-command */
+  async createGuildApplicationCommand(
+    guildId: string,
+    options: {
+      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;
+      type?: ApplicationCommandTypes;
+      nsfw?: boolean;
+    }
+  ): Promise<ApplicationCommand> {
+    return new ApplicationCommand(
+      await this.client.rest.post<RawApplicationCommand>(
+        Endpoints.applicationGuildCommands(this.id, guildId),
+        {
+          json: this.client.util.applicationCommandToRaw(options),
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/monetization/entitlements#create-test-entitlement */
+  async createTestEntitlement(options: {
+    skuId: string;
+    ownerId: string;
+    ownerType: number;
+  }): Promise<TestEntitlement> {
+    return new TestEntitlement(
+      await this.client.rest.post<
+        Omit<RawEntitlement, "starts_at" | "ends_at" | "subscription_id">
+      >(Endpoints.applicationEntitlements(this.id), {
+        json: {
+          sku_id: options.skuId,
+          owner_id: options.ownerId,
+          owner_type: options.ownerType,
+        },
+      }),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#delete-global-application-command */
+  deleteGlobalApplicationCommand(commandId: string): void {
+    this.client.rest.delete(Endpoints.applicationCommand(this.id, commandId));
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#delete-guild-application-command */
+  deleteGuildApplicationCommand(guildId: string, commandId: string): void {
+    this.client.rest.delete(
+      Endpoints.applicationGuildCommand(this.id, guildId, commandId)
+    );
+  }
+
+  /** https://discord.com/developers/docs/monetization/entitlements#delete-test-entitlement */
+  deleteTestEntitlement(entitlementId: string): void {
+    this.client.rest.delete(
+      Endpoints.applicationEntitlement(this.id, entitlementId)
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/application#edit-current-application */
+  async edit(options: {
+    customInstallURL?: string;
+    description?: string;
+    roleConnectionsVerificationURL?: string;
+    installParams?: JSONInstallParams;
+    flags?: ApplicationFlags;
+    icon?: string;
+    coverImage?: string;
+    interactionsEndpointURL?: string;
+    tags?: Array<string>;
+  }): Promise<Application> {
+    return new Application(
+      await this.client.rest.patch<RawApplication>(
+        Endpoints.applicationCurrentUser(),
+        {
+          json: {
+            custom_install_url: options.customInstallURL,
+            description: options.description,
+            role_connections_verification_url:
+              options.roleConnectionsVerificationURL,
+            install_params: options.installParams,
+            flags: options.flags,
+            icon: options.icon,
+            cover_image: options.coverImage,
+            interactions_endpoint_url: options.interactionsEndpointURL,
+            tags: options.tags,
+          },
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#edit-application-command-permissions */
+  async editApplicationCommandPermissions(
+    guildId: string,
+    commandId: string,
+    options: {
+      permissions: Array<JSONGuildApplicationCommandPermissions>;
+    }
+  ): Promise<JSONGuildApplicationCommandPermissions> {
+    return this.client.rest
+      .put<RawGuildApplicationCommandPermissions>(
+        Endpoints.applicationCommandPermissions(this.id, guildId, commandId),
+        {
+          json: {
+            permissions: options.permissions.map((option) => ({
+              id: option.id,
+              application_id: option.applicationId,
+              guild_id: option.guildId,
+              permissions: option.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+              })),
+            })),
+          },
+        }
+      )
+      .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#edit-global-application-command */
+  async editGlobalApplicationCommand(
+    commandId: string,
+    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(
+      await this.client.rest.patch<RawApplicationCommand>(
+        Endpoints.applicationCommand(this.id, commandId),
+        {
+          json: this.client.util.applicationCommandToRaw(options),
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#edit-guild-application-command */
+  async editGuildApplicationCommand(
+    guildId: string,
+    commandId: string,
+    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(
+      await this.client.rest.patch<RawApplicationCommand>(
+        Endpoints.applicationGuildCommand(this.id, guildId, commandId),
+        {
+          json: this.client.util.applicationCommandToRaw(options),
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-application-command-permissions */
+  async getApplicationCommandPermissions(
+    guildId: string,
+    commandId: string
+  ): Promise<Array<JSONGuildApplicationCommandPermissions>> {
+    return this.client.rest
+      .get<Array<RawGuildApplicationCommandPermissions>>(
+        Endpoints.applicationCommandPermissions(this.id, guildId, commandId)
+      )
+      .then((response) =>
+        response.map((permissions: RawGuildApplicationCommandPermissions) => ({
+          id: permissions.id,
+          applicationId: permissions.application_id,
+          guildId: permissions.guild_id,
+          permissions: permissions.permissions.map((permission) => ({
+            id: permission.id,
+            type: permission.type,
+            permission: permission.permission,
+          })),
+        }))
+      );
+  }
+
+  /** https://discord.com/developers/docs/monetization/entitlements#list-entitlements */
+  async getEntitlements(options?: {
+    userId?: string;
+    skuIds?: Array<string>;
+    before?: string;
+    after?: string;
+    limit?: number;
+    guildId?: string;
+    excludeEnded?: boolean;
+  }): Promise<Array<Entitlement>> {
+    return this.client.rest
+      .get<Array<RawEntitlement>>(Endpoints.applicationEntitlements(this.id), {
+        query: {
+          user_id: options?.userId,
+          sku_ids: options?.skuIds,
+          before: options?.before,
+          after: options?.after,
+          limit: options?.limit,
+          guild_id: options?.guildId,
+          exclude_ended: options?.excludeEnded,
+        },
+      })
+      .then((response) =>
+        response.map((data) => new Entitlement(data, this.client))
+      );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-global-application-command */
+  async getGlobalApplicationCommand(
+    commandId: string
+  ): Promise<ApplicationCommand> {
+    return new ApplicationCommand(
+      await this.client.rest.get<RawApplicationCommand>(
+        Endpoints.applicationCommand(this.id, commandId)
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-global-application-commands */
+  async getGlobalApplicationCommands(options: {
+    withLocalizations?: boolean;
+  }): Promise<Array<ApplicationCommand>> {
+    return this.client.rest
+      .get<Array<RawApplicationCommand>>(
+        Endpoints.applicationCommands(this.id),
+        {
+          query: {
+            with_localizations: options.withLocalizations,
+          },
+        }
+      )
+      .then((response) =>
+        response.map((data) => new ApplicationCommand(data, this.client))
+      );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command */
+  async getGuildApplicationCommand(
+    guildId: string,
+    commandId: string
+  ): Promise<ApplicationCommand> {
+    return new ApplicationCommand(
+      await this.client.rest.get<RawApplicationCommand>(
+        Endpoints.applicationGuildCommand(this.id, guildId, commandId)
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-commands */
+  async getGuildApplicationCommands(
+    guildId: string,
+    options?: {
+      withLocalizations?: boolean;
+    }
+  ): Promise<Array<ApplicationCommand>> {
+    return this.client.rest
+      .get<Array<RawApplicationCommand>>(
+        Endpoints.applicationGuildCommands(this.id, guildId),
+        {
+          query: {
+            with_localizations: options?.withLocalizations,
+          },
+        }
+      )
+      .then((response) =>
+        response.map((data) => new ApplicationCommand(data, this.client))
+      );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-guild-application-command-permissions */
+  async getGuildApplicationCommandPermissions(
+    guildId: string
+  ): Promise<Array<JSONGuildApplicationCommandPermissions>> {
+    return this.client.rest
+      .get<Array<RawGuildApplicationCommandPermissions>>(
+        Endpoints.guildApplicationCommandsPermissions(this.id, guildId)
+      )
+      .then((response) =>
+        response.map((permissions: RawGuildApplicationCommandPermissions) => ({
+          id: permissions.id,
+          applicationId: permissions.application_id,
+          guildId: permissions.guild_id,
+          permissions: permissions.permissions.map((permission) => ({
+            id: permission.id,
+            type: permission.type,
+            permission: permission.permission,
+          })),
+        }))
+      );
+  }
+
+  /** https://discord.com/developers/docs/resources/application-role-connection-metadata#get-application-role-connection-metadata-records */
+  async getApplicationRoleConnectionMetadataRecords(): Promise<
+    Array<JSONApplicationRoleConnectionMetadata>
+  > {
+    return this.client.rest
+      .get<Array<RawApplicationRoleConnectionMetadata>>(
+        Endpoints.applicationRoleConnectionMetadata(this.id)
+      )
+      .then((response) =>
+        response.map((data) => ({
+          type: data.type,
+          key: data.key,
+          name: data.name,
+          nameLocalizations: data.name_localizations,
+          description: data.description,
+          descriptionLocalizations: data.description_localizations,
+        }))
+      );
+  }
+
+  /** https://discord.com/developers/docs/monetization/skus#list-skus */
+  async getSKUs(): Promise<Array<SKU>> {
+    return this.client.rest
+      .get<Array<RawSKU>>(Endpoints.applicationSKUs(this.id))
+      .then((response) => response.map((data) => new SKU(data, this.client)));
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-global-application-commands */
+  async setGlobalApplicationCommands(
+    commands: Array<{
+      id?: 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;
+      type?: ApplicationCommandTypes;
+      nsfw?: boolean;
+    }>
+  ): Promise<Array<ApplicationCommand>> {
+    return this.client.rest
+      .put<Array<RawApplicationCommand>>(
+        Endpoints.applicationCommands(this.id),
+        {
+          json: commands.map((command) =>
+            this.client.util.applicationCommandToRaw(command)
+          ),
+        }
+      )
+      .then((response) =>
+        response.map((data) => new ApplicationCommand(data, this.client))
+      );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#bulk-overwrite-guild-application-commands */
+  async setGuildApplicationCommands(
+    guildId: string,
+    commands: Array<{
+      id?: 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;
+      type: ApplicationCommandTypes;
+      nsfw?: boolean;
+    }>
+  ): Promise<Array<ApplicationCommand>> {
+    return this.client.rest
+      .put<Array<RawApplicationCommand>>(
+        Endpoints.applicationGuildCommands(this.id, guildId),
+        {
+          json: commands.map((command) =>
+            this.client.util.applicationCommandToRaw(command)
+          ),
+        }
+      )
+      .then((response) =>
+        response.map((data) => new ApplicationCommand(data, this.client))
+      );
+  }
+
+  /** https://discord.com/developers/docs/resources/application-role-connection-metadata#update-application-role-connection-metadata-records */
+  async updateApplicationRoleConnectionMetadataRecords(): Promise<
+    Array<JSONApplicationRoleConnectionMetadata>
+  > {
+    return this.client.rest
+      .put<Array<RawApplicationRoleConnectionMetadata>>(
+        Endpoints.applicationRoleConnectionMetadata(this.id)
+      )
+      .then((response) =>
+        response.map((data) => ({
+          type: data.type,
+          key: data.key,
+          name: data.name,
+          nameLocalizations: data.name_localizations,
+          description: data.description,
+          descriptionLocalizations: data.description_localizations,
+        }))
+      );
+  }
+
+  override toRaw(): Pick<RawApplication, "id" | "flags"> {
+    return this.raw;
+  }
+
+  override toJSON(): Pick<JSONApplication, "id" | "flags"> {
+    return {
+      ...super.toJSON(),
+      flags: this.flags,
+    };
+  }
+}

package/lib/structures/Emoji.ts

@@ -0,0 +1,95 @@
+import { User } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type { JSONEmoji, RawEmoji } from "../types";
+
+/** https://discord.com/developers/docs/resources/emoji */
+export class Emoji {
+  private client: Client;
+  private raw: RawEmoji;
+  id: string | null;
+  name: string | null;
+  roles?: Array<string>;
+  user?: User;
+  requireColons?: boolean;
+  managed?: boolean;
+  animated?: boolean;
+  available?: boolean;
+
+  constructor(data: RawEmoji, client: Client) {
+    this.client = client;
+    this.raw = data;
+    this.id = data.id;
+    this.name = data.name;
+
+    this.patch(data);
+  }
+
+  private patch(data: RawEmoji) {
+    if (data.roles !== undefined) this.roles = data.roles;
+    if (data.user !== undefined) this.user = new User(data.user, this.client);
+    if (data.require_colons !== undefined)
+      this.requireColons = data.require_colons;
+    if (data.managed !== undefined) this.managed = data.managed;
+    if (data.animated !== undefined) this.animated = data.animated;
+    if (data.available !== undefined) this.available = data.available;
+  }
+
+  /** https://discord.com/developers/docs/resources/emoji#delete-guild-emoji */
+  delete(guildId: string, reason?: string): void {
+    if (!this.id)
+      throw new Error("[disgroove] Cannot delete a default Discord emoji");
+
+    this.client.rest.delete(Endpoints.guildEmoji(guildId, this.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/emoji#modify-guild-emoji */
+  async edit(
+    guildId: string,
+    options: {
+      name?: string;
+      roles?: Array<string> | null;
+    },
+    reason?: string
+  ): Promise<Emoji> {
+    if (!this.id)
+      throw new Error("[disgroove] Cannot edit a default Discord emoji");
+
+    return new Emoji(
+      await this.client.rest.patch<RawEmoji>(
+        Endpoints.guildEmoji(guildId, this.id),
+        {
+          json: {
+            name: options.name,
+            roles: options.roles,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): RawEmoji {
+    return this.raw;
+  }
+
+  toJSON(): JSONEmoji {
+    return {
+      id: this.id,
+      name: this.name,
+      roles: this.roles,
+      user: this.user?.toJSON(),
+      requireColons: this.requireColons,
+      managed: this.managed,
+      animated: this.animated,
+      available: this.available,
+    };
+  }
+}

package/lib/structures/Entitlement.ts

@@ -0,0 +1,65 @@
+import type { Client } from "../Client";
+import type { JSONEntitlement, RawEntitlement } from "../types";
+import { Base } from ".";
+import type { EntitlementTypes } from "../constants";
+
+/** https://discord.com/developers/docs/monetization/entitlements */
+export class Entitlement extends Base {
+  protected override raw: RawEntitlement;
+  skuId: string;
+  applicationId: string;
+  userId?: string;
+  promotionId?: string | null; // Undocumented
+  type: EntitlementTypes;
+  deleted: boolean;
+  giftCodeFlags?: number; // Undocumented
+  consumed?: boolean; // Undocumented
+  startsAt?: string;
+  endsAt?: string;
+  guildId?: string;
+  subscriptionId?: string; // Undocumented
+
+  constructor(data: RawEntitlement, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.skuId = data.sku_id;
+    this.applicationId = data.application_id;
+    this.type = data.type;
+    this.deleted = data.deleted;
+  }
+
+  protected override patch(data: RawEntitlement): void {
+    if (data.user_id !== undefined) this.userId = data.user_id;
+    if (data.promotion_id !== undefined) this.promotionId = data.promotion_id;
+    if (data.gift_code_flags !== undefined)
+      this.giftCodeFlags = data.gift_code_flags;
+    if (data.consumed !== undefined) this.consumed = data.consumed;
+    if (data.starts_at !== undefined) this.startsAt = data.starts_at;
+    if (data.ends_at !== undefined) this.endsAt = data.ends_at;
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+    if (data.subscription_id !== undefined) this.subscriptionId;
+  }
+
+  override toRaw(): RawEntitlement {
+    return this.raw;
+  }
+
+  override toJSON(): JSONEntitlement {
+    return {
+      id: this.id,
+      skuId: this.skuId,
+      applicationId: this.applicationId,
+      userId: this.userId,
+      promotionId: this.promotionId,
+      type: this.type,
+      deleted: this.deleted,
+      giftCodeFlags: this.giftCodeFlags,
+      consumed: this.consumed,
+      startsAt: this.startsAt,
+      endsAt: this.endsAt,
+      guildId: this.guildId,
+      subscriptionId: this.subscriptionId,
+    };
+  }
+}