cognova 0.2.6 → 0.2.8

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

@@ -1,142 +0,0 @@
-'use strict';
-
-const { Collection } = require('@discordjs/collection');
-const { Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { DiscordjsTypeError, ErrorCodes } = require('../errors');
-const ApplicationEmoji = require('../structures/ApplicationEmoji');
-const { resolveImage } = require('../util/DataResolver');
-
-/**
- * Manages API methods for ApplicationEmojis and stores their cache.
- * @extends {CachedManager}
- */
-class ApplicationEmojiManager extends CachedManager {
-  constructor(application, iterable) {
-    super(application.client, ApplicationEmoji, iterable);
-
-    /**
-     * The application this manager belongs to
-     * @type {ClientApplication}
-     */
-    this.application = application;
-  }
-
-  _add(data, cache) {
-    return super._add(data, cache, { extras: [this.application] });
-  }
-
-  /**
-   * Options used for creating an emoji of the application
-   * @typedef {Object} ApplicationEmojiCreateOptions
-   * @property {BufferResolvable|Base64Resolvable} attachment The image for the emoji
-   * @property {string} name The name for the emoji
-   */
-
-  /**
-   * Creates a new custom emoji of the application.
-   * @param {ApplicationEmojiCreateOptions} options Options for creating the emoji
-   * @returns {Promise<Emoji>} The created emoji
-   * @example
-   * // Create a new emoji from a URL
-   * application.emojis.create({ attachment: 'https://i.imgur.com/w3duR07.png', name: 'rip' })
-   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
-   *   .catch(console.error);
-   * @example
-   * // Create a new emoji from a file on your computer
-   * application.emojis.create({ attachment: './memes/banana.png', name: 'banana' })
-   *   .then(emoji => console.log(`Created new emoji with name ${emoji.name}!`))
-   *   .catch(console.error);
-   */
-  async create({ attachment, name }) {
-    attachment = await resolveImage(attachment);
-    if (!attachment) throw new DiscordjsTypeError(ErrorCodes.ReqResourceType);
-
-    const body = { image: attachment, name };
-
-    const emoji = await this.client.rest.post(Routes.applicationEmojis(this.application.id), { body });
-    return this._add(emoji);
-  }
-
-  /**
-   * Obtains one or more emojis from Discord, or the emoji cache if they're already available.
-   * @param {Snowflake} [id] The emoji's id
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<ApplicationEmoji|Collection<Snowflake, ApplicationEmoji>>}
-   * @example
-   * // Fetch all emojis from the application
-   * application.emojis.fetch()
-   *   .then(emojis => console.log(`There are ${emojis.size} emojis.`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single emoji
-   * application.emojis.fetch('222078108977594368')
-   *   .then(emoji => console.log(`The emoji name is: ${emoji.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 emoji = await this.client.rest.get(Routes.applicationEmoji(this.application.id, id));
-      return this._add(emoji, cache);
-    }
-
-    const { items: data } = await this.client.rest.get(Routes.applicationEmojis(this.application.id));
-    const emojis = new Collection();
-    for (const emoji of data) emojis.set(emoji.id, this._add(emoji, cache));
-    return emojis;
-  }
-
-  /**
-   * Deletes an emoji.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to delete
-   * @returns {Promise<void>}
-   */
-  async delete(emoji) {
-    const id = this.resolveId(emoji);
-    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
-    await this.client.rest.delete(Routes.applicationEmoji(this.application.id, id));
-  }
-
-  /**
-   * Edits an emoji.
-   * @param {EmojiResolvable} emoji The Emoji resolvable to edit
-   * @param {ApplicationEmojiEditOptions} options The options to provide
-   * @returns {Promise<ApplicationEmoji>}
-   */
-  async edit(emoji, options) {
-    const id = this.resolveId(emoji);
-    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
-
-    const newData = await this.client.rest.patch(Routes.applicationEmoji(this.application.id, id), {
-      body: {
-        name: options.name,
-      },
-    });
-    const existing = this.cache.get(id);
-    if (existing) {
-      existing._patch(newData);
-      return existing;
-    }
-    return this._add(newData);
-  }
-
-  /**
-   * Fetches the author for this emoji
-   * @param {EmojiResolvable} emoji The emoji to fetch the author of
-   * @returns {Promise<User>}
-   */
-  async fetchAuthor(emoji) {
-    const id = this.resolveId(emoji);
-    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'emoji', 'EmojiResolvable', true);
-
-    const data = await this.client.rest.get(Routes.applicationEmoji(this.application.id, id));
-
-    return this._add(data).author;
-  }
-}
-
-module.exports = ApplicationEmojiManager;

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

@@ -1,292 +0,0 @@
-'use strict';
-
-const { Collection } = require('@discordjs/collection');
-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},
-   * {@link AutoModerationRuleTriggerType.KeywordPreset},
-   * and {@link AutoModerationRuleTriggerType.MemberProfile}
-   * @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},
-   * {@link AutoModerationRuleTriggerType.MentionSpam},
-   * or {@link AutoModerationRuleTriggerType.MemberProfile}.</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,
-    triggerType,
-    triggerMetadata,
-    actions,
-    enabled,
-    exemptRoles,
-    exemptChannels,
-    reason,
-  }) {
-    const data = await this.client.rest.post(Routes.guildAutoModerationRules(this.guild.id), {
-      body: {
-        name,
-        event_type: eventType,
-        trigger_type: triggerType,
-        trigger_metadata: triggerMetadata && {
-          keyword_filter: triggerMetadata.keywordFilter,
-          regex_patterns: triggerMetadata.regexPatterns,
-          presets: triggerMetadata.presets,
-          allow_list: triggerMetadata.allowList,
-          mention_total_limit: triggerMetadata.mentionTotalLimit,
-          mention_raid_protection_enabled: triggerMetadata.mentionRaidProtectionEnabled,
-        },
-        actions: actions.map(action => ({
-          type: action.type,
-          metadata: {
-            duration_seconds: action.metadata?.durationSeconds,
-            channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
-            custom_message: action.metadata?.customMessage,
-          },
-        })),
-        enabled,
-        exempt_roles: exemptRoles?.map(exemptRole => this.guild.roles.resolveId(exemptRole)),
-        exempt_channels: exemptChannels?.map(exemptChannel => this.guild.channels.resolveId(exemptChannel)),
-      },
-      reason,
-    });
-
-    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 },
-  ) {
-    const autoModerationRuleId = this.resolveId(autoModerationRule);
-
-    const data = await this.client.rest.patch(Routes.guildAutoModerationRule(this.guild.id, autoModerationRuleId), {
-      body: {
-        name,
-        event_type: eventType,
-        trigger_metadata: triggerMetadata && {
-          keyword_filter: triggerMetadata.keywordFilter,
-          regex_patterns: triggerMetadata.regexPatterns,
-          presets: triggerMetadata.presets,
-          allow_list: triggerMetadata.allowList,
-          mention_total_limit: triggerMetadata.mentionTotalLimit,
-          mention_raid_protection_enabled: triggerMetadata.mentionRaidProtectionEnabled,
-        },
-        actions: actions?.map(action => ({
-          type: action.type,
-          metadata: {
-            duration_seconds: action.metadata?.durationSeconds,
-            channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
-            custom_message: action.metadata?.customMessage,
-          },
-        })),
-        enabled,
-        exempt_roles: exemptRoles?.map(exemptRole => this.guild.roles.resolveId(exemptRole)),
-        exempt_channels: exemptChannels?.map(exemptChannel => this.guild.channels.resolveId(exemptChannel)),
-      },
-      reason,
-    });
-
-    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;
-    const resolvedAutoModerationRule = this.resolveId(autoModerationRule ?? options);
-    if (resolvedAutoModerationRule) {
-      return this._fetchSingle({ autoModerationRule: resolvedAutoModerationRule, cache, force });
-    }
-    return this._fetchMany(options);
-  }
-
-  async _fetchSingle({ autoModerationRule, cache, force = false }) {
-    if (!force) {
-      const existing = this.cache.get(autoModerationRule);
-      if (existing) return existing;
-    }
-
-    const data = await this.client.rest.get(Routes.guildAutoModerationRule(this.guild.id, autoModerationRule));
-    return this._add(data, cache);
-  }
-
-  async _fetchMany(options = {}) {
-    const data = await this.client.rest.get(Routes.guildAutoModerationRules(this.guild.id));
-
-    return data.reduce(
-      (col, autoModerationRule) => col.set(autoModerationRule.id, this._add(autoModerationRule, options.cache)),
-      new Collection(),
-    );
-  }
-
-  /**
-   * 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 });
-  }
-}
-
-module.exports = AutoModerationRuleManager;

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

@@ -1,85 +0,0 @@
-'use strict';
-
-const CachedManager = require('./CachedManager');
-const ApplicationEmoji = require('../structures/ApplicationEmoji');
-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
-   * * An ApplicationEmoji object
-   * @typedef {Snowflake|GuildEmoji|ReactionEmoji|ApplicationEmoji} 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 this.cache.get(emoji.id) ?? null;
-    if (emoji instanceof ApplicationEmoji) return this.cache.get(emoji.id) ?? null;
-    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;
-    if (emoji instanceof ApplicationEmoji) 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;
-    if (emoji instanceof ReactionEmoji) return emoji.identifier;
-    if (emoji instanceof ApplicationEmoji) return emoji.identifier;
-    if (typeof emoji === 'string') {
-      const res = parseEmoji(emoji);
-      if (res?.name.length) {
-        emoji = `${res.animated ? 'a:' : ''}${res.name}${res.id ? `:${res.id}` : ''}`;
-      }
-      if (!emoji.includes('%')) return encodeURIComponent(emoji);
-      return emoji;
-    }
-    return null;
-  }
-}
-
-module.exports = BaseGuildEmojiManager;

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

@@ -1,19 +0,0 @@
-'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 });
-  }
-}
-
-module.exports = BaseManager;

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

@@ -1,64 +0,0 @@
-'use strict';
-
-const DataManager = require('./DataManager');
-const { MakeCacheOverrideSymbol } = require('../util/Symbols');
-
-/**
- * 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[MakeCacheOverrideSymbol] ?? this.constructor,
-        this.holds,
-        this.constructor,
-      ),
-    });
-
-    if (iterable) {
-      for (const item of iterable) {
-        this._add(item);
-      }
-    }
-  }
-
-  /**
-   * The cache of items for this manager.
-   * @type {Collection}
-   * @abstract
-   */
-  get cache() {
-    return this._cache;
-  }
-
-  _add(data, cache = true, { id, extras = [] } = {}) {
-    const existing = this.cache.get(id ?? data.id);
-    if (existing) {
-      if (cache) {
-        existing._patch(data);
-        return existing;
-      }
-      const clone = existing._clone();
-      clone._patch(data);
-      return clone;
-    }
-
-    const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
-    if (cache) this.cache.set(id ?? entry.id, entry);
-    return entry;
-  }
-}
-
-module.exports = CachedManager;

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

@@ -1,79 +0,0 @@
-'use strict';
-
-const DataManager = require('./DataManager');
-const GuildChannel = require('../structures/GuildChannel');
-
-/**
- * Manages API methods for CategoryChannels' children.
- * @extends {DataManager}
- */
-class CategoryChannelChildManager extends DataManager {
-  constructor(channel) {
-    super(channel.client, GuildChannel);
-    /**
-     * The category channel this manager belongs to
-     * @type {CategoryChannel}
-     */
-    this.channel = channel;
-  }
-
-  /**
-   * The channels that are a part of this category
-   * @type {Collection<Snowflake, GuildChannel>}
-   * @readonly
-   */
-  get cache() {
-    return this.guild.channels.cache.filter(channel => channel.parentId === this.channel.id);
-  }
-
-  /**
-   * The guild this manager belongs to
-   * @type {Guild}
-   * @readonly
-   */
-  get guild() {
-    return this.channel.guild;
-  }
-
-  /**
-   * Options for creating a channel using {@link CategoryChannelChildManager#create}.
-   * @typedef {Object} CategoryCreateChannelOptions
-   * @property {string} name The name for the new channel
-   * @property {ChannelType} [type=ChannelType.GuildText] The type of the new channel.
-   * @property {string} [topic] The topic for the new channel
-   * @property {boolean} [nsfw] Whether the new channel is NSFW
-   * @property {number} [bitrate] Bitrate of the new channel in bits (only voice)
-   * @property {number} [userLimit] Maximum amount of users allowed in the new channel (only voice)
-   * @property {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [permissionOverwrites]
-   * Permission overwrites of the new channel
-   * @property {number} [position] Position of the new channel
-   * @property {number} [rateLimitPerUser] The rate limit per user (slowmode) for the new channel in seconds
-   * @property {string} [rtcRegion] The specific region of the new channel.
-   * @property {VideoQualityMode} [videoQualityMode] The camera video quality mode of the voice channel
-   * @property {number} [defaultThreadRateLimitPerUser] The initial rate limit per user (slowmode)
-   * to set on newly created threads in a channel.
-   * @property {GuildForumTagData[]} [availableTags] The tags that can be used in this channel (forum only).
-   * @property {DefaultReactionEmoji} [defaultReactionEmoji]
-   * The emoji to show in the add reaction button on a thread in a guild forum channel.
-   * @property {ThreadAutoArchiveDuration} [defaultAutoArchiveDuration]
-   * The default auto archive duration for all new threads in this channel
-   * @property {SortOrderType} [defaultSortOrder] The default sort order mode used to order posts (forum only).
-   * @property {ForumLayoutType} [defaultForumLayout] The default layout used to display posts (forum only).
-   * @property {string} [reason] Reason for creating the new channel
-   */
-
-  /**
-   * Creates a new channel within this category.
-   * <info>You cannot create a channel of type {@link ChannelType.GuildCategory} inside a CategoryChannel.</info>
-   * @param {CategoryCreateChannelOptions} options Options for creating the new channel
-   * @returns {Promise<GuildChannel>}
-   */
-  create(options) {
-    return this.guild.channels.create({
-      ...options,
-      parent: this.channel.id,
-    });
-  }
-}
-
-module.exports = CategoryChannelChildManager;