disgroove 1.3.1 → 1.3.3-dev.1

package/lib/structures/GuildMember.ts

@@ -0,0 +1,193 @@
+import { User } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONGuildMember,
+  JSONGuildMemberAddEventExtraFields,
+  RawGuildMember,
+  RawGuildMemberAddEventExtraFields,
+} from "../types";
+import type { GuildMemberFlags } from "../constants";
+
+/** https://discord.com/developers/docs/resources/guild */
+export class GuildMember {
+  private client: Client;
+  private raw: RawGuildMember & Partial<RawGuildMemberAddEventExtraFields>;
+  user?: User;
+  nick?: string | null;
+  avatar?: string | null;
+  roles: Array<string>;
+  joinedAt: string;
+  premiumSince?: number | null;
+  deaf: boolean;
+  mute: boolean;
+  flags: GuildMemberFlags;
+  pending?: boolean;
+  permissions?: string;
+  communicationDisabledUntil?: number | null;
+  guildId?: string;
+
+  constructor(
+    data: RawGuildMember & Partial<RawGuildMemberAddEventExtraFields>,
+    client: Client
+  ) {
+    this.client = client;
+    this.raw = data;
+    this.roles = data.roles;
+    this.joinedAt = data.joined_at;
+    this.deaf = data.deaf;
+    this.mute = data.mute;
+    this.flags = data.flags;
+
+    this.patch(data);
+  }
+
+  private patch(
+    data: RawGuildMember & Partial<RawGuildMemberAddEventExtraFields>
+  ): void {
+    if (data.user !== undefined) this.user = new User(data.user, this.client);
+    if (data.nick !== undefined) this.nick = data.nick;
+    if (data.avatar !== undefined) this.avatar = data.avatar;
+    if (data.premium_since !== undefined)
+      this.premiumSince = data.premium_since;
+    if (data.pending !== undefined) this.pending = data.pending;
+    if (data.permissions !== undefined) this.permissions = data.permissions;
+    if (data.communication_disabled_until !== undefined)
+      this.communicationDisabledUntil = data.communication_disabled_until;
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#add-guild-member-role */
+  addRole(roleId: string, reason?: string): void {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.put(
+      Endpoints.guildMemberRole(this.guildId, this.user.id, roleId),
+      {
+        reason,
+      }
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#create-guild-ban */
+  createBan(
+    options?: {
+      deleteMessageDays?: number;
+      deleteMessageSeconds?: number;
+    },
+    reason?: string
+  ): void {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.put(Endpoints.guildBan(this.guildId, this.user.id), {
+      json: {
+        delete_message_days: options?.deleteMessageDays,
+        delete_message_seconds: options?.deleteMessageSeconds,
+      },
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#modify-guild-member */
+  async edit(
+    options: {
+      nick?: string | null;
+      roles?: Array<string> | null;
+      mute?: boolean | null;
+      deaf?: boolean | null;
+      channelId?: string | null;
+      communicationDisabledUntil?: number | null;
+      flags?: GuildMemberFlags;
+    },
+    reason?: string
+  ): Promise<GuildMember> {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    return new GuildMember(
+      await this.client.rest.patch(
+        Endpoints.guildMember(this.guildId, this.user.id),
+        {
+          json: {
+            nick: options.nick,
+            roles: options.roles,
+            mute: options.mute,
+            deaf: options.deaf,
+            channel_id: options.channelId,
+            communication_disabled_until: options.communicationDisabledUntil,
+            flags: options.flags,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#remove-guild-member */
+  remove(reason?: string): void {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.delete(Endpoints.guildMember(this.guildId, this.user.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#remove-guild-ban */
+  removeBan(reason?: string): void {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.delete(Endpoints.guildBan(this.guildId, this.user.id), {
+      reason,
+    });
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#remove-guild-member-role */
+  removeRole(roleId: string, reason?: string): void {
+    if (!this.user?.id)
+      throw new Error("[disgroove] Guild member ID not found");
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.delete(
+      Endpoints.guildMemberRole(this.guildId, this.user.id, roleId),
+      {
+        reason,
+      }
+    );
+  }
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): RawGuildMember & Partial<RawGuildMemberAddEventExtraFields> {
+    return this.raw;
+  }
+
+  toJSON(): JSONGuildMember & Partial<JSONGuildMemberAddEventExtraFields> {
+    return {
+      user: this.user?.toJSON(),
+      nick: this.nick,
+      avatar: this.avatar,
+      roles: this.roles,
+      joinedAt: this.joinedAt,
+      premiumSince: this.premiumSince,
+      deaf: this.deaf,
+      mute: this.mute,
+      flags: this.flags,
+      pending: this.pending,
+      permissions: this.permissions,
+      communicationDisabledUntil: this.communicationDisabledUntil,
+      guildId: this.guildId,
+    };
+  }
+}

package/lib/structures/GuildScheduledEvent.ts

@@ -0,0 +1,164 @@
+import { Base, GuildMember, User } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONGuildScheduledEvent,
+  JSONGuildScheduledEventEntityMetadata,
+  JSONGuildScheduledEventUser,
+  RawGuildScheduledEvent,
+  RawGuildScheduledEventUser,
+} from "../types";
+import type {
+  GuildScheduledEventEntityTypes,
+  GuildScheduledEventPrivacyLevel,
+  GuildScheduledEventStatus,
+} from "../constants";
+
+/** https://discord.com/developers/docs/resources/guild-scheduled-event */
+export class GuildScheduledEvent extends Base {
+  protected override raw: RawGuildScheduledEvent;
+  guildId: string;
+  channelId: string | null;
+  creatorId?: string | null;
+  name: string;
+  description?: string | null;
+  scheduledStartTime: string;
+  scheduledEndTime: string | null;
+  privacyLevel: GuildScheduledEventPrivacyLevel;
+  status: GuildScheduledEventStatus;
+  entityType: GuildScheduledEventEntityTypes;
+  entityId?: string;
+  entityMetadata: JSONGuildScheduledEventEntityMetadata | null;
+  creator?: User;
+  userCount?: number;
+  image?: string;
+
+  constructor(data: RawGuildScheduledEvent, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.guildId = data.guild_id;
+    this.channelId = data.channel_id;
+    this.name = data.name;
+    this.scheduledStartTime = data.scheduled_start_time;
+    this.scheduledEndTime = data.scheduled_end_time;
+    this.privacyLevel = data.privacy_level;
+    this.status = data.status;
+    this.entityType = data.entity_type;
+    this.entityMetadata = data.entity_metadata;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: RawGuildScheduledEvent): void {
+    if (data.creator_id !== undefined) this.creatorId = data.creator_id;
+    if (data.description !== undefined) this.description = data.description;
+    if (data.entity_id !== undefined) this.entityId = data.entity_id;
+    if (data.creator !== undefined)
+      this.creator = new User(data.creator, this.client);
+    if (data.user_count !== undefined) this.userCount = data.user_count;
+    if (data.image !== undefined) this.image = data.image;
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-scheduled-event#delete-guild-scheduled-event */
+  delete(): void {
+    this.client.rest.delete(
+      Endpoints.guildScheduledEvent(this.guildId, this.id)
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-scheduled-event#modify-guild-scheduled-event */
+  async edit(
+    options: {
+      channelId?: string | null;
+      entityMetadata?: JSONGuildScheduledEventEntityMetadata | null;
+      name?: string;
+      privacyLevel?: GuildScheduledEventPrivacyLevel;
+      scheduledStartTime?: string;
+      scheduledEndTime?: string;
+      description?: string | null;
+      entityType?: GuildScheduledEventEntityTypes;
+      status?: GuildScheduledEventStatus;
+      image?: string;
+    },
+    reason?: string
+  ): Promise<GuildScheduledEvent> {
+    return new GuildScheduledEvent(
+      await this.client.rest.patch<RawGuildScheduledEvent>(
+        Endpoints.guildScheduledEvent(this.guildId, this.id),
+        {
+          json: {
+            channel_id: options.channelId,
+            entity_metadata: options.entityMetadata,
+            name: options.name,
+            privacy_level: options.privacyLevel,
+            scheduled_start_time: options.scheduledStartTime,
+            scheduled_end_time: options.scheduledEndTime,
+            description: options.description,
+            entityType: options.entityType,
+            status: options.status,
+            image: options.image,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-scheduled-event#get-guild-scheduled-event-users */
+  async getUsers(options?: {
+    limit?: number;
+    withMember?: boolean;
+    before?: string;
+    after?: string;
+  }): Promise<Array<JSONGuildScheduledEventUser>> {
+    return this.client.rest
+      .get<Array<RawGuildScheduledEventUser>>(
+        Endpoints.guildScheduledEvent(this.guildId, this.id),
+        {
+          query: {
+            limit: options?.limit,
+            with_member: options?.withMember,
+            before: options?.before,
+            after: options?.after,
+          },
+        }
+      )
+      .then((response) =>
+        response.map((data) => ({
+          guildScheduledEventId: data.guild_scheduled_event_id,
+          user: new User(data.user, this.client).toJSON(),
+          member:
+            data.member !== undefined
+              ? new GuildMember(data.member, this.client).toJSON()
+              : undefined,
+        }))
+      );
+  }
+
+  override toRaw(): RawGuildScheduledEvent {
+    return this.raw;
+  }
+
+  override toJSON(): JSONGuildScheduledEvent {
+    return {
+      ...super.toJSON(),
+      guildId: this.guildId,
+      channelId: this.channelId,
+      creatorId: this.creatorId,
+      name: this.name,
+      description: this.description,
+      scheduledStartTime: this.scheduledStartTime,
+      scheduledEndTime: this.scheduledEndTime,
+      privacyLevel: this.privacyLevel,
+      status: this.status,
+      entityType: this.entityType,
+      entityId: this.entityId,
+      entityMetadata: this.entityMetadata,
+      creator: this.creator?.toJSON(),
+      userCount: this.userCount,
+      image: this.image,
+    };
+  }
+}

package/lib/structures/GuildTemplate.ts

@@ -0,0 +1,103 @@
+import { Guild, User } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type { JSONGuildTemplate, RawGuildTemplate } from "../types";
+
+/** https://discord.com/developers/docs/resources/guild-template */
+export class GuildTemplate {
+  private client: Client;
+  private raw: RawGuildTemplate;
+  code: string;
+  name: string;
+  description: string | null;
+  usageCount: number;
+  creatorId: string;
+  creator: User;
+  createdAt: string;
+  updatedAt: string;
+  sourceGuildId: string;
+  serializedSourceGuild: Guild;
+  isDirty: boolean | null;
+
+  constructor(data: RawGuildTemplate, client: Client) {
+    this.client = client;
+    this.raw = data;
+    this.code = data.code;
+    this.name = data.name;
+    this.description = data.description;
+    this.usageCount = data.usage_count;
+    this.creatorId = data.creator_id;
+    this.createdAt = data.created_at;
+    this.creator = new User(data.creator, client);
+    this.updatedAt = data.updated_at;
+    this.sourceGuildId = data.source_guild_id;
+    this.serializedSourceGuild = new Guild(
+      data.serialized_source_guild,
+      client
+    );
+    this.isDirty = data.is_dirty;
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-template#delete-guild-template */
+  async delete(): Promise<JSONGuildTemplate> {
+    return new GuildTemplate(
+      await this.client.rest.delete<RawGuildTemplate>(
+        Endpoints.guildTemplate(this.sourceGuildId, this.code)
+      ),
+      this.client
+    ).toJSON();
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-template#modify-guild-template */
+  async edit(options: {
+    name?: string;
+    description?: string | null;
+  }): Promise<GuildTemplate> {
+    return new GuildTemplate(
+      await this.client.rest.patch<RawGuildTemplate>(
+        Endpoints.guildTemplate(this.sourceGuildId, this.code),
+        {
+          json: {
+            name: options.name,
+            description: options.description,
+          },
+        }
+      ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-template#sync-guild-template */
+  async sync(): Promise<GuildTemplate> {
+    return new GuildTemplate(
+      await this.client.rest.put<RawGuildTemplate>(
+        Endpoints.guildTemplate(this.sourceGuildId, this.code)
+      ),
+      this.client
+    );
+  }
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): RawGuildTemplate {
+    return this.raw;
+  }
+
+  toJSON(): JSONGuildTemplate {
+    return {
+      code: this.code,
+      name: this.name,
+      description: this.description,
+      usageCount: this.usageCount,
+      creatorId: this.creatorId,
+      creator: this.creator.toJSON(),
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      sourceGuildId: this.sourceGuildId,
+      serializedSourceGuild: this.serializedSourceGuild.toJSON(),
+      isDirty: this.isDirty,
+    };
+  }
+}

package/lib/structures/Integration.ts

@@ -0,0 +1,136 @@
+import { Base, User } from ".";
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONIntegration,
+  JSONIntegrationAccount,
+  JSONIntegrationApplication,
+  JSONIntegrationCreateEventExtraFields,
+  JSONIntegrationUpdateEventExtraFields,
+  RawIntegration,
+  RawIntegrationCreateEventExtraFields,
+  RawIntegrationUpdateEventExtraFields,
+} from "../types";
+import type { IntegrationExpireBehaviors, OAuth2Scopes } from "../constants";
+
+/** https://discord.com/developers/docs/resources/guild */
+export class Integration extends Base {
+  protected override raw: RawIntegration &
+    Partial<
+      | RawIntegrationCreateEventExtraFields
+      | RawIntegrationUpdateEventExtraFields
+    >;
+  name: string;
+  type: string;
+  enabled: boolean;
+  syncing?: boolean;
+  roleId?: string;
+  enableEmoticons?: boolean;
+  expireBehavior?: IntegrationExpireBehaviors;
+  expireGracePeriod?: number;
+  user?: User;
+  account: JSONIntegrationAccount;
+  syncedAt?: string;
+  subscriberCount?: number;
+  revoked?: boolean;
+  application?: JSONIntegrationApplication;
+  scopes?: Array<OAuth2Scopes>;
+  guildId?: string;
+
+  constructor(
+    data: RawIntegration &
+      Partial<
+        | RawIntegrationCreateEventExtraFields
+        | RawIntegrationUpdateEventExtraFields
+      >,
+    client: Client
+  ) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.name = data.name;
+    this.type = data.type;
+    this.enabled = data.enabled;
+    this.account = data.account;
+
+    this.patch(data);
+  }
+
+  protected override patch(
+    data: RawIntegration &
+      Partial<
+        | RawIntegrationCreateEventExtraFields
+        | RawIntegrationUpdateEventExtraFields
+      >
+  ): void {
+    if (data.syncing !== undefined) this.syncing = data.syncing;
+    if (data.role_id !== undefined) this.roleId = data.role_id;
+    if (data.enable_emoticons !== undefined)
+      this.enableEmoticons = data.enable_emoticons;
+    if (data.expire_behavior !== undefined)
+      this.expireBehavior = data.expire_behavior;
+    if (data.expire_grace_period !== undefined)
+      this.expireGracePeriod = data.expire_grace_period;
+    if (data.user !== undefined) this.user = new User(data.user, this.client);
+    if (data.synced_at !== undefined) this.syncedAt = data.synced_at;
+    if (data.subscriber_count !== undefined)
+      this.subscriberCount = data.subscriber_count;
+    if (data.revoked !== undefined) this.revoked = data.revoked;
+    if (data.application !== undefined)
+      this.application = {
+        id: data.application.id,
+        name: data.application.name,
+        icon: data.application.icon,
+        description: data.application.description,
+        bot:
+          data.application.bot !== undefined
+            ? new User(data.application.bot, this.client).toJSON()
+            : undefined,
+      };
+    if (data.scopes !== undefined) this.scopes = data.scopes;
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#delete-guild-integration */
+  delete(reason?: string): void {
+    if (!this.guildId) throw new Error("[disgroove] Guild ID not found");
+
+    this.client.rest.delete(Endpoints.guildIntegration(this.guildId, this.id), {
+      reason,
+    });
+  }
+
+  override toRaw(): RawIntegration &
+    Partial<
+      | RawIntegrationCreateEventExtraFields
+      | RawIntegrationUpdateEventExtraFields
+    > {
+    return this.raw;
+  }
+
+  override toJSON(): JSONIntegration &
+    Partial<
+      | JSONIntegrationCreateEventExtraFields
+      | JSONIntegrationUpdateEventExtraFields
+    > {
+    return {
+      ...super.toJSON(),
+      name: this.name,
+      type: this.type,
+      enabled: this.enabled,
+      syncing: this.syncing,
+      roleId: this.roleId,
+      enableEmoticons: this.enableEmoticons,
+      expireBehavior: this.expireBehavior,
+      expireGracePeriod: this.expireGracePeriod,
+      user: this.user?.toJSON(),
+      account: this.account,
+      syncedAt: this.syncedAt,
+      subscriberCount: this.subscriberCount,
+      revoked: this.revoked,
+      application: this.application,
+      scopes: this.scopes,
+      guildId: this.guildId,
+    };
+  }
+}