@sapphire/plugin-subcommands 5.1.1-next.f01b974.0 → 6.0.0-next.37591c8.0

package/dist/cjs/index.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+var PluginSubcommandCooldown_cjs = require('./preconditions/PluginSubcommandCooldown.cjs');
+var Subcommand_cjs = require('./lib/Subcommand.cjs');
+var subcommandCooldown_cjs = require('./lib/precondition-resolvers/subcommandCooldown.cjs');
+var Enums_cjs = require('./lib/types/Enums.cjs');
+var Events_cjs = require('./lib/types/Events.cjs');
+var SubcommandMappings_cjs = require('./lib/types/SubcommandMappings.cjs');
+var _load_cjs = require('./listeners/_load.cjs');
+var _load_cjs$1 = require('./preconditions/_load.cjs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var subcommandCooldown_cjs__namespace = /*#__PURE__*/_interopNamespace(subcommandCooldown_cjs);
+
+// src/index.ts
+var SubcommandPreconditions = {
+  SubcommandCooldown: PluginSubcommandCooldown_cjs.PluginPrecondition
+};
+var version = "6.0.0-next.37591c8.0";
+
+exports.SubcommandPreconditionResolvers = subcommandCooldown_cjs__namespace;
+Object.defineProperty(exports, 'loadListeners', {
+  enumerable: true,
+  get: function () { return _load_cjs.loadListeners; }
+});
+Object.defineProperty(exports, 'loadPreconditions', {
+  enumerable: true,
+  get: function () { return _load_cjs$1.loadPreconditions; }
+});
+exports.SubcommandPreconditions = SubcommandPreconditions;
+exports.version = version;
+Object.keys(Subcommand_cjs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return Subcommand_cjs[k]; }
+  });
+});
+Object.keys(Enums_cjs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return Enums_cjs[k]; }
+  });
+});
+Object.keys(Events_cjs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return Events_cjs[k]; }
+  });
+});
+Object.keys(SubcommandMappings_cjs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return SubcommandMappings_cjs[k]; }
+  });
+});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";AACA,SAAS,sBAAsB,0BAAsE;AAErG,cAAc;AACd,YAAY,qCAAqC;AACjD,cAAc;AACd,cAAc;AACd,cAAc;AAEd,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAiC3B,IAAM,0BAA0B;AAAA,EACtC;AACD;AAkBO,IAAM,UAAkB","sourcesContent":["import type { CooldownOptions } from '@sapphire/framework';\nimport { PluginPrecondition as SubcommandCooldown, type SubcommandCooldownPreconditionContext } from './preconditions/PluginSubcommandCooldown';\n\nexport * from './lib/Subcommand';\nexport * as SubcommandPreconditionResolvers from './lib/precondition-resolvers/subcommandCooldown';\nexport * from './lib/types/Enums';\nexport * from './lib/types/Events';\nexport * from './lib/types/SubcommandMappings';\n\nexport { loadListeners } from './listeners/_load';\nexport { loadPreconditions } from './preconditions/_load';\n\ndeclare module 'discord.js' {\n\tinterface ClientOptions {\n\t\t/**\n\t\t * If Plugin-subcommand to load pre-included subcommand error event listeners that log any encountered errors to the {@link SapphireClient.logger} instance\n\t\t * @since 3.1.2\n\t\t * @default true\n\t\t */\n\t\tloadSubcommandErrorListeners?: boolean;\n\t\t/**\n\t\t * Sets the default cooldown time for all subcommands.\n\t\t * @remark This is separate from {@link ClientOptions.defaultCooldown} as it is only used for subcommands\n\t\t * @remark Note that for the `filteredCommands` option you have to provide it as\n\t\t * - For a subcommand without a group: `commandName.subcommandName` (e.g. `config.show`).\n\t\t * - For a subcommand with a group: `commandName.groupName.subcommandName` (e.g. `config.set.prefix`).\n\t\t * @since 5.1.0\n\t\t * @default \"No cooldown options\"\n\t\t */\n\t\tsubcommandDefaultCooldown?: CooldownOptions;\n\t}\n}\n\ndeclare module '@sapphire/framework' {\n\tinterface Preconditions {\n\t\tSubcommandCooldown: SubcommandPreconditions.SubcommandCooldownContext;\n\t}\n}\n\n/**\n * The preconditions specific to subcommands\n * @since 5.1.0\n */\nexport const SubcommandPreconditions = {\n\tSubcommandCooldown\n};\n\n/**\n * The preconditions specific to subcommands\n * @since 5.1.0\n */\nexport namespace SubcommandPreconditions {\n\t/** The context for the subcommand cooldown precondition */\n\texport type SubcommandCooldownContext = SubcommandCooldownPreconditionContext;\n}\n\n/**\n * The [@sapphire/plugin-subcommands](https://github.com/sapphiredev/plugins/blob/main/packages/subcommands) version that you are currently using.\n * An example use of this is showing it of in a bot information command.\n *\n * Note to Sapphire developers: This needs to explicitly be `string` so it is not typed as the string that gets replaced by esbuild\n */\n// eslint-disable-next-line @typescript-eslint/no-inferrable-types\nexport const version: string = '6.0.0-next.37591c8.0';\n"]}

package/dist/cjs/index.d.ts

@@ -0,0 +1,395 @@
+import * as _sapphire_framework from '@sapphire/framework';
+import { Command, Args, PreconditionContainerArray, ChatInputCommand, MessageCommand, CorePreconditions, AllFlowsPrecondition, BucketScope, UserError, MessageCommandDeniedPayload, CooldownOptions } from '@sapphire/framework';
+import { Message, CacheType, ChatInputCommandInteraction, ContextMenuCommandInteraction } from 'discord.js';
+import { RateLimitManager } from '@sapphire/ratelimits';
+
+type SubcommandMapping = SubcommandMappingMethod | SubcommandMappingGroup;
+type SubcommandMappingArray = SubcommandMapping[];
+/**
+ * Describes the mapping of all the subcommands to their respective implementations for this command.
+ */
+interface SubcommandMappingBase {
+    /**
+     * The name of this subcommand, or subcommand group
+     */
+    name: string;
+    /**
+     * Whether this subcommand mapping describes a `'method'` or `'group'`
+     * @default 'method'
+     */
+    type?: 'group' | 'method';
+}
+/**
+ * Describes how a subcommand method maps to the actual implementation of that subcommand.
+ */
+interface SubcommandMappingMethod extends SubcommandMappingBase, Pick<Command.Options, 'preconditions' | 'runIn' | 'nsfw' | 'cooldownLimit' | 'cooldownDelay' | 'cooldownScope' | 'cooldownFilteredUsers' | 'requiredClientPermissions' | 'requiredUserPermissions'> {
+    /**
+     * This subcommand mapping describes a subcommand method and can therefore only ever be `'method'`
+     */
+    type?: 'method';
+    /**
+     * Whether this is the default subcommand when none is provided.
+     *
+     * Note that this is effectively only used for Message based subcommand
+     * (those implementing {@link SubcommandMappingMethod.messageRun})
+     * because the subcommand is always provided for chat input commands.
+     */
+    default?: boolean;
+    /**
+     * The class method to call when invoking this subcommand through a **message command**,
+     * or a callback implementation of the subcommand.
+     *
+     * Note that when providing a string you have to first define the method that will be called within your function
+     * before this will allow any values. This is to ensure that the property is strictly typed to the context of the
+     * class.
+     *
+     * @example
+     * ```typescript
+     * messageRun: 'runAdminConfig'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * messageRun(message: Message) {
+     *    return message.reply(`<@${message.author.id}> has been granted admin`);
+     * }
+     * ```
+     */
+    messageRun?: string | Command['messageRun'];
+    /**
+     * The class method to call when invoking this subcommand through a **chat input command**,
+     * or a callback implementation of the subcommand.
+     *
+     * Note that when providing a string you have to first define the method that will be called within your function
+     * before this will allow any values. This is to ensure that the property is strictly typed to the context of the
+     * class.
+     *
+     * @example
+     * ```typescript
+     * chatInputRun: 'runModeratorConfig'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * chatInputRun(interaction: Subcommand.Interaction) {
+     *    return interaction.reply(`<@${interaction.user.id}> has been granted moderator`);
+     * }
+     * ```
+     */
+    chatInputRun?: string | Command['chatInputRun'];
+}
+interface SubcommandMappingGroup extends SubcommandMappingBase {
+    /**
+     * This subcommand mapping describes a subcommand group and can therefore only ever be `'group'`
+     */
+    type: 'group';
+    /**
+     * The {@link SubcommandMappingMethod}s that are contained within this subcommand group.
+     */
+    entries: SubcommandMappingMethod[];
+}
+type MessageSubcommandMappingMethod = Omit<SubcommandMappingMethod, 'messageRun'> & Required<Pick<SubcommandMappingMethod, 'messageRun'>>;
+type ChatInputCommandSubcommandMappingMethod = Omit<SubcommandMappingMethod, 'chatInputRun'> & Required<Pick<SubcommandMappingMethod, 'chatInputRun'>>;
+
+interface SubcommandOptions extends Command.Options {
+    subcommands?: SubcommandMappingArray;
+    /**
+     * Whether to add aliases for subcommands with dashes in them
+     *
+     * When this option is enabled *and* the subcommand implements `messageRun`, dashless aliases will be added.
+     *
+     * For subcommands groups both the group itself and all subcommands within the group will have dashless aliases added.
+     *
+     * @since 3.0.0
+     * @default false
+     */
+    generateDashLessAliases?: boolean;
+}
+/**
+ * The class to extends for commands that have subcommands.
+ * Specify the subcommands through the {@link Subcommand.Options.subcommands} option.
+ *
+ * Note that you should not make **all** your commands extend this class, _only_ the ones that have subcommands.
+ * The reason for this is that this class implements {@link Command.messageRun} and {@link Command.chatInputRun}
+ * which you wouldn't necessarily want to do for commands that don't have subcommands.
+ * Furthermore, it also just adds general unnecessary memory overhead.
+ */
+declare class Subcommand<PreParseReturn extends Args = Args, Options extends Subcommand.Options = Subcommand.Options> extends Command<PreParseReturn, Options> {
+    #private;
+    /**
+     * The preconditions to be run for each specified subcommand.
+     * @since 4.1.0
+     */
+    readonly subcommandPreconditions: Map<string, PreconditionContainerArray>;
+    /**
+     * The parsed subcommand mappings that were provided with the {@link SubcommandOptions.subcommands} option.
+     * This is built at construction time and is used to determine which subcommand to run.
+     */
+    parsedSubcommandMappings: SubcommandMappingArray;
+    /**
+     * Whether to use case insensitive subcommands. This is only relevant for message-command styled commands as
+     * chat input commands are always lowercase. This can be enabled through `clientOptions.caseInsensitiveCommands`.
+     */
+    caseInsensitiveSubcommands: boolean;
+    constructor(context: Subcommand.LoaderContext, options: Options);
+    onLoad(): void;
+    /**
+     * Whether this command has message-based subcommands or not
+     * @returns `true` if this command has message-based subcommands, otherwise `false`
+     */
+    supportsMessageCommands(): boolean;
+    /**
+     * Whether this command has chat input subcommands or not
+     * @returns `true` if this command has chat input subcommands, otherwise `false`
+     */
+    supportsChatInputCommands(): this is ChatInputCommand;
+    /**
+     * The method that is ran when a message-based subcommand is ran.
+     *
+     * **DO NOT** override this in your implementation of a subcommand!
+     */
+    messageRun(message: Message, args: PreParseReturn, context: MessageCommand.RunContext): Promise<void>;
+    /**
+     * The method that is ran when a chat input based subcommand is ran.
+     *
+     * **DO NOT** override this in your implementation of a subcommand!
+     */
+    chatInputRun(interaction: ChatInputCommand.Interaction, context: ChatInputCommand.RunContext): Promise<void>;
+}
+declare namespace Subcommand {
+    type Options = SubcommandOptions;
+    type JSON = Command.JSON;
+    /** @deprecated Use {@linkcode LoaderContext} instead. */
+    type Context = LoaderContext;
+    type LoaderContext = Command.LoaderContext;
+    type RunInTypes = Command.RunInTypes;
+    type ChatInputCommandInteraction<Cached extends CacheType = CacheType> = Command.ChatInputCommandInteraction<Cached>;
+    type ContextMenuCommandInteraction<Cached extends CacheType = CacheType> = Command.ContextMenuCommandInteraction<Cached>;
+    type AutocompleteInteraction<Cached extends CacheType = CacheType> = Command.AutocompleteInteraction<Cached>;
+    type Registry = Command.Registry;
+}
+
+/**
+ * The context for the subcommand cooldown precondition
+ * @since 5.1.0
+ */
+interface SubcommandCooldownPreconditionContext extends CorePreconditions.CooldownContext {
+    /** The name of the subcommand */
+    subcommandMethodName: string;
+    /** The name of the subcommand group, if any */
+    subcommandGroupName?: string;
+}
+/**
+ * The subcommand cooldown precondition. This differs from the cooldown precondition in framework by using a separate
+ * bucket as well as resolving the id differently to ensure it is specific to a subcommand.
+ * @since 5.1.0
+ */
+declare class PluginPrecondition extends AllFlowsPrecondition {
+    subcommandBuckets: WeakMap<Subcommand<_sapphire_framework.Args, SubcommandOptions>, RateLimitManager<string>>;
+    messageRun(message: Message, subcommand: Subcommand, context: SubcommandCooldownPreconditionContext): AllFlowsPrecondition.Result;
+    chatInputRun(interaction: ChatInputCommandInteraction, subcommand: Subcommand, context: SubcommandCooldownPreconditionContext): AllFlowsPrecondition.Result;
+    contextMenuRun(interaction: ContextMenuCommandInteraction, subcommand: Command, context: SubcommandCooldownPreconditionContext): AllFlowsPrecondition.Result;
+    private sharedRun;
+    private getIdFromMessage;
+    private getIdFromInteraction;
+    private getSubcommandMappingName;
+    private getManager;
+}
+
+/** The options for adding this subcommand cooldown precondition */
+interface ParseSubcommandConstructorPreConditionsCooldownParameters<PreParseReturn extends Args = Args, Options extends Subcommand.Options = Subcommand.Options> {
+    /** The command to parse cooldowns for. */
+    subcommand: Subcommand<PreParseReturn, Options>;
+    /** The cooldown limit to use. */
+    cooldownLimit: number | undefined;
+    /** The cooldown delay to use. */
+    cooldownDelay: number | undefined;
+    /** The cooldown scope to use. */
+    cooldownScope: BucketScope | undefined;
+    /** The cooldown filtered users to use. */
+    cooldownFilteredUsers: string[] | undefined;
+    /** The name this precondition is for. */
+    subcommandMethodName: string;
+    /** The group this precondition is for, if any. */
+    subcommandGroupName?: string;
+    /** The precondition container array to append the precondition to. */
+    preconditionContainerArray: PreconditionContainerArray;
+}
+/**
+ * Appends the `SubcommandCooldown` precondition when {@link Subcommand.Options.cooldownLimit} and
+ * {@link Subcommand.Options.cooldownDelay} are both non-zero.
+ *
+ * @param options The {@link ParseSubcommandConstructorPreConditionsCooldownParameters} for adding this subcommand cooldown precondition
+ */
+declare function parseSubcommandConstructorPreConditionsCooldown<PreParseReturn extends Args = Args, Options extends Subcommand.Options = Subcommand.Options>({ subcommand: command, cooldownLimit, cooldownDelay, cooldownScope, cooldownFilteredUsers, subcommandMethodName, subcommandGroupName, preconditionContainerArray }: ParseSubcommandConstructorPreConditionsCooldownParameters<PreParseReturn, Options>): void;
+
+type subcommandCooldown_ParseSubcommandConstructorPreConditionsCooldownParameters<PreParseReturn extends Args = Args, Options extends Subcommand.Options = Subcommand.Options> = ParseSubcommandConstructorPreConditionsCooldownParameters<PreParseReturn, Options>;
+declare const subcommandCooldown_parseSubcommandConstructorPreConditionsCooldown: typeof parseSubcommandConstructorPreConditionsCooldown;
+declare namespace subcommandCooldown {
+  export { type subcommandCooldown_ParseSubcommandConstructorPreConditionsCooldownParameters as ParseSubcommandConstructorPreConditionsCooldownParameters, subcommandCooldown_parseSubcommandConstructorPreConditionsCooldown as parseSubcommandConstructorPreConditionsCooldown };
+}
+
+/**
+ * The available command pre-conditions.
+ * @since 2.0.0
+ */
+declare enum SubcommandCommandPreConditions {
+    SubcommandCooldown = "SubcommandCooldown"
+}
+/**
+ * The available subcommand pre-conditions.
+ * @since 5.1.0
+ */
+declare enum SubcommandIdentifiers {
+    /** The identifier for the subcommand cooldown precondition */
+    SubcommandPreconditionCooldown = "subcommandPreconditionCooldown"
+}
+
+declare const SubcommandPluginEvents: {
+    ChatInputSubcommandDenied: "chatInputSubcommandDenied";
+    ChatInputSubcommandRun: "chatInputSubcommandRun";
+    ChatInputSubcommandSuccess: "chatInputSubcommandSuccess";
+    ChatInputSubcommandError: "chatInputSubcommandError";
+    MessageSubcommandDenied: "messageSubcommandDenied";
+    MessageSubcommandRun: "messageSubcommandRun";
+    MessageSubcommandSuccess: "messageSubcommandSuccess";
+    MessageSubcommandError: "messageSubcommandError";
+    SubcommandMappingIsMissingMessageCommandHandler: "subcommandMappingIsMissingMessageCommandHandler";
+    SubcommandMappingIsMissingChatInputCommandHandler: "subcommandMappingIsMissingChatInputCommandHandler";
+};
+declare enum SubcommandPluginIdentifiers {
+    MessageSubcommandNoMatch = "messageSubcommandNoMatch",
+    ChatInputSubcommandNoMatch = "chatInputSubcommandNoMatch",
+    SubcommandNotFound = "subcommandNotFound"
+}
+interface MessageSubcommandNoMatchContext extends MessageCommand.RunContext {
+    possibleSubcommandName: string | null;
+    possibleSubcommandGroupOrName: string | null;
+}
+interface IMessageSubcommandPayload {
+    message: Message;
+    command: Subcommand;
+}
+interface MessageSubcommandDeniedPayload extends Omit<MessageCommandDeniedPayload, 'parameters' | 'command'>, MessageSubcommandAcceptedPayload {
+    parameters?: string;
+}
+interface MessageSubcommandAcceptedPayload extends IMessageSubcommandPayload {
+    context: MessageCommand.RunContext;
+    matchedSubcommandMapping: SubcommandMappingMethod;
+}
+interface MessageSubcommandRunPayload extends MessageSubcommandAcceptedPayload {
+}
+interface MessageSubcommandErrorPayload extends MessageSubcommandRunPayload {
+}
+interface MessageSubcommandSuccessPayload extends MessageSubcommandRunPayload {
+    result: unknown;
+}
+interface IChatInputSubcommandPayload {
+    interaction: ChatInputCommand.Interaction;
+    command: Subcommand;
+}
+interface ChatInputSubcommandAcceptedPayload extends IChatInputSubcommandPayload {
+    context: ChatInputCommand.RunContext;
+    matchedSubcommandMapping: SubcommandMappingMethod;
+}
+interface ChatInputSubcommandDeniedPayload extends ChatInputSubcommandAcceptedPayload {
+}
+interface ChatInputSubcommandRunPayload extends ChatInputSubcommandAcceptedPayload {
+}
+interface ChatInputSubcommandErrorPayload extends ChatInputSubcommandRunPayload {
+}
+interface ChatInputSubcommandSuccessPayload extends ChatInputSubcommandRunPayload {
+    result: unknown;
+}
+declare module 'discord.js' {
+    interface ClientEvents {
+        [SubcommandPluginEvents.ChatInputSubcommandDenied]: [error: UserError, payload: ChatInputSubcommandDeniedPayload];
+        [SubcommandPluginEvents.ChatInputSubcommandRun]: [
+            interaction: ChatInputCommand.Interaction,
+            subcommand: ChatInputCommandSubcommandMappingMethod,
+            payload: ChatInputSubcommandRunPayload
+        ];
+        [SubcommandPluginEvents.ChatInputSubcommandSuccess]: [
+            interaction: ChatInputCommand.Interaction,
+            subcommand: ChatInputCommandSubcommandMappingMethod,
+            payload: ChatInputSubcommandSuccessPayload
+        ];
+        [SubcommandPluginEvents.ChatInputSubcommandError]: [error: unknown, payload: ChatInputSubcommandErrorPayload];
+        [SubcommandPluginEvents.MessageSubcommandDenied]: [error: UserError, payload: MessageSubcommandDeniedPayload];
+        [SubcommandPluginEvents.MessageSubcommandRun]: [
+            message: Message,
+            subcommand: MessageSubcommandMappingMethod,
+            payload: MessageSubcommandRunPayload
+        ];
+        [SubcommandPluginEvents.MessageSubcommandSuccess]: [
+            message: Message,
+            subcommand: MessageSubcommandMappingMethod,
+            payload: MessageSubcommandSuccessPayload
+        ];
+        [SubcommandPluginEvents.MessageSubcommandError]: [error: unknown, payload: MessageSubcommandErrorPayload];
+        [SubcommandPluginEvents.SubcommandMappingIsMissingMessageCommandHandler]: [
+            message: Message,
+            subcommand: SubcommandMappingMethod,
+            payload: MessageSubcommandAcceptedPayload
+        ];
+        [SubcommandPluginEvents.SubcommandMappingIsMissingChatInputCommandHandler]: [
+            message: ChatInputCommand.Interaction,
+            subcommand: SubcommandMappingMethod,
+            payload: ChatInputSubcommandAcceptedPayload
+        ];
+    }
+}
+
+declare function loadListeners(): void;
+
+declare function loadPreconditions(): void;
+
+declare module 'discord.js' {
+    interface ClientOptions {
+        /**
+         * If Plugin-subcommand to load pre-included subcommand error event listeners that log any encountered errors to the {@link SapphireClient.logger} instance
+         * @since 3.1.2
+         * @default true
+         */
+        loadSubcommandErrorListeners?: boolean;
+        /**
+         * Sets the default cooldown time for all subcommands.
+         * @remark This is separate from {@link ClientOptions.defaultCooldown} as it is only used for subcommands
+         * @remark Note that for the `filteredCommands` option you have to provide it as
+         * - For a subcommand without a group: `commandName.subcommandName` (e.g. `config.show`).
+         * - For a subcommand with a group: `commandName.groupName.subcommandName` (e.g. `config.set.prefix`).
+         * @since 5.1.0
+         * @default "No cooldown options"
+         */
+        subcommandDefaultCooldown?: CooldownOptions;
+    }
+}
+declare module '@sapphire/framework' {
+    interface Preconditions {
+        SubcommandCooldown: SubcommandPreconditions.SubcommandCooldownContext;
+    }
+}
+/**
+ * The preconditions specific to subcommands
+ * @since 5.1.0
+ */
+declare const SubcommandPreconditions: {
+    SubcommandCooldown: typeof PluginPrecondition;
+};
+/**
+ * The preconditions specific to subcommands
+ * @since 5.1.0
+ */
+declare namespace SubcommandPreconditions {
+    /** The context for the subcommand cooldown precondition */
+    type SubcommandCooldownContext = SubcommandCooldownPreconditionContext;
+}
+/**
+ * The [@sapphire/plugin-subcommands](https://github.com/sapphiredev/plugins/blob/main/packages/subcommands) version that you are currently using.
+ * An example use of this is showing it of in a bot information command.
+ *
+ * Note to Sapphire developers: This needs to explicitly be `string` so it is not typed as the string that gets replaced by esbuild
+ */
+declare const version: string;
+
+export { type ChatInputCommandSubcommandMappingMethod, type ChatInputSubcommandAcceptedPayload, type ChatInputSubcommandDeniedPayload, type ChatInputSubcommandErrorPayload, type ChatInputSubcommandRunPayload, type ChatInputSubcommandSuccessPayload, type IChatInputSubcommandPayload, type IMessageSubcommandPayload, type MessageSubcommandAcceptedPayload, type MessageSubcommandDeniedPayload, type MessageSubcommandErrorPayload, type MessageSubcommandMappingMethod, type MessageSubcommandNoMatchContext, type MessageSubcommandRunPayload, type MessageSubcommandSuccessPayload, Subcommand, SubcommandCommandPreConditions, SubcommandIdentifiers, type SubcommandMapping, type SubcommandMappingArray, type SubcommandMappingGroup, type SubcommandMappingMethod, type SubcommandOptions, SubcommandPluginEvents, SubcommandPluginIdentifiers, subcommandCooldown as SubcommandPreconditionResolvers, SubcommandPreconditions, loadListeners, loadPreconditions, version };