@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/ApplicationCommandPermissionsManager.js

@@ -5,47 +5,25 @@ const { ApplicationCommandPermissionType, RESTJSONErrorCodes, Routes } = require
 const BaseManager = require('./BaseManager');
 const { DiscordjsError, DiscordjsTypeError, ErrorCodes } = require('../errors');
 
-/**
- * Manages API methods for permissions of Application Commands.
- * @extends {BaseManager}
- */
+
 class ApplicationCommandPermissionsManager extends BaseManager {
   constructor(manager) {
     super(manager.client);
 
-    /**
-     * The manager or command that this manager belongs to
-     * @type {ApplicationCommandManager|ApplicationCommand}
-     * @private
-     */
+    
     this.manager = manager;
 
-    /**
-     * The guild that this manager acts on
-     * @type {?Guild}
-     */
+    
     this.guild = manager.guild ?? null;
 
-    /**
-     * The id of the guild that this manager acts on
-     * @type {?Snowflake}
-     */
+    
     this.guildId = manager.guildId ?? manager.guild?.id ?? null;
 
-    /**
-     * The id of the command this manager acts on
-     * @type {?Snowflake}
-     */
+    
     this.commandId = manager.id ?? null;
   }
 
-  /**
-   * The APIRouter path to the commands
-   * @param {Snowflake} guildId The guild's id to use in the path,
-   * @param {Snowflake} [commandId] The application command's id
-   * @returns {string}
-   * @private
-   */
+  
   permissionsPath(guildId, commandId) {
     if (commandId) {
       return Routes.applicationCommandPermissions(this.client.application.id, guildId, commandId);
@@ -54,49 +32,13 @@ class ApplicationCommandPermissionsManager extends BaseManager {
     return Routes.guildApplicationCommandsPermissions(this.client.application.id, guildId);
   }
 
-  /* eslint-disable max-len */
-  /**
-   * The object returned when fetching permissions for an application command.
-   * @typedef {Object} ApplicationCommandPermissions
-   * @property {Snowflake} id The role, user, or channel's id. Can also be a
-   * {@link https://discord.com/developers/docs/interactions/application-commands#application-command-permissions-object-application-command-permissions-constants permission constant}.
-   * @property {ApplicationCommandPermissionType} type Whether this permission is for a role or a user
-   * @property {boolean} permission Whether the role or user has the permission to use this command
-   */
-  /* eslint-enable max-len */
-
-  /**
-   * Options for managing permissions for one or more Application Commands
-   * <warn>When passing these options to a manager where `guildId` is `null`,
-   * `guild` is a required parameter</warn>
-   * @typedef {Object} BaseApplicationCommandPermissionsOptions
-   * @property {GuildResolvable} [guild] The guild to modify / check permissions for
-   * <warn>Ignored when the manager has a non-null `guildId` property</warn>
-   * @property {ApplicationCommandResolvable} [command] The command to modify / check permissions for
-   * <warn>Ignored when the manager has a non-null `commandId` property</warn>
-   */
-
-  /**
-   * Fetches the permissions for one or multiple commands. Providing the client's id as the "command id" will fetch
-   * *only* the guild level permissions
-   * @param {BaseApplicationCommandPermissionsOptions} [options] Options used to fetch permissions
-   * @returns {Promise<ApplicationCommandPermissions[]|Collection<Snowflake, ApplicationCommandPermissions[]>>}
-   * @example
-   * // Fetch permissions for one command
-   * guild.commands.permissions.fetch({ command: '123456789012345678' })
-   *   .then(perms => console.log(`Fetched ${perms.length} overwrites`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch permissions for all commands in a guild
-   * client.application.commands.permissions.fetch({ guild: '123456789012345678' })
-   *   .then(perms => console.log(`Fetched permissions for ${perms.size} commands`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch guild level permissions
-   * guild.commands.permissions.fetch({ command: client.user.id })
-   *   .then(perms => console.log(`Fetched ${perms.length} guild level permissions`))
-   *   .catch(console.error);
-   */
+  
+  
+  
+
+  
+
+  
   async fetch({ guild, command } = {}) {
     const { guildId, commandId } = this._validateOptions(guild, command);
     if (commandId) {
@@ -108,49 +50,9 @@ class ApplicationCommandPermissionsManager extends BaseManager {
     return data.reduce((coll, perm) => coll.set(perm.id, perm.permissions), new Collection());
   }
 
-  /**
-   * Options used to set permissions for one or more Application Commands in a guild
-   * <warn>Omitting the `command` parameter edits the guild wide permissions
-   * when the manager's `commandId` is `null`</warn>
-   * @typedef {BaseApplicationCommandPermissionsOptions} ApplicationCommandPermissionsEditOptions
-   * @property {ApplicationCommandPermissions[]} permissions The new permissions for the guild or overwrite
-   * @property {string} token The bearer token to use that authorizes the permission edit
-   */
-
-  /**
-   * Sets the permissions for the guild or a command overwrite.
-   * @param {ApplicationCommandPermissionsEditOptions} options Options used to set permissions
-   * @returns {Promise<ApplicationCommandPermissions[]|Collection<Snowflake, ApplicationCommandPermissions[]>>}
-   * @example
-   * // Set a permission overwrite for a command
-   * client.application.commands.permissions.set({
-   *  guild: '892455839386304532',
-   *  command: '123456789012345678',
-   *  token: 'TotallyRealToken',
-   *  permissions: [
-   *    {
-   *      id: '876543210987654321',
-   *      type: ApplicationCommandPermissionType.User,
-   *      permission: false,
-   *    },
-   * ]})
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Set the permissions used for the guild (commands without overwrites)
-   * guild.commands.permissions.set({ token: 'TotallyRealToken', permissions: [
-   *   {
-   *     id: '123456789012345678',
-   *     permissions: [{
-   *       id: '876543210987654321',
-   *       type: ApplicationCommandPermissionType.User,
-   *       permission: false,
-   *     }],
-   *   },
-   * ]})
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
+
+  
   async set({ guild, command, permissions, token } = {}) {
     if (!token) {
       throw new DiscordjsError(ErrorCodes.ApplicationCommandPermissionsTokenMissing);
@@ -177,22 +79,7 @@ class ApplicationCommandPermissionsManager extends BaseManager {
     return data.permissions;
   }
 
-  /**
-   * Add permissions to a command.
-   * @param {ApplicationCommandPermissionsEditOptions} options Options used to add permissions
-   * @returns {Promise<ApplicationCommandPermissions[]>}
-   * @example
-   * // Add a rule to block a role from using a command
-   * guild.commands.permissions.add({ command: '123456789012345678', token: 'TotallyRealToken', permissions: [
-   *   {
-   *     id: '876543211234567890',
-   *     type: ApplicationCommandPermissionType.Role,
-   *     permission: false
-   *   },
-   * ]})
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
+  
   async add({ guild, command, permissions, token } = {}) {
     if (!token) {
       throw new DiscordjsError(ErrorCodes.ApplicationCommandPermissionsTokenMissing);
@@ -227,49 +114,13 @@ class ApplicationCommandPermissionsManager extends BaseManager {
     return this.set({ guild: guildId, command: commandId, permissions: newPermissions, token });
   }
 
-  /**
-   * A static snowflake that identifies the everyone role for application command permissions.
-   * It is the same as the guild id
-   * @typedef {Snowflake} RolePermissionConstant
-   */
-
-  /**
-   * A static snowflake that identifies the "all channels" entity for application command permissions.
-   * It will be the result of the calculation `guildId - 1`
-   * @typedef {Snowflake} ChannelPermissionConstant
-   */
-
-  /**
-   * Options used to remove permissions from a command
-   * <warn>Omitting the `command` parameter removes from the guild wide permissions
-   * when the managers `commandId` is `null`</warn>
-   * <warn>At least one of `users`, `roles`, and `channels` is required</warn>
-   * @typedef {BaseApplicationCommandPermissionsOptions} RemoveApplicationCommandPermissionsOptions
-   * @property {string} token The bearer token to use that authorizes the permission removal
-   * @property {UserResolvable[]} [users] The user(s) to remove
-   * @property {Array<RoleResolvable|RolePermissionConstant>} [roles] The role(s) to remove
-   * @property {Array<GuildChannelResolvable|ChannelPermissionConstant>} [channels] The channel(s) to remove
-   */
-
-  /**
-   * Remove permissions from a command.
-   * @param {RemoveApplicationCommandPermissionsOptions} options Options used to remove permissions
-   * @returns {Promise<ApplicationCommandPermissions[]>}
-   * @example
-   * // Remove a user permission from this command
-   * guild.commands.permissions.remove({
-   *  command: '123456789012345678', users: '876543210123456789', token: 'TotallyRealToken',
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Remove multiple roles from this command
-   * guild.commands.permissions.remove({
-   *   command: '123456789012345678', roles: ['876543210123456789', '765432101234567890'], token: 'TotallyRealToken',
-   * })
-   *    .then(console.log)
-   *    .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
   async remove({ guild, command, users, roles, channels, token } = {}) {
     if (!token) {
       throw new DiscordjsError(ErrorCodes.ApplicationCommandPermissionsTokenMissing);
@@ -342,25 +193,9 @@ class ApplicationCommandPermissionsManager extends BaseManager {
     return this.set({ guild: guildId, command: commandId, permissions, token });
   }
 
-  /**
-   * Options used to check the existence of permissions on a command
-   * <warn>The `command` parameter is not optional when the managers `commandId` is `null`</warn>
-   * @typedef {BaseApplicationCommandPermissionsOptions} HasApplicationCommandPermissionsOptions
-   * @property {ApplicationCommandPermissionIdResolvable} permissionId The entity to check if a permission exists for
-   * on this command.
-   * @property {ApplicationCommandPermissionType} [permissionType] Check for a specific type of permission
-   */
-
-  /**
-   * Check whether a permission exists for a user, role, or channel
-   * @param {HasApplicationCommandPermissionsOptions} options Options used to check permissions
-   * @returns {Promise<boolean>}
-   * @example
-   * // Check whether a user has permission to use a command
-   * guild.commands.permissions.has({ command: '123456789012345678', permissionId: '876543210123456789' })
-   *  .then(console.log)
-   *  .catch(console.error);
-   */
+  
+
+  
   async has({ guild, command, permissionId, permissionType }) {
     const { guildId, commandId } = this._validateOptions(guild, command);
     if (!commandId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'command', 'ApplicationCommandResolvable');
@@ -398,7 +233,7 @@ class ApplicationCommandPermissionsManager extends BaseManager {
       if (error.code !== RESTJSONErrorCodes.UnknownApplicationCommandPermissions) throw error;
     }
 
-    // Check permission type if provided for the single edge case where a channel id is the same as the everyone role id
+    
     return existing.some(perm => perm.id === resolvedId && (permissionType ?? perm.type) === perm.type);
   }
 
@@ -422,13 +257,7 @@ class ApplicationCommandPermissionsManager extends BaseManager {
 
 module.exports = ApplicationCommandPermissionsManager;
 
-/* eslint-disable max-len */
-/**
- * @external APIApplicationCommandPermissions
- * @see {@link https://discord.com/developers/docs/interactions/application-commands#application-command-permissions-object-application-command-permissions-structure}
- */
 
-/**
- * Data that resolves to an id used for an application command permission
- * @typedef {UserResolvable|RoleResolvable|GuildChannelResolvable|RolePermissionConstant|ChannelPermissionConstant} ApplicationCommandPermissionIdResolvable
- */
+
+
+

package/src/managers/AutoModerationRuleManager.js

@@ -5,105 +5,34 @@ const { Routes } = require('discord-api-types/v10');
 const CachedManager = require('./CachedManager');
 const AutoModerationRule = require('../structures/AutoModerationRule');
 
-/**
- * Manages API methods for auto moderation rules and stores their cache.
- * @extends {CachedManager}
- */
+
 class AutoModerationRuleManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, AutoModerationRule, iterable);
 
-    /**
-     * The guild this manager belongs to.
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, AutoModerationRule>}
-   * @name AutoModerationRuleManager#cache
-   */
+  
 
-  /**
-   * Resolves an {@link AutoModerationRuleResolvable} to an {@link AutoModerationRule} object.
-   * @method resolve
-   * @memberof AutoModerationRuleManager
-   * @instance
-   * @param {AutoModerationRuleResolvable} autoModerationRule The AutoModerationRule resolvable to resolve
-   * @returns {?AutoModerationRule}
-   */
+  
 
-  /**
-   * Resolves an {@link AutoModerationRuleResolvable} to a {@link AutoModerationRule} id.
-   * @method resolveId
-   * @memberof AutoModerationRuleManager
-   * @instance
-   * @param {AutoModerationRuleResolvable} autoModerationRule The AutoModerationRule resolvable to resolve
-   * @returns {?Snowflake}
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { extras: [this.guild] });
   }
 
-  /**
-   * Options used to set the trigger metadata of an auto moderation rule.
-   * @typedef {Object} AutoModerationTriggerMetadataOptions
-   * @property {string[]} [keywordFilter] The substrings that will be searched for in the content
-   * @property {string[]} [regexPatterns] The regular expression patterns which will be matched against the content
-   * <info>Only Rust-flavored regular expressions are supported.</info>
-   * @property {AutoModerationRuleKeywordPresetType[]} [presets]
-   * The internally pre-defined wordsets which will be searched for in the content
-   * @property {string[]} [allowList] The substrings that will be exempt from triggering
-   * {@link AutoModerationRuleTriggerType.Keyword} and {@link AutoModerationRuleTriggerType.KeywordPreset}
-   * @property {?number} [mentionTotalLimit] The total number of role & user mentions allowed per message
-   * @property {boolean} [mentionRaidProtectionEnabled] Whether to automatically detect mention raids
-   */
+  
 
-  /**
-   * Options used to set the actions of an auto moderation rule.
-   * @typedef {Object} AutoModerationActionOptions
-   * @property {AutoModerationActionType} type The type of this auto moderation rule action
-   * @property {AutoModerationActionMetadataOptions} [metadata] Additional metadata needed during execution
-   * <info>This property is required if using a `type` of
-   * {@link AutoModerationActionType.SendAlertMessage} or {@link AutoModerationActionType.Timeout}.</info>
-   */
+  
 
-  /**
-   * Options used to set the metadata of an auto moderation rule action.
-   * @typedef {Object} AutoModerationActionMetadataOptions
-   * @property {GuildTextChannelResolvable|ThreadChannel} [channel] The channel to which content will be logged
-   * @property {number} [durationSeconds] The timeout duration in seconds
-   * @property {string} [customMessage] The custom message that is shown whenever a message is blocked
-   */
+  
 
-  /**
-   * Options used to create an auto moderation rule.
-   * @typedef {Object} AutoModerationRuleCreateOptions
-   * @property {string} name The name of the auto moderation rule
-   * @property {AutoModerationRuleEventType} eventType The event type of the auto moderation rule
-   * @property {AutoModerationRuleTriggerType} triggerType The trigger type of the auto moderation rule
-   * @property {AutoModerationTriggerMetadataOptions} [triggerMetadata] The trigger metadata of the auto moderation rule
-   * <info>This property is required if using a `triggerType` of
-   * {@link AutoModerationRuleTriggerType.Keyword}, {@link AutoModerationRuleTriggerType.KeywordPreset},
-   * or {@link AutoModerationRuleTriggerType.MentionSpam}.</info>
-   * @property {AutoModerationActionOptions[]} actions
-   * The actions that will execute when the auto moderation rule is triggered
-   * @property {boolean} [enabled] Whether the auto moderation rule should be enabled
-   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [exemptRoles]
-   * The roles that should not be affected by the auto moderation rule
-   * @property {Collection<Snowflake, GuildChannel|ThreadChannel>|GuildChannelResolvable[]} [exemptChannels]
-   * The channels that should not be affected by the auto moderation rule
-   * @property {string} [reason] The reason for creating the auto moderation rule
-   */
+  
 
-  /**
-   * Creates a new auto moderation rule.
-   * @param {AutoModerationRuleCreateOptions} options Options for creating the auto moderation rule
-   * @returns {Promise<AutoModerationRule>}
-   */
+  
   async create({
     name,
     eventType,
@@ -146,28 +75,9 @@ class AutoModerationRuleManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Options used to edit an auto moderation rule.
-   * @typedef {Object} AutoModerationRuleEditOptions
-   * @property {string} [name] The name of the auto moderation rule
-   * @property {AutoModerationRuleEventType} [eventType] The event type of the auto moderation rule
-   * @property {AutoModerationTriggerMetadataOptions} [triggerMetadata] The trigger metadata of the auto moderation rule
-   * @property {AutoModerationActionOptions[]} [actions]
-   * The actions that will execute when the auto moderation rule is triggered
-   * @property {boolean} [enabled] Whether the auto moderation rule should be enabled
-   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [exemptRoles]
-   * The roles that should not be affected by the auto moderation rule
-   * @property {Collection<Snowflake, GuildChannel|ThreadChannel>|GuildChannelResolvable[]} [exemptChannels]
-   * The channels that should not be affected by the auto moderation rule
-   * @property {string} [reason] The reason for creating the auto moderation rule
-   */
+  
 
-  /**
-   * Edits an auto moderation rule.
-   * @param {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to edit
-   * @param {AutoModerationRuleEditOptions} options Options for editing the auto moderation rule
-   * @returns {Promise<AutoModerationRule>}
-   */
+  
   async edit(
     autoModerationRule,
     { name, eventType, triggerMetadata, actions, enabled, exemptRoles, exemptChannels, reason },
@@ -204,46 +114,13 @@ class AutoModerationRuleManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Data that can be resolved to give an AutoModerationRule object. This can be:
-   * * An AutoModerationRule
-   * * A Snowflake
-   * @typedef {AutoModerationRule|Snowflake} AutoModerationRuleResolvable
-   */
+  
 
-  /**
-   * Options used to fetch a single auto moderation rule from a guild.
-   * @typedef {BaseFetchOptions} FetchAutoModerationRuleOptions
-   * @property {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to fetch
-   */
+  
 
-  /**
-   * Options used to fetch all auto moderation rules from a guild.
-   * @typedef {Object} FetchAutoModerationRulesOptions
-   * @property {boolean} [cache] Whether to cache the fetched auto moderation rules
-   */
+  
 
-  /**
-   * Fetches auto moderation rules from Discord.
-   * @param {AutoModerationRuleResolvable|FetchAutoModerationRuleOptions|FetchAutoModerationRulesOptions} [options]
-   * Options for fetching auto moderation rule(s)
-   * @returns {Promise<AutoModerationRule|Collection<Snowflake, AutoModerationRule>>}
-   * @example
-   * // Fetch all auto moderation rules from a guild without caching
-   * guild.autoModerationRules.fetch({ cache: false })
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single auto moderation rule
-   * guild.autoModerationRules.fetch('979083472868098119')
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single auto moderation rule without checking cache and without caching
-   * guild.autoModerationRules.fetch({ autoModerationRule: '979083472868098119', cache: false, force: true })
-   *   .then(console.log)
-   *   .catch(console.error)
-   */
+  
   fetch(options) {
     if (!options) return this._fetchMany();
     const { autoModerationRule, cache, force } = options;
@@ -273,12 +150,7 @@ class AutoModerationRuleManager extends CachedManager {
     );
   }
 
-  /**
-   * Deletes an auto moderation rule.
-   * @param {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to delete
-   * @param {string} [reason] The reason for deleting the auto moderation rule
-   * @returns {Promise<void>}
-   */
+  
   async delete(autoModerationRule, reason) {
     const autoModerationRuleId = this.resolveId(autoModerationRule);
     await this.client.rest.delete(Routes.guildAutoModerationRule(this.guild.id, autoModerationRuleId), { reason });

package/src/managers/BaseGuildEmojiManager.js

@@ -5,62 +5,31 @@ const GuildEmoji = require('../structures/GuildEmoji');
 const ReactionEmoji = require('../structures/ReactionEmoji');
 const { parseEmoji } = require('../util/Util');
 
-/**
- * Holds methods to resolve GuildEmojis and stores their cache.
- * @extends {CachedManager}
- */
+
 class BaseGuildEmojiManager extends CachedManager {
   constructor(client, iterable) {
     super(client, GuildEmoji, iterable);
   }
 
-  /**
-   * The cache of GuildEmojis
-   * @type {Collection<Snowflake, GuildEmoji>}
-   * @name BaseGuildEmojiManager#cache
-   */
+  
 
-  /**
-   * Data that can be resolved into a GuildEmoji object. This can be:
-   * * A Snowflake
-   * * A GuildEmoji object
-   * * A ReactionEmoji object
-   * @typedef {Snowflake|GuildEmoji|ReactionEmoji} EmojiResolvable
-   */
+  
 
-  /**
-   * Resolves an EmojiResolvable to an Emoji object.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
-   * @returns {?GuildEmoji}
-   */
+  
   resolve(emoji) {
     if (emoji instanceof ReactionEmoji) return super.resolve(emoji.id);
     return super.resolve(emoji);
   }
 
-  /**
-   * Resolves an EmojiResolvable to an Emoji id string.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
-   * @returns {?Snowflake}
-   */
+  
   resolveId(emoji) {
     if (emoji instanceof ReactionEmoji) return emoji.id;
     return super.resolveId(emoji);
   }
 
-  /**
-   * Data that can be resolved to give an emoji identifier. This can be:
-   * * An EmojiResolvable
-   * * The `<a:name:id>`, `<:name:id>`, `a:name:id` or `name:id` emoji identifier string of an emoji
-   * * The Unicode representation of an emoji
-   * @typedef {string|EmojiResolvable} EmojiIdentifierResolvable
-   */
+  
 
-  /**
-   * Resolves an EmojiResolvable to an emoji identifier.
-   * @param {EmojiIdentifierResolvable} emoji The emoji resolvable to resolve
-   * @returns {?string}
-   */
+  
   resolveIdentifier(emoji) {
     const emojiResolvable = this.resolve(emoji);
     if (emojiResolvable) return emojiResolvable.identifier;

package/src/managers/BaseManager.js

@@ -1,17 +1,9 @@
 'use strict';
 
-/**
- * Manages the API methods of a data model.
- * @abstract
- */
+
 class BaseManager {
   constructor(client) {
-    /**
-     * The client that instantiated this Manager
-     * @name BaseManager#client
-     * @type {Client}
-     * @readonly
-     */
+    
     Object.defineProperty(this, 'client', { value: client });
   }
 }

package/src/managers/CachedManager.js

@@ -2,22 +2,12 @@
 
 const DataManager = require('./DataManager');
 
-/**
- * Manages the API methods of a data model with a mutable cache of instances.
- * @extends {DataManager}
- * @abstract
- */
+
 class CachedManager extends DataManager {
   constructor(client, holds, iterable) {
     super(client, holds);
 
-    /**
-     * The private cache of items for this manager.
-     * @type {Collection}
-     * @private
-     * @readonly
-     * @name CachedManager#_cache
-     */
+    
     Object.defineProperty(this, '_cache', { value: this.client.options.makeCache(this.constructor, this.holds) });
 
     if (iterable) {
@@ -27,11 +17,7 @@ class CachedManager extends DataManager {
     }
   }
 
-  /**
-   * The cache of items for this manager.
-   * @type {Collection}
-   * @abstract
-   */
+  
   get cache() {
     return this._cache;
   }