@velliajs/discord 1.0.0

package/src/managers/GuildMemberRoleManager.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Routes } = require('discord-api-types/v10');
+const DataManager = require('./DataManager');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+const { Role } = require('../structures/Role');
+
+/**
+ * Manages API methods for roles of a GuildMember and stores their cache.
+ * @extends {DataManager}
+ */
+class GuildMemberRoleManager extends DataManager {
+  constructor(member) {
+    super(member.client, Role);
+
+    /**
+     * The GuildMember this manager belongs to
+     * @type {GuildMember}
+     */
+    this.member = member;
+
+    /**
+     * The Guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = member.guild;
+  }
+
+  /**
+   * The roles of this member
+   * @type {Collection<Snowflake, Role>}
+   * @readonly
+   */
+  get cache() {
+    const everyone = this.guild.roles.everyone;
+    return this.guild.roles.cache.filter(role => this.member._roles.includes(role.id)).set(everyone.id, everyone);
+  }
+
+  /**
+   * The role of the member used to hoist them in a separate category in the users list
+   * @type {?Role}
+   * @readonly
+   */
+  get hoist() {
+    const hoistedRoles = this.cache.filter(role => role.hoist);
+    if (!hoistedRoles.size) return null;
+    return hoistedRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
+  }
+
+  /**
+   * The role of the member used to set their role icon
+   * @type {?Role}
+   * @readonly
+   */
+  get icon() {
+    const iconRoles = this.cache.filter(role => role.icon || role.unicodeEmoji);
+    if (!iconRoles.size) return null;
+    return iconRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
+  }
+
+  /**
+   * The role of the member used to set their color
+   * @type {?Role}
+   * @readonly
+   */
+  get color() {
+    const coloredRoles = this.cache.filter(role => role.color);
+    if (!coloredRoles.size) return null;
+    return coloredRoles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev));
+  }
+
+  /**
+   * The role of the member with the highest position
+   * @type {Role}
+   * @readonly
+   */
+  get highest() {
+    return this.cache.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this.cache.first());
+  }
+
+  /**
+   * The premium subscriber role of the guild, if present on the member
+   * @type {?Role}
+   * @readonly
+   */
+  get premiumSubscriberRole() {
+    return this.cache.find(role => role.tags?.premiumSubscriberRole) ?? null;
+  }
+
+  /**
+   * The managed role this member created when joining the guild, if any
+   * <info>Only ever available on bots</info>
+   * @type {?Role}
+   * @readonly
+   */
+  get botRole() {
+    if (!this.member.user.bot) return null;
+    return this.cache.find(role => role.tags?.botId === this.member.user.id) ?? null;
+  }
+
+  /**
+   * Adds a role (or multiple roles) to the member.
+   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to add
+   * @param {string} [reason] Reason for adding the role(s)
+   * @returns {Promise<GuildMember>}
+   */
+  async add(roleOrRoles, reason) {
+    if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
+      const resolvedRoles = [];
+      for (const role of roleOrRoles.values()) {
+        const resolvedRole = this.guild.roles.resolveId(role);
+        if (!resolvedRole) {
+          throw new DiscordjsTypeError(ErrorCodes.InvalidElement, 'Array or Collection', 'roles', role);
+        }
+        resolvedRoles.push(resolvedRole);
+      }
+
+      const newRoles = [...new Set(resolvedRoles.concat(...this.cache.keys()))];
+      return this.set(newRoles, reason);
+    } else {
+      roleOrRoles = this.guild.roles.resolveId(roleOrRoles);
+      if (roleOrRoles === null) {
+        throw new DiscordjsTypeError(
+          ErrorCodes.InvalidType,
+          'roles',
+          'Role, Snowflake or Array or Collection of Roles or Snowflakes',
+        );
+      }
+
+      await this.client.rest.put(Routes.guildMemberRole(this.guild.id, this.member.id, roleOrRoles), { reason });
+
+      const clone = this.member._clone();
+      clone._roles = [...this.cache.keys(), roleOrRoles];
+      return clone;
+    }
+  }
+
+  /**
+   * Removes a role (or multiple roles) from the member.
+   * @param {RoleResolvable|RoleResolvable[]|Collection<Snowflake, Role>} roleOrRoles The role or roles to remove
+   * @param {string} [reason] Reason for removing the role(s)
+   * @returns {Promise<GuildMember>}
+   */
+  async remove(roleOrRoles, reason) {
+    if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
+      const resolvedRoles = [];
+      for (const role of roleOrRoles.values()) {
+        const resolvedRole = this.guild.roles.resolveId(role);
+        if (!resolvedRole) {
+          throw new DiscordjsTypeError(ErrorCodes.InvalidElement, 'Array or Collection', 'roles', role);
+        }
+        resolvedRoles.push(resolvedRole);
+      }
+
+      const newRoles = this.cache.filter(role => !resolvedRoles.includes(role.id));
+      return this.set(newRoles, reason);
+    } else {
+      roleOrRoles = this.guild.roles.resolveId(roleOrRoles);
+      if (roleOrRoles === null) {
+        throw new DiscordjsTypeError(
+          ErrorCodes.InvalidType,
+          'roles',
+          'Role, Snowflake or Array or Collection of Roles or Snowflakes',
+        );
+      }
+
+      await this.client.rest.delete(Routes.guildMemberRole(this.guild.id, this.member.id, roleOrRoles), { reason });
+
+      const clone = this.member._clone();
+      const newRoles = this.cache.filter(role => role.id !== roleOrRoles);
+      clone._roles = [...newRoles.keys()];
+      return clone;
+    }
+  }
+
+  /**
+   * Sets the roles applied to the member.
+   * @param {Collection<Snowflake, Role>|RoleResolvable[]} roles The roles or role ids to apply
+   * @param {string} [reason] Reason for applying the roles
+   * @returns {Promise<GuildMember>}
+   * @example
+   * // Set the member's roles to a single role
+   * guildMember.roles.set(['391156570408615936'])
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Remove all the roles from a member
+   * guildMember.roles.set([])
+   *   .then(member => console.log(`Member roles is now of ${member.roles.cache.size} size`))
+   *   .catch(console.error);
+   */
+  set(roles, reason) {
+    return this.member.edit({ roles, reason });
+  }
+
+  clone() {
+    const clone = new this.constructor(this.member);
+    clone.member._roles = [...this.cache.keys()];
+    return clone;
+  }
+}
+
+module.exports = GuildMemberRoleManager;

package/src/managers/GuildScheduledEventManager.js

@@ -0,0 +1,297 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { makeURLSearchParams } = require('@discordjs/rest');
+const { GuildScheduledEventEntityType, Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const { DiscordjsTypeError, DiscordjsError, ErrorCodes } = require('../errors');
+const { GuildScheduledEvent } = require('../structures/GuildScheduledEvent');
+const DataResolver = require('../util/DataResolver');
+
+/**
+ * Manages API methods for GuildScheduledEvents and stores their cache.
+ * @extends {CachedManager}
+ */
+class GuildScheduledEventManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, GuildScheduledEvent, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, GuildScheduledEvent>}
+   * @name GuildScheduledEventManager#cache
+   */
+
+  /**
+   * Data that resolves to give a GuildScheduledEvent object. This can be:
+   * * A Snowflake
+   * * A GuildScheduledEvent object
+   * @typedef {Snowflake|GuildScheduledEvent} GuildScheduledEventResolvable
+   */
+
+  /**
+   * Options used to create a guild scheduled event.
+   * @typedef {Object} GuildScheduledEventCreateOptions
+   * @property {string} name The name of the guild scheduled event
+   * @property {DateResolvable} scheduledStartTime The time to schedule the event at
+   * @property {DateResolvable} [scheduledEndTime] The time to end the event at
+   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
+   * @property {GuildScheduledEventPrivacyLevel} privacyLevel The privacy level of the guild scheduled event
+   * @property {GuildScheduledEventEntityType} entityType The scheduled entity type of the event
+   * @property {string} [description] The description of the guild scheduled event
+   * @property {GuildVoiceChannelResolvable} [channel] The channel of the guild scheduled event
+   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.StageInstance} or
+   * {@link GuildScheduledEventEntityType.Voice}</warn>
+   * @property {GuildScheduledEventEntityMetadataOptions} [entityMetadata] The entity metadata of the
+   * guild scheduled event
+   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
+   * @property {?(BufferResolvable|Base64Resolvable)} [image] The cover image of the guild scheduled event
+   * @property {string} [reason] The reason for creating the guild scheduled event
+   */
+
+  /**
+   * Options used to set entity metadata of a guild scheduled event.
+   * @typedef {Object} GuildScheduledEventEntityMetadataOptions
+   * @property {string} [location] The location of the guild scheduled event
+   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
+   */
+
+  /**
+   * Creates a new guild scheduled event.
+   * @param {GuildScheduledEventCreateOptions} options Options for creating the guild scheduled event
+   * @returns {Promise<GuildScheduledEvent>}
+   */
+  async create(options) {
+    if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
+    let {
+      privacyLevel,
+      entityType,
+      channel,
+      name,
+      scheduledStartTime,
+      description,
+      scheduledEndTime,
+      entityMetadata,
+      reason,
+      image,
+    } = options;
+
+    let entity_metadata, channel_id;
+    if (entityType === GuildScheduledEventEntityType.External) {
+      channel_id = channel === undefined ? channel : null;
+      entity_metadata = { location: entityMetadata?.location };
+    } else {
+      channel_id = this.guild.channels.resolveId(channel);
+      if (!channel_id) throw new DiscordjsError(ErrorCodes.GuildVoiceChannelResolve);
+      entity_metadata = entityMetadata === undefined ? entityMetadata : null;
+    }
+
+    const data = await this.client.rest.post(Routes.guildScheduledEvents(this.guild.id), {
+      body: {
+        channel_id,
+        name,
+        privacy_level: privacyLevel,
+        scheduled_start_time: new Date(scheduledStartTime).toISOString(),
+        scheduled_end_time: scheduledEndTime ? new Date(scheduledEndTime).toISOString() : scheduledEndTime,
+        description,
+        entity_type: entityType,
+        entity_metadata,
+        image: image && (await DataResolver.resolveImage(image)),
+      },
+      reason,
+    });
+
+    return this._add(data);
+  }
+
+  /**
+   * Options used to fetch a single guild scheduled event from a guild.
+   * @typedef {BaseFetchOptions} FetchGuildScheduledEventOptions
+   * @property {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to fetch
+   * @property {boolean} [withUserCount=true] Whether to fetch the number of users subscribed to the scheduled event
+   */
+
+  /**
+   * Options used to fetch multiple guild scheduled events from a guild.
+   * @typedef {Object} FetchGuildScheduledEventsOptions
+   * @property {boolean} [cache] Whether or not to cache the fetched guild scheduled events
+   * @property {boolean} [withUserCount=true] Whether to fetch the number of users subscribed to each scheduled event
+   * should be returned
+   */
+
+  /**
+   * Obtains one or more guild scheduled events from Discord, or the guild cache if it's already available.
+   * @param {GuildScheduledEventResolvable|FetchGuildScheduledEventOptions|FetchGuildScheduledEventsOptions} [options]
+   * The id of the guild scheduled event or options
+   * @returns {Promise<GuildScheduledEvent|Collection<Snowflake, GuildScheduledEvent>>}
+   */
+  async fetch(options = {}) {
+    const id = this.resolveId(options.guildScheduledEvent ?? options);
+
+    if (id) {
+      if (!options.force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+
+      const data = await this.client.rest.get(Routes.guildScheduledEvent(this.guild.id, id), {
+        query: makeURLSearchParams({ with_user_count: options.withUserCount ?? true }),
+      });
+      return this._add(data, options.cache);
+    }
+
+    const data = await this.client.rest.get(Routes.guildScheduledEvents(this.guild.id), {
+      query: makeURLSearchParams({ with_user_count: options.withUserCount ?? true }),
+    });
+
+    return data.reduce(
+      (coll, rawGuildScheduledEventData) =>
+        coll.set(
+          rawGuildScheduledEventData.id,
+          this.guild.scheduledEvents._add(rawGuildScheduledEventData, options.cache),
+        ),
+      new Collection(),
+    );
+  }
+
+  /**
+   * Options used to edit a guild scheduled event.
+   * @typedef {Object} GuildScheduledEventEditOptions
+   * @property {string} [name] The name of the guild scheduled event
+   * @property {DateResolvable} [scheduledStartTime] The time to schedule the event at
+   * @property {DateResolvable} [scheduledEndTime] The time to end the event at
+   * @property {GuildScheduledEventPrivacyLevel} [privacyLevel] The privacy level of the guild scheduled event
+   * @property {GuildScheduledEventEntityType} [entityType] The scheduled entity type of the event
+   * @property {string} [description] The description of the guild scheduled event
+   * @property {?GuildVoiceChannelResolvable} [channel] The channel of the guild scheduled event
+   * @property {GuildScheduledEventStatus} [status] The status of the guild scheduled event
+   * @property {GuildScheduledEventEntityMetadataOptions} [entityMetadata] The entity metadata of the
+   * guild scheduled event
+   * <warn>This can be modified only if `entityType` of the `GuildScheduledEvent` to be edited is
+   * {@link GuildScheduledEventEntityType.External}</warn>
+   * @property {?(BufferResolvable|Base64Resolvable)} [image] The cover image of the guild scheduled event
+   * @property {string} [reason] The reason for editing the guild scheduled event
+   */
+
+  /**
+   * Edits a guild scheduled event.
+   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to edit
+   * @param {GuildScheduledEventEditOptions} options Options to edit the guild scheduled event
+   * @returns {Promise<GuildScheduledEvent>}
+   */
+  async edit(guildScheduledEvent, options) {
+    const guildScheduledEventId = this.resolveId(guildScheduledEvent);
+    if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);
+
+    if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
+    let {
+      privacyLevel,
+      entityType,
+      channel,
+      status,
+      name,
+      scheduledStartTime,
+      description,
+      scheduledEndTime,
+      entityMetadata,
+      reason,
+      image,
+    } = options;
+
+    let entity_metadata;
+    if (entityMetadata) {
+      entity_metadata = {
+        location: entityMetadata.location,
+      };
+    }
+
+    const data = await this.client.rest.patch(Routes.guildScheduledEvent(this.guild.id, guildScheduledEventId), {
+      body: {
+        channel_id: channel === undefined ? channel : this.guild.channels.resolveId(channel),
+        name,
+        privacy_level: privacyLevel,
+        scheduled_start_time: scheduledStartTime ? new Date(scheduledStartTime).toISOString() : undefined,
+        scheduled_end_time: scheduledEndTime ? new Date(scheduledEndTime).toISOString() : scheduledEndTime,
+        description,
+        entity_type: entityType,
+        status,
+        image: image && (await DataResolver.resolveImage(image)),
+        entity_metadata,
+      },
+      reason,
+    });
+
+    return this._add(data);
+  }
+
+  /**
+   * Deletes a guild scheduled event.
+   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to delete
+   * @returns {Promise<void>}
+   */
+  async delete(guildScheduledEvent) {
+    const guildScheduledEventId = this.resolveId(guildScheduledEvent);
+    if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);
+
+    await this.client.rest.delete(Routes.guildScheduledEvent(this.guild.id, guildScheduledEventId));
+  }
+
+  /**
+   * Options used to fetch subscribers of a guild scheduled event
+   * @typedef {Object} FetchGuildScheduledEventSubscribersOptions
+   * @property {number} [limit] The maximum numbers of users to fetch
+   * @property {boolean} [withMember] Whether to fetch guild member data of the users
+   * @property {Snowflake} [before] Consider only users before this user id
+   * @property {Snowflake} [after] Consider only users after this user id
+   * <warn>If both `before` and `after` are provided, only `before` is respected</warn>
+   */
+
+  /**
+   * Represents a subscriber of a {@link GuildScheduledEvent}
+   * @typedef {Object} GuildScheduledEventUser
+   * @property {Snowflake} guildScheduledEventId The id of the guild scheduled event which the user subscribed to
+   * @property {User} user The user that subscribed to the guild scheduled event
+   * @property {?GuildMember} member The guild member associated with the user, if any
+   */
+
+  /**
+   * Fetches subscribers of a guild scheduled event.
+   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to fetch subscribers of
+   * @param {FetchGuildScheduledEventSubscribersOptions} [options={}] Options for fetching the subscribers
+   * @returns {Promise<Collection<Snowflake, GuildScheduledEventUser>>}
+   */
+  async fetchSubscribers(guildScheduledEvent, options = {}) {
+    const guildScheduledEventId = this.resolveId(guildScheduledEvent);
+    if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);
+
+    const query = makeURLSearchParams({
+      limit: options.limit,
+      with_member: options.withMember,
+      before: options.before,
+      after: options.after,
+    });
+
+    const data = await this.client.rest.get(Routes.guildScheduledEventUsers(this.guild.id, guildScheduledEventId), {
+      query,
+    });
+
+    return data.reduce(
+      (coll, rawData) =>
+        coll.set(rawData.user.id, {
+          guildScheduledEventId: rawData.guild_scheduled_event_id,
+          user: this.client.users._add(rawData.user),
+          member: rawData.member ? this.guild.members._add({ ...rawData.member, user: rawData.user }) : null,
+        }),
+      new Collection(),
+    );
+  }
+}
+
+module.exports = GuildScheduledEventManager;

package/src/managers/GuildStickerManager.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+const MessagePayload = require('../structures/MessagePayload');
+const { Sticker } = require('../structures/Sticker');
+
+/**
+ * Manages API methods for Guild Stickers and stores their cache.
+ * @extends {CachedManager}
+ */
+class GuildStickerManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, Sticker, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of Guild Stickers
+   * @type {Collection<Snowflake, Sticker>}
+   * @name GuildStickerManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * Options used to create a guild sticker.
+   * @typedef {Object} GuildStickerCreateOptions
+   * @property {AttachmentPayload|BufferResolvable|Stream} file The file for the sticker
+   * @property {string} name The name for the sticker
+   * @property {string} tags The Discord name of a unicode emoji representing the sticker's expression
+   * @property {?string} [description] The description for the sticker
+   * @property {string} [reason] Reason for creating the sticker
+   */
+
+  /**
+   * Creates a new custom sticker in the guild.
+   * @param {GuildStickerCreateOptions} options Options for creating a guild sticker
+   * @returns {Promise<Sticker>} The created sticker
+   * @example
+   * // Create a new sticker from a URL
+   * guild.stickers.create({ file: 'https://i.imgur.com/w3duR07.png', name: 'rip', tags: 'headstone' })
+   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
+   *   .catch(console.error);
+   * @example
+   * // Create a new sticker from a file on your computer
+   * guild.stickers.create({ file: './memes/banana.png', name: 'banana', tags: 'banana' })
+   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
+   *   .catch(console.error);
+   */
+  async create({ file, name, tags, description, reason } = {}) {
+    const resolvedFile = await MessagePayload.resolveFile(file);
+    if (!resolvedFile) throw new DiscordjsTypeError(ErrorCodes.ReqResourceType);
+    file = { ...resolvedFile, key: 'file' };
+
+    const body = { name, tags, description: description ?? '' };
+
+    const sticker = await this.client.rest.post(Routes.guildStickers(this.guild.id), {
+      appendToFormData: true,
+      body,
+      files: [file],
+      reason,
+    });
+    return this.client.actions.GuildStickerCreate.handle(this.guild, sticker).sticker;
+  }
+
+  /**
+   * Data that resolves to give a Sticker object. This can be:
+   * * A Sticker object
+   * * A Snowflake
+   * @typedef {Sticker|Snowflake} StickerResolvable
+   */
+
+  /**
+   * Resolves a StickerResolvable to a Sticker object.
+   * @method resolve
+   * @memberof GuildStickerManager
+   * @instance
+   * @param {StickerResolvable} sticker The Sticker resolvable to identify
+   * @returns {?Sticker}
+   */
+
+  /**
+   * Resolves a StickerResolvable to a Sticker id string.
+   * @method resolveId
+   * @memberof GuildStickerManager
+   * @instance
+   * @param {StickerResolvable} sticker The Sticker resolvable to identify
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Edits a sticker.
+   * @param {StickerResolvable} sticker The sticker to edit
+   * @param {GuildStickerEditOptions} [options={}] The new data for the sticker
+   * @returns {Promise<Sticker>}
+   */
+  async edit(sticker, options = {}) {
+    const stickerId = this.resolveId(sticker);
+    if (!stickerId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+
+    const d = await this.client.rest.patch(Routes.guildSticker(this.guild.id, stickerId), {
+      body: options,
+      reason: options.reason,
+    });
+
+    const existing = this.cache.get(stickerId);
+    if (existing) {
+      const clone = existing._clone();
+      clone._patch(d);
+      return clone;
+    }
+    return this._add(d);
+  }
+
+  /**
+   * Deletes a sticker.
+   * @param {StickerResolvable} sticker The sticker to delete
+   * @param {string} [reason] Reason for deleting this sticker
+   * @returns {Promise<void>}
+   */
+  async delete(sticker, reason) {
+    sticker = this.resolveId(sticker);
+    if (!sticker) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+
+    await this.client.rest.delete(Routes.guildSticker(this.guild.id, sticker), { reason });
+  }
+
+  /**
+   * Obtains one or more stickers from Discord, or the sticker cache if they're already available.
+   * @param {Snowflake} [id] The Sticker's id
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<Sticker|Collection<Snowflake, Sticker>>}
+   * @example
+   * // Fetch all stickers from the guild
+   * message.guild.stickers.fetch()
+   *   .then(stickers => console.log(`There are ${stickers.size} stickers.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single sticker
+   * message.guild.stickers.fetch('222078108977594368')
+   *   .then(sticker => console.log(`The sticker name is: ${sticker.name}`))
+   *   .catch(console.error);
+   */
+  async fetch(id, { cache = true, force = false } = {}) {
+    if (id) {
+      if (!force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+      const sticker = await this.client.rest.get(Routes.guildSticker(this.guild.id, id));
+      return this._add(sticker, cache);
+    }
+
+    const data = await this.client.rest.get(Routes.guildStickers(this.guild.id));
+    return new Collection(data.map(sticker => [sticker.id, this._add(sticker, cache)]));
+  }
+
+  /**
+   * Fetches the user who uploaded this sticker, if this is a guild sticker.
+   * @param {StickerResolvable} sticker The sticker to fetch the user for
+   * @returns {Promise<?User>}
+   */
+  async fetchUser(sticker) {
+    sticker = this.resolve(sticker);
+    if (!sticker) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
+    const data = await this.client.rest.get(Routes.guildSticker(this.guild.id, sticker.id));
+    sticker._patch(data);
+    return sticker.user;
+  }
+}
+
+module.exports = GuildStickerManager;