disgroove 1.3.1 → 1.3.3-dev.1

package/lib/structures/Sticker.ts

@@ -0,0 +1,100 @@
+import { Base, User } from ".";
+import type { Client } from "../Client";
+import type { StickerFormatTypes, StickerTypes } from "../constants";
+import { Endpoints } from "../rest";
+import type { JSONSticker, RawSticker } from "../types";
+
+/** https://discord.com/developers/docs/resources/sticker */
+export class Sticker extends Base {
+  protected override raw: RawSticker;
+  packId?: string;
+  name: string;
+  description: string | null;
+  tags: string;
+  asset?: string;
+  type: StickerTypes;
+  formatType: StickerFormatTypes;
+  available?: boolean;
+  guildId?: string;
+  user?: User;
+  sortValue?: number;
+
+  constructor(data: RawSticker, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.name = data.name;
+    this.description = data.description;
+    this.tags = data.tags;
+    this.type = data.type;
+    this.formatType = data.format_type;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: RawSticker) {
+    if (data.pack_id !== undefined) this.packId = data.pack_id;
+    if (data.asset != undefined) this.asset = data.asset;
+    if (data.available !== undefined) this.available = data.available;
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+    if (data.user !== undefined) this.user = new User(data.user, this.client);
+    if (data.sort_value !== undefined) this.sortValue = data.sort_value;
+  }
+
+  /** https://discord.com/developers/docs/resources/sticker#delete-guild-sticker */
+  delete(reason?: string): void {
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.delete(Endpoints.guildSticker(this.guildId, this.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/sticker#modify-guild-sticker */
+  async edit(
+    options: {
+      name?: string;
+      description?: string | null;
+      tags?: string;
+    },
+    reason?: string
+  ): Promise<Sticker> {
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    return new Sticker(
+      await this.client.rest.patch<RawSticker>(
+        Endpoints.guildSticker(this.guildId, this.id),
+        {
+          json: {
+            name: options.name,
+            description: options.description,
+            tags: options.tags,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  override toRaw(): RawSticker {
+    return this.raw;
+  }
+
+  override toJSON(): JSONSticker {
+    return {
+      ...super.toJSON(),
+      packId: this.packId,
+      name: this.name,
+      description: this.description,
+      tags: this.tags,
+      asset: this.asset,
+      type: this.type,
+      formatType: this.formatType,
+      available: this.available,
+      guildId: this.guildId,
+      user: this.user?.toJSON(),
+      sortValue: this.sortValue,
+    };
+  }
+}

package/lib/structures/Team.ts

@@ -0,0 +1,41 @@
+import { Base, User } from ".";
+import type { Client } from "../Client";
+import type { JSONTeam, JSONTeamMember, RawTeam } from "../types";
+
+/** https://discord.com/developers/docs/topics/teams */
+export class Team extends Base {
+  protected override raw: RawTeam;
+  icon: string | null;
+  members: Array<JSONTeamMember>;
+  name: string;
+  ownerUserId: string;
+
+  constructor(data: RawTeam, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.icon = data.icon;
+    this.members = data.members.map((teamMember) => ({
+      membershipState: teamMember.membership_state,
+      teamId: teamMember.team_id,
+      user: new User(teamMember.user, client).toJSON(),
+      role: teamMember.role,
+    }));
+    this.name = data.name;
+    this.ownerUserId = data.owner_user_id;
+  }
+
+  override toRaw(): RawTeam {
+    return this.raw;
+  }
+
+  override toJSON(): JSONTeam {
+    return {
+      icon: this.icon,
+      ...super.toJSON(),
+      members: this.members,
+      name: this.name,
+      ownerUserId: this.ownerUserId,
+    };
+  }
+}

package/lib/structures/TestEntitlement.ts

@@ -0,0 +1,78 @@
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type { JSONEntitlement, RawEntitlement } from "../types";
+import { Base } from ".";
+import type { EntitlementTypes } from "../constants";
+
+/** https://discord.com/developers/docs/monetization/entitlements */
+export class TestEntitlement extends Base {
+  protected override raw: Omit<
+    RawEntitlement,
+    "starts_at" | "ends_at" | "subscription_id"
+  >;
+  skuId: string;
+  applicationId: string;
+  userId?: string;
+  promotionId?: string | null; // Undocumented
+  type: EntitlementTypes;
+  deleted: boolean;
+  giftCodeFlags?: number; // Undocumented
+  consumed?: boolean; // Undocumented
+  guildId?: string;
+
+  constructor(
+    data: Omit<RawEntitlement, "starts_at" | "ends_at" | "subscription_id">,
+    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: Omit<RawEntitlement, "starts_at" | "ends_at" | "subscription_id">
+  ): 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.guild_id !== undefined) this.guildId = data.guild_id;
+  }
+
+  /** https://discord.com/developers/docs/monetization/entitlements */
+  delete(): void {
+    this.client.rest.delete(
+      Endpoints.applicationEntitlement(this.applicationId, this.id)
+    );
+  }
+
+  override toRaw(): Omit<
+    RawEntitlement,
+    "starts_at" | "ends_at" | "subscription_id"
+  > {
+    return this.raw;
+  }
+
+  override toJSON(): Omit<
+    JSONEntitlement,
+    "startsAt" | "endsAt" | "subscriptionId"
+  > {
+    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,
+      guildId: this.guildId,
+    };
+  }
+}

package/lib/structures/UnavailableGuild.ts

@@ -0,0 +1,27 @@
+import { Base } from ".";
+import type { Client } from "../Client";
+import type { RawUnavailableGuild, JSONUnavailableGuild } from "../types";
+
+/** https://discord.com/developers/docs/resources/guild */
+export class UnavailableGuild extends Base {
+  protected override raw: RawUnavailableGuild;
+  unavailable: boolean;
+
+  constructor(data: RawUnavailableGuild, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.unavailable = data.unavailable;
+  }
+
+  override toRaw(): RawUnavailableGuild {
+    return this.raw;
+  }
+
+  override toJSON(): JSONUnavailableGuild {
+    return {
+      ...super.toJSON(),
+      unavailable: this.unavailable,
+    };
+  }
+}

package/lib/structures/User.ts

@@ -0,0 +1,233 @@
+import { Base, Channel, GuildMember, Integration } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONApplicationRoleConnection,
+  JSONConnection,
+  JSONUser,
+  RawApplicationRoleConnection,
+  RawChannel,
+  RawConnection,
+  RawGuildMember,
+  RawUser,
+} from "../types";
+import type {
+  ApplicationRoleConnectionMetadataType,
+  Locale,
+  PremiumTypes,
+  UserFlags,
+} from "../constants";
+
+/** https://discord.com/developers/docs/resources/user */
+export class User extends Base {
+  protected override raw: RawUser;
+  username: string;
+  discriminator: string;
+  avatar: string;
+  globalName: string | null;
+  bot?: boolean;
+  system?: boolean;
+  mfaEnabled?: boolean;
+  banner?: string;
+  accentColor?: number;
+  locale?: string;
+  verified?: boolean;
+  email?: string;
+  flags?: UserFlags;
+  premiumType?: PremiumTypes;
+  publicFlags?: UserFlags;
+  avatarDecoration?: string | null;
+
+  constructor(data: RawUser, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.username = data.username;
+    this.discriminator = data.discriminator;
+    this.globalName = data.global_name;
+    this.avatar = data.avatar;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: RawUser): void {
+    if (data.bot !== undefined) this.bot = data.bot;
+    if (data.system !== undefined) this.system = data.system;
+    if (data.mfa_enabled !== undefined) this.mfaEnabled = data.mfa_enabled;
+    if (data.banner !== undefined) this.banner = data.banner;
+    if (data.accent_color !== undefined) this.accentColor = data.accent_color;
+    if (data.locale !== undefined) this.locale = data.locale;
+    if (data.verified !== undefined) this.verified = data.verified;
+    if (data.email !== undefined) this.email = data.email;
+    if (data.flags !== undefined) this.flags = data.flags;
+    if (data.premium_type !== undefined) this.premiumType = data.premium_type;
+    if (data.public_flags !== undefined) this.publicFlags = data.public_flags;
+    if (data.avatar_decoration !== undefined)
+      this.avatarDecoration = data.avatar_decoration;
+  }
+
+  /** https://discord.com/developers/docs/resources/user#create-dm */
+  async createDM(options: { recipientId: string }): Promise<Channel> {
+    return new Channel(
+      await this.client.rest.post<RawChannel>(Endpoints.userChannels(), {
+        json: {
+          recipient_id: options.recipientId,
+        },
+      }),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#create-group-dm */
+  async createGroupDM(options: {
+    accessTokens: Array<string>;
+    nicks: Array<string>;
+  }): Promise<Channel> {
+    return new Channel(
+      await this.client.rest.post<RawChannel>(Endpoints.userChannels(), {
+        json: {
+          access_tokens: options.accessTokens,
+          nicks: options.nicks,
+        },
+      }),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#modify-current-user */
+  async edit(options: {
+    username?: string;
+    avatar?: string | null;
+  }): Promise<User> {
+    return new User(
+      await this.client.rest.patch<RawUser>(Endpoints.user(), {
+        json: {
+          username: options.username,
+          avatar: options.avatar,
+        },
+      }),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#get-user-application-role-connection */
+  async getApplicationRoleConnection(): Promise<JSONApplicationRoleConnection> {
+    return this.client.rest
+      .get<RawApplicationRoleConnection>(
+        Endpoints.userApplicationRoleConnection(this.client.application.id)
+      )
+      .then((response) => ({
+        platformName: response.platform_name,
+        platformUsername: response.platform_username,
+        metadata: {
+          type: response.metadata.type,
+          key: response.metadata.key,
+          name: response.metadata.name,
+          nameLocalizations: response.metadata.name_localizations,
+          description: response.metadata.description,
+          descriptionLocalizations: response.metadata.description_localizations,
+        },
+      }));
+  }
+
+  /** https://discord.com/developers/docs/resources/user#get-user-connections */
+  async getConnections(): Promise<Array<JSONConnection>> {
+    return this.client.rest
+      .get<Array<RawConnection>>(Endpoints.userConnections())
+      .then((response) =>
+        response.map((data) => ({
+          id: data.id,
+          name: data.name,
+          type: data.type,
+          revoked: data.revoked,
+          integrations: data.integrations?.map((integration) =>
+            new Integration(integration, this.client).toJSON()
+          ),
+          verified: data.verified,
+          friendSync: data.friend_sync,
+          showActivity: data.show_activity,
+          twoWayLink: data.two_way_link,
+          visibility: data.visibility,
+        }))
+      );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#get-current-user-guild-member */
+  async getGuildMember(guildId: string): Promise<GuildMember> {
+    return new GuildMember(
+      await this.client.rest.get<RawGuildMember>(
+        Endpoints.guildMember(guildId)
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#leave-guild */
+  leaveGuild(guildId: string): void {
+    this.client.rest.delete(Endpoints.userGuild(guildId));
+  }
+
+  /** https://discord.com/developers/docs/resources/user#update-user-application-role-connection */
+  async updateApplicationRoleConnection(options: {
+    platformName?: string;
+    platformUsername?: string;
+    metadata?: {
+      type: ApplicationRoleConnectionMetadataType;
+      key: string;
+      name: string;
+      nameLocalizations?: Partial<Record<Locale, string>> | null;
+      description: string;
+      descriptionLocalizations?: Partial<Record<Locale, string>> | null;
+    };
+  }): Promise<JSONApplicationRoleConnection> {
+    return this.client.rest
+      .put<RawApplicationRoleConnection>(
+        Endpoints.userApplicationRoleConnection(this.client.application.id),
+        {
+          json: {
+            platform_name: options.platformName,
+            platform_username: options.platformUsername,
+            metadata: options.metadata,
+          },
+        }
+      )
+      .then((response) => ({
+        platformName: response.platform_name,
+        platformUsername: response.platform_username,
+        metadata: {
+          type: response.metadata.type,
+          key: response.metadata.key,
+          name: response.metadata.name,
+          nameLocalizations: response.metadata.name_localizations,
+          description: response.metadata.description,
+          descriptionLocalizations: response.metadata.description_localizations,
+        },
+      }));
+  }
+
+  override toRaw(): RawUser {
+    return this.raw;
+  }
+
+  override toJSON(): JSONUser {
+    return {
+      ...super.toJSON(),
+      username: this.username,
+      discriminator: this.discriminator,
+      globalName: this.globalName,
+      avatar: this.avatar,
+      bot: this.bot,
+      system: this.system,
+      mfaEnabled: this.mfaEnabled,
+      banner: this.banner,
+      accentColor: this.accentColor,
+      locale: this.locale,
+      verified: this.verified,
+      email: this.email,
+      flags: this.flags,
+      premiumType: this.premiumType,
+      publicFlags: this.publicFlags,
+      avatarDecoration: this.avatarDecoration,
+    };
+  }
+}

package/lib/structures/VoiceState.ts

@@ -0,0 +1,72 @@
+import { GuildMember } from ".";
+import type { Client } from "../Client";
+import type { JSONVoiceState, RawVoiceState } from "../types";
+
+/** https://discord.com/developers/docs/resources/voice */
+export class VoiceState {
+  private client: Client;
+  private raw: RawVoiceState;
+  guildId?: string;
+  channelId: string | null;
+  userId: string;
+  member?: GuildMember;
+  sessionId: string;
+  deaf: boolean;
+  mute: boolean;
+  selfDeaf: boolean;
+  selfMute: boolean;
+  selfStream?: boolean;
+  selfVideo: boolean;
+  suppress: boolean;
+  requestToSpeakTimestamp: string | null;
+
+  constructor(data: RawVoiceState, client: Client) {
+    this.client = client;
+    this.raw = data;
+    this.channelId = data.channel_id;
+    this.userId = data.user_id;
+    this.sessionId = data.session_id;
+    this.deaf = data.deaf;
+    this.mute = data.mute;
+    this.selfDeaf = data.self_deaf;
+    this.selfMute = data.self_mute;
+    this.selfVideo = data.self_video;
+    this.suppress = data.suppress;
+    this.requestToSpeakTimestamp = data.request_to_speak_timestamp;
+
+    this.patch(data);
+  }
+
+  private patch(data: RawVoiceState) {
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+    if (data.member !== undefined)
+      this.member = new GuildMember(data.member, this.client);
+    if (data.self_stream !== undefined) this.selfStream = data.self_stream;
+  }
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): RawVoiceState {
+    return this.raw;
+  }
+
+  toJSON(): JSONVoiceState {
+    return {
+      guildId: this.guildId,
+      channelId: this.channelId,
+      userId: this.userId,
+      member: this.member?.toJSON(),
+      sessionId: this.sessionId,
+      deaf: this.deaf,
+      mute: this.mute,
+      selfDeaf: this.selfDeaf,
+      selfMute: this.selfMute,
+      selfStream: this.selfStream,
+      selfVideo: this.selfVideo,
+      suppress: this.suppress,
+      requestToSpeakTimestamp: this.requestToSpeakTimestamp,
+    };
+  }
+}