cognova 0.2.5 → 0.2.7

package/.output/server/node_modules/discord.js/src/managers/ChannelManager.js

@@ -1,135 +0,0 @@
-'use strict';
-
-const process = require('node:process');
-const { Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { BaseChannel } = require('../structures/BaseChannel');
-const { createChannel } = require('../util/Channels');
-const { ThreadChannelTypes } = require('../util/Constants');
-const Events = require('../util/Events');
-
-let cacheWarningEmitted = false;
-
-/**
- * A manager of channels belonging to a client
- * @extends {CachedManager}
- */
-class ChannelManager extends CachedManager {
-  constructor(client, iterable) {
-    super(client, BaseChannel, iterable);
-    const defaultCaching =
-      this._cache.constructor.name === 'Collection' ||
-      this._cache.maxSize === undefined ||
-      this._cache.maxSize === Infinity;
-    if (!cacheWarningEmitted && !defaultCaching) {
-      cacheWarningEmitted = true;
-      process.emitWarning(
-        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
-        'UnsupportedCacheOverwriteWarning',
-      );
-    }
-  }
-
-  /**
-   * The cache of Channels
-   * @type {Collection<Snowflake, BaseChannel>}
-   * @name ChannelManager#cache
-   */
-
-  _add(data, guild, { cache = true, allowUnknownGuild = false } = {}) {
-    const existing = this.cache.get(data.id);
-    if (existing) {
-      if (cache) existing._patch(data);
-      guild?.channels?._add(existing);
-      if (ThreadChannelTypes.includes(existing.type)) {
-        existing.parent?.threads?._add(existing);
-      }
-      return existing;
-    }
-
-    const channel = createChannel(this.client, data, guild, { allowUnknownGuild });
-
-    if (!channel) {
-      this.client.emit(Events.Debug, `Failed to find guild, or unknown type for channel ${data.id} ${data.type}`);
-      return null;
-    }
-
-    if (cache && !allowUnknownGuild) this.cache.set(channel.id, channel);
-
-    return channel;
-  }
-
-  _remove(id) {
-    const channel = this.cache.get(id);
-    channel?.guild?.channels.cache.delete(id);
-
-    for (const [code, invite] of channel?.guild?.invites.cache ?? []) {
-      if (invite.channelId === id) channel.guild.invites.cache.delete(code);
-    }
-
-    channel?.parent?.threads?.cache.delete(id);
-    this.cache.delete(id);
-
-    if (channel?.threads) {
-      for (const threadId of channel.threads.cache.keys()) {
-        this.cache.delete(threadId);
-        channel.guild?.channels.cache.delete(threadId);
-      }
-    }
-  }
-
-  /**
-   * Data that can be resolved to give a Channel object. This can be:
-   * * A Channel object
-   * * A Snowflake
-   * @typedef {BaseChannel|Snowflake} ChannelResolvable
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a Channel object.
-   * @method resolve
-   * @memberof ChannelManager
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?BaseChannel}
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a channel id string.
-   * @method resolveId
-   * @memberof ChannelManager
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Options for fetching a channel from Discord
-   * @typedef {BaseFetchOptions} FetchChannelOptions
-   * @property {boolean} [allowUnknownGuild=false] Allows the channel to be returned even if the guild is not in cache,
-   * it will not be cached. <warn>Many of the properties and methods on the returned channel will throw errors</warn>
-   */
-
-  /**
-   * Obtains a channel from Discord, or the channel cache if it's already available.
-   * @param {Snowflake} id The channel's id
-   * @param {FetchChannelOptions} [options] Additional options for this fetch
-   * @returns {Promise<?BaseChannel>}
-   * @example
-   * // Fetch a channel by its id
-   * client.channels.fetch('222109930545610754')
-   *   .then(channel => console.log(channel.name))
-   *   .catch(console.error);
-   */
-  async fetch(id, { allowUnknownGuild = false, cache = true, force = false } = {}) {
-    if (!force) {
-      const existing = this.cache.get(id);
-      if (existing && !existing.partial) return existing;
-    }
-
-    const data = await this.client.rest.get(Routes.channel(id));
-    return this._add(data, null, { cache, allowUnknownGuild });
-  }
-}
-
-module.exports = ChannelManager;

package/.output/server/node_modules/discord.js/src/managers/DMMessageManager.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const MessageManager = require('./MessageManager');
-
-/**
- * Manages API methods for messages in direct message channels and holds their cache.
- * @extends {MessageManager}
- */
-class DMMessageManager extends MessageManager {
-  /**
-   * The channel that the messages belong to
-   * @name DMMessageManager#channel
-   * @type {DMChannel}
-   */
-}
-
-module.exports = DMMessageManager;

package/.output/server/node_modules/discord.js/src/managers/DataManager.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const BaseManager = require('./BaseManager');
-const { DiscordjsError, ErrorCodes } = require('../errors');
-
-/**
- * Manages the API methods of a data model along with a collection of instances.
- * @extends {BaseManager}
- * @abstract
- */
-class DataManager extends BaseManager {
-  constructor(client, holds) {
-    super(client);
-
-    /**
-     * The data structure belonging to this manager.
-     * @name DataManager#holds
-     * @type {Function}
-     * @private
-     * @readonly
-     */
-    Object.defineProperty(this, 'holds', { value: holds });
-  }
-
-  /**
-   * The cache of items for this manager.
-   * @type {Collection}
-   * @abstract
-   */
-  get cache() {
-    throw new DiscordjsError(ErrorCodes.NotImplemented, 'get cache', this.constructor.name);
-  }
-
-  /**
-   * Resolves a data entry to a data Object.
-   * @param {string|Object} idOrInstance The id or instance of something in this Manager
-   * @returns {?Object} An instance from this Manager
-   */
-  resolve(idOrInstance) {
-    if (idOrInstance instanceof this.holds) return idOrInstance;
-    if (typeof idOrInstance === 'string') return this.cache.get(idOrInstance) ?? null;
-    return null;
-  }
-
-  /**
-   * Resolves a data entry to an instance id.
-   * @param {string|Object} idOrInstance The id or instance of something in this Manager
-   * @returns {?Snowflake}
-   */
-  resolveId(idOrInstance) {
-    if (idOrInstance instanceof this.holds) return idOrInstance.id;
-    if (typeof idOrInstance === 'string') return idOrInstance;
-    return null;
-  }
-
-  valueOf() {
-    return this.cache;
-  }
-}
-
-module.exports = DataManager;

package/.output/server/node_modules/discord.js/src/managers/EntitlementManager.js

@@ -1,174 +0,0 @@
-'use strict';
-
-const { Collection } = require('@discordjs/collection');
-const { makeURLSearchParams } = require('@discordjs/rest');
-const { Routes, EntitlementOwnerType } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { ErrorCodes, DiscordjsTypeError } = require('../errors/index');
-const { Entitlement } = require('../structures/Entitlement');
-const { resolveSKUId } = require('../util/Util');
-
-/**
- * Manages API methods for entitlements and stores their cache.
- * @extends {CachedManager}
- */
-class EntitlementManager extends CachedManager {
-  constructor(client, iterable) {
-    super(client, Entitlement, iterable);
-  }
-
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, Entitlement>}
-   * @name EntitlementManager#cache
-   */
-
-  /**
-   * Data that resolves to give an Entitlement object. This can be:
-   * * An Entitlement object
-   * * A Snowflake
-   * @typedef {Entitlement|Snowflake} EntitlementResolvable
-   */
-
-  /**
-   * Data that resolves to give a SKU object. This can be:
-   * * A SKU object
-   * * A Snowflake
-   * @typedef {SKU|Snowflake} SKUResolvable
-   */
-
-  /**
-   * Options used to fetch an entitlement
-   * @typedef {BaseFetchOptions} FetchEntitlementOptions
-   * @property {EntitlementResolvable} entitlement The entitlement to fetch
-   */
-
-  /**
-   * Options used to fetch entitlements
-   * @typedef {Object} FetchEntitlementsOptions
-   * @property {number} [limit] The maximum number of entitlements to fetch
-   * @property {GuildResolvable} [guild] The guild to fetch entitlements for
-   * @property {UserResolvable} [user] The user to fetch entitlements for
-   * @property {SKUResolvable[]} [skus] The SKUs to fetch entitlements for
-   * @property {boolean} [excludeEnded] Whether to exclude ended entitlements
-   * @property {boolean} [excludeDeleted] Whether to exclude deleted entitlements
-   * @property {boolean} [cache=true] Whether to cache the fetched entitlements
-   * @property {Snowflake} [before] Consider only entitlements before this entitlement id
-   * @property {Snowflake} [after] Consider only entitlements after this entitlement id
-   * <warn>If both `before` and `after` are provided, only `before` is respected</warn>
-   */
-
-  /**
-   * Fetches entitlements for this application
-   * @param {EntitlementResolvable|FetchEntitlementOptions|FetchEntitlementsOptions} [options]
-   * Options for fetching the entitlements
-   * @returns {Promise<Entitlement|Collection<Snowflake, Entitlement>>}
-   */
-  async fetch(options) {
-    if (!options) return this._fetchMany(options);
-    const { entitlement, cache, force } = options;
-    const resolvedEntitlement = this.resolveId(entitlement ?? options);
-
-    if (resolvedEntitlement) {
-      return this._fetchSingle({ entitlement: resolvedEntitlement, cache, force });
-    }
-
-    return this._fetchMany(options);
-  }
-
-  async _fetchSingle({ entitlement, cache, force = false }) {
-    if (!force) {
-      const existing = this.cache.get(entitlement);
-
-      if (existing) {
-        return existing;
-      }
-    }
-
-    const data = await this.client.rest.get(Routes.entitlement(this.client.application.id, entitlement));
-    return this._add(data, cache);
-  }
-
-  async _fetchMany({ limit, guild, user, skus, excludeEnded, excludeDeleted, cache, before, after } = {}) {
-    const query = makeURLSearchParams({
-      limit,
-      guild_id: guild && this.client.guilds.resolveId(guild),
-      user_id: user && this.client.users.resolveId(user),
-      sku_ids: skus?.map(sku => resolveSKUId(sku)).join(','),
-      exclude_ended: excludeEnded,
-      exclude_deleted: excludeDeleted,
-      before,
-      after,
-    });
-
-    const entitlements = await this.client.rest.get(Routes.entitlements(this.client.application.id), { query });
-
-    return entitlements.reduce(
-      (coll, entitlement) => coll.set(entitlement.id, this._add(entitlement, cache)),
-      new Collection(),
-    );
-  }
-
-  /**
-   * Options used to create a test entitlement
-   * <info>Either `guild` or `user` must be provided, but not both</info>
-   * @typedef {Object} EntitlementCreateOptions
-   * @property {SKUResolvable} sku The id of the SKU to create the entitlement for
-   * @property {GuildResolvable} [guild] The guild to create the entitlement for
-   * @property {UserResolvable} [user] The user to create the entitlement for
-   */
-
-  /**
-   * Creates a test entitlement
-   * @param {EntitlementCreateOptions} options Options for creating the test entitlement
-   * @returns {Promise<Entitlement>}
-   */
-  async createTest({ sku, guild, user }) {
-    const skuId = resolveSKUId(sku);
-    if (!skuId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sku', 'SKUResolvable');
-
-    if ((guild && user) || (!guild && !user)) {
-      throw new DiscordjsTypeError(ErrorCodes.EntitlementCreateInvalidOwner);
-    }
-
-    const resolved = guild ? this.client.guilds.resolveId(guild) : this.client.users.resolveId(user);
-    if (!resolved) {
-      const name = guild ? 'guild' : 'user';
-      const type = guild ? 'GuildResolvable' : 'UserResolvable';
-      throw new DiscordjsTypeError(ErrorCodes.InvalidType, name, type);
-    }
-
-    const entitlement = await this.client.rest.post(Routes.entitlements(this.client.application.id), {
-      body: {
-        sku_id: skuId,
-        owner_id: resolved,
-        owner_type: guild ? EntitlementOwnerType.Guild : EntitlementOwnerType.User,
-      },
-    });
-    return new Entitlement(this.client, entitlement);
-  }
-
-  /**
-   * Deletes a test entitlement
-   * @param {EntitlementResolvable} entitlement The entitlement to delete
-   * @returns {Promise<void>}
-   */
-  async deleteTest(entitlement) {
-    const resolved = this.resolveId(entitlement);
-    if (!resolved) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'entitlement', 'EntitlementResolvable');
-
-    await this.client.rest.delete(Routes.entitlement(this.client.application.id, resolved));
-  }
-
-  /**
-   * Marks an entitlement as consumed
-   * <info>Only available for One-Time Purchase consumable SKUs.</info>
-   * @param {Snowflake} entitlementId The id of the entitlement to consume
-   * @returns {Promise<void>}
-   */
-  async consume(entitlementId) {
-    await this.client.rest.post(Routes.consumeEntitlement(this.client.application.id, entitlementId));
-  }
-}
-
-exports.EntitlementManager = EntitlementManager;

package/.output/server/node_modules/discord.js/src/managers/GuildApplicationCommandManager.js

@@ -1,28 +0,0 @@
-'use strict';
-
-const ApplicationCommandManager = require('./ApplicationCommandManager');
-const ApplicationCommandPermissionsManager = require('./ApplicationCommandPermissionsManager');
-
-/**
- * An extension for guild-specific application commands.
- * @extends {ApplicationCommandManager}
- */
-class GuildApplicationCommandManager extends ApplicationCommandManager {
-  constructor(guild, iterable) {
-    super(guild.client, iterable);
-
-    /**
-     * The guild that this manager belongs to
-     * @type {Guild}
-     */
-    this.guild = guild;
-
-    /**
-     * The manager for permissions of arbitrary commands on this guild
-     * @type {ApplicationCommandPermissionsManager}
-     */
-    this.permissions = new ApplicationCommandPermissionsManager(this);
-  }
-}
-
-module.exports = GuildApplicationCommandManager;

package/.output/server/node_modules/discord.js/src/managers/GuildBanManager.js

@@ -1,249 +0,0 @@
-'use strict';
-
-const process = require('node:process');
-const { Collection } = require('@discordjs/collection');
-const { makeURLSearchParams } = require('@discordjs/rest');
-const { Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { DiscordjsTypeError, DiscordjsError, ErrorCodes } = require('../errors');
-const GuildBan = require('../structures/GuildBan');
-const { GuildMember } = require('../structures/GuildMember');
-
-let deprecationEmittedForDeleteMessageDays = false;
-
-/**
- * Manages API methods for guild bans and stores their cache.
- * @extends {CachedManager}
- */
-class GuildBanManager extends CachedManager {
-  constructor(guild, iterable) {
-    super(guild.client, GuildBan, iterable);
-
-    /**
-     * The guild this Manager belongs to
-     * @type {Guild}
-     */
-    this.guild = guild;
-  }
-
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, GuildBan>}
-   * @name GuildBanManager#cache
-   */
-
-  _add(data, cache) {
-    return super._add(data, cache, { id: data.user.id, extras: [this.guild] });
-  }
-
-  /**
-   * Data that resolves to give a GuildBan object. This can be:
-   * * A GuildBan object
-   * * A User resolvable
-   * @typedef {GuildBan|UserResolvable} GuildBanResolvable
-   */
-
-  /**
-   * Resolves a GuildBanResolvable to a GuildBan object.
-   * @param {GuildBanResolvable} ban The ban that is in the guild
-   * @returns {?GuildBan}
-   */
-  resolve(ban) {
-    return super.resolve(ban) ?? super.resolve(this.client.users.resolveId(ban));
-  }
-
-  /**
-   * Options used to fetch a single ban from a guild.
-   * @typedef {BaseFetchOptions} FetchBanOptions
-   * @property {UserResolvable} user The ban to fetch
-   */
-
-  /**
-   * Options used to fetch multiple bans from a guild.
-   * @typedef {Object} FetchBansOptions
-   * @property {number} [limit] The maximum number of bans to return
-   * @property {Snowflake} [before] Consider only bans before this id
-   * @property {Snowflake} [after] Consider only bans after this id
-   * @property {boolean} [cache] Whether to cache the fetched bans
-   */
-
-  /**
-   * Fetches ban(s) from Discord.
-   * @param {UserResolvable|FetchBanOptions|FetchBansOptions} [options] Options for fetching guild ban(s)
-   * @returns {Promise<GuildBan|Collection<Snowflake, GuildBan>>}
-   * @example
-   * // Fetch multiple bans from a guild
-   * guild.bans.fetch()
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 5 bans from a guild without caching
-   * guild.bans.fetch({ limit: 5, cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single ban
-   * guild.bans.fetch('351871113346809860')
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single ban without checking cache
-   * guild.bans.fetch({ user, force: true })
-   *   .then(console.log)
-   *   .catch(console.error)
-   * @example
-   * // Fetch a single ban without caching
-   * guild.bans.fetch({ user, cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
-  async fetch(options) {
-    if (!options) return this._fetchMany();
-    const { user, cache, force, limit, before, after } = options;
-    const resolvedUser = this.client.users.resolveId(user ?? options);
-    if (resolvedUser) return this._fetchSingle({ user: resolvedUser, cache, force });
-
-    if (!before && !after && !limit && cache === undefined) {
-      throw new DiscordjsError(ErrorCodes.FetchBanResolveId);
-    }
-
-    return this._fetchMany(options);
-  }
-
-  async _fetchSingle({ user, cache, force = false }) {
-    if (!force) {
-      const existing = this.cache.get(user);
-      if (existing && !existing.partial) return existing;
-    }
-
-    const data = await this.client.rest.get(Routes.guildBan(this.guild.id, user));
-    return this._add(data, cache);
-  }
-
-  async _fetchMany({ cache, ...apiOptions } = {}) {
-    const data = await this.client.rest.get(Routes.guildBans(this.guild.id), {
-      query: makeURLSearchParams(apiOptions),
-    });
-
-    return data.reduce((col, ban) => col.set(ban.user.id, this._add(ban, cache)), new Collection());
-  }
-
-  /**
-   * Options used to ban a user from a guild.
-   * @typedef {Object} BanOptions
-   * @property {number} [deleteMessageDays] Number of days of messages to delete, must be between 0 and 7, inclusive
-   * <warn>This property is deprecated. Use `deleteMessageSeconds` instead.</warn>
-   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
-   * must be between 0 and 604800 (7 days), inclusive
-   * @property {string} [reason] The reason for the ban
-   */
-
-  /**
-   * Bans a user from the guild.
-   * @param {UserResolvable} user The user to ban
-   * @param {BanOptions} [options] Options for the ban
-   * @returns {Promise<GuildMember|User|Snowflake>} Result object will be resolved as specifically as possible.
-   * If the GuildMember cannot be resolved, the User will instead be attempted to be resolved. If that also cannot
-   * be resolved, the user id will be the result.
-   * @example
-   * // Ban a user by id (or with a user/guild member object)
-   * guild.bans.create('84484653687267328')
-   *   .then(banInfo => console.log(`Banned ${banInfo.user?.tag ?? banInfo.tag ?? banInfo}`))
-   *   .catch(console.error);
-   */
-  async create(user, options = {}) {
-    if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
-    const id = this.client.users.resolveId(user);
-    if (!id) throw new DiscordjsError(ErrorCodes.BanResolveId, true);
-
-    if (options.deleteMessageDays !== undefined && !deprecationEmittedForDeleteMessageDays) {
-      process.emitWarning(
-        // eslint-disable-next-line max-len
-        'The deleteMessageDays option for GuildBanManager#create() is deprecated. Use the deleteMessageSeconds option instead.',
-        'DeprecationWarning',
-      );
-
-      deprecationEmittedForDeleteMessageDays = true;
-    }
-
-    await this.client.rest.put(Routes.guildBan(this.guild.id, id), {
-      body: {
-        delete_message_seconds:
-          options.deleteMessageSeconds ??
-          (options.deleteMessageDays ? options.deleteMessageDays * 24 * 60 * 60 : undefined),
-      },
-      reason: options.reason,
-    });
-    if (user instanceof GuildMember) return user;
-    const _user = this.client.users.cache.get(id);
-    if (_user) {
-      return this.guild.members.resolve(_user) ?? _user;
-    }
-    return id;
-  }
-
-  /**
-   * Unbans a user from the guild.
-   * @param {UserResolvable} user The user to unban
-   * @param {string} [reason] Reason for unbanning user
-   * @returns {Promise<?User>}
-   * @example
-   * // Unban a user by id (or with a user/guild member object)
-   * guild.bans.remove('84484653687267328')
-   *   .then(user => console.log(`Unbanned ${user.username} from ${guild.name}`))
-   *   .catch(console.error);
-   */
-  async remove(user, reason) {
-    const id = this.client.users.resolveId(user);
-    if (!id) throw new DiscordjsError(ErrorCodes.BanResolveId);
-    await this.client.rest.delete(Routes.guildBan(this.guild.id, id), { reason });
-    return this.client.users.resolve(user);
-  }
-
-  /**
-   * Options used for bulk banning users from a guild.
-   * @typedef {Object} BulkBanOptions
-   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
-   * must be between 0 and 604800 (7 days), inclusive
-   * @property {string} [reason] The reason for the bans
-   */
-
-  /**
-   * Result of bulk banning users from a guild.
-   * @typedef {Object} BulkBanResult
-   * @property {Snowflake[]} bannedUsers IDs of the banned users
-   * @property {Snowflake[]} failedUsers IDs of the users that could not be banned or were already banned
-   */
-
-  /**
-   * Bulk ban users from a guild, and optionally delete previous messages sent by them.
-   * @param {Collection<Snowflake, UserResolvable>|UserResolvable[]} users The users to ban
-   * @param {BulkBanOptions} [options] The options for bulk banning users
-   * @returns {Promise<BulkBanResult>} Returns an object with `bannedUsers` key containing the IDs of the banned users
-   * and the key `failedUsers` with the IDs that could not be banned or were already banned.
-   * @example
-   * // Bulk ban users by ids (or with user/guild member objects) and delete all their messages from the past 7 days
-   * guild.bans.bulkCreate(['84484653687267328'], { deleteMessageSeconds: 7 * 24 * 60 * 60 })
-   *   .then(result => {
-   *     console.log(`Banned ${result.bannedUsers.length} users, failed to ban ${result.failedUsers.length} users.`)
-   *   })
-   *   .catch(console.error);
-   */
-  async bulkCreate(users, options = {}) {
-    if (!users || !(Array.isArray(users) || users instanceof Collection)) {
-      throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'users', 'Array or Collection of UserResolvable', true);
-    }
-    if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
-
-    const userIds = users.map(user => this.client.users.resolveId(user));
-    if (userIds.length === 0) throw new DiscordjsError(ErrorCodes.BulkBanUsersOptionEmpty);
-
-    const result = await this.client.rest.post(Routes.guildBulkBan(this.guild.id), {
-      body: { delete_message_seconds: options.deleteMessageSeconds, user_ids: userIds },
-      reason: options.reason,
-    });
-    return { bannedUsers: result.banned_users, failedUsers: result.failed_users };
-  }
-}
-
-module.exports = GuildBanManager;