js-discord-modularcommand 1.1.0 → 2.0.0

package/dist/modularbutton.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Contains the structure for creating reusable button components.
+ * @author vicentefelipechile
+ * @license MIT
+ */
+import { ButtonBuilder, ButtonStyle } from "discord.js";
+import { ButtonExecuteFunction } from "./types";
+/**
+ * @class ModularButton
+ * @description A class to create and manage reusable button components.
+ */
+export default class ModularButton {
+    /** The Discord.js ButtonBuilder instance. */
+    buttonObject: ButtonBuilder;
+    /** The custom ID for the button, used to identify it in interactions. */
+    customId: string;
+    /** The visual style of the button. */
+    style: ButtonStyle;
+    /** The function to execute when the button is clicked. */
+    execute: ButtonExecuteFunction;
+    /**
+     * @description Creates a new ModularButton instance.
+     * @param {string} customId The custom ID for the button. This should be unique within the context of a message.
+     * @param {ButtonStyle} style The visual style of the button.
+     */
+    constructor(customId: string, style: ButtonStyle);
+    /**
+     * @description Sets the execution function for the button's click event.
+     * @param {ButtonExecuteFunction} executeFunction The function to run when the button is interacted with.
+     * @returns {this} The current ModularButton instance for method chaining.
+     */
+    setExecute(executeFunction: ButtonExecuteFunction): this;
+}

package/dist/modularbutton.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * @file Contains the structure for creating reusable button components.
+ * @author vicentefelipechile
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+// =================================================================================================
+// Main Class
+// =================================================================================================
+/**
+ * @class ModularButton
+ * @description A class to create and manage reusable button components.
+ */
+class ModularButton {
+    /**
+     * @description Creates a new ModularButton instance.
+     * @param {string} customId The custom ID for the button. This should be unique within the context of a message.
+     * @param {ButtonStyle} style The visual style of the button.
+     */
+    constructor(customId, style) {
+        /** The function to execute when the button is clicked. */
+        this.execute = async () => { };
+        this.buttonObject = new discord_js_1.ButtonBuilder()
+            .setCustomId(customId)
+            .setStyle(style);
+        this.customId = customId;
+        this.style = style;
+    }
+    /**
+     * @description Sets the execution function for the button's click event.
+     * @param {ButtonExecuteFunction} executeFunction The function to run when the button is interacted with.
+     * @returns {this} The current ModularButton instance for method chaining.
+     */
+    setExecute(executeFunction) {
+        this.execute = executeFunction;
+        return this;
+    }
+}
+exports.default = ModularButton;

package/dist/modularcommand.d.ts

@@ -6,90 +6,10 @@
 /**
  * Imports
  */
-import { ApplicationCommandOptionType, MessageComponentInteraction, ChatInputCommandInteraction, ModalSubmitInteraction, SlashCommandBuilder, ButtonBuilder, Locale, Message, ButtonStyle, Channel, User, Role, GuildMember, LocalizationMap, APIApplicationCommandOptionChoice } from 'discord.js';
+import { LocalizationMap, ButtonStyle, Locale } from 'discord.js';
 import ModularModal from './modularmodal.js';
-/**
- * Types
- */
-type ArgType = string | number | boolean | User | Channel | Role | GuildMember;
-type ExecuteFunction<T extends ChatInputCommandInteraction | MessageComponentInteraction> = (params: {
-    interaction: T;
-    args?: Record<string, ArgType>;
-    command: ModularCommand;
-    locale: Record<string, any>;
-}) => Promise<void>;
-type ButtonExecuteFunction = (params: {
-    interaction: MessageComponentInteraction;
-    command: ModularCommand;
-    locale: Record<string, any>;
-    message: Message;
-}) => Promise<void>;
-type ModalExecuteFunction = (params: {
-    interaction: ModalSubmitInteraction;
-    args: Record<string, string>;
-    command: ModularCommand;
-    locale: Record<string, any>;
-}) => Promise<void>;
-type PermissionCheckFunction = (params: {
-    interaction: ChatInputCommandInteraction;
-}) => boolean | Promise<boolean>;
-/**
- * @description Registered Command as object to be used outside the modular command system.
- * @example
- * const PingCommand = new ModularCommand('ping');
- *
- * PingCommand.setExecute(({interaction}) => {
- *     interaction.reply('Pong!');
- * });
- *
- * const cmds = RegisterCommand([PingCommand])
- * const cmd = cmds[0];
- * console.log(cmd.execute); // [Function: execute]
- */
-type RegisteredCommand = {
-    data: SlashCommandBuilder;
-    execute: (interaction: ChatInputCommandInteraction) => Promise<void>;
-    componentExecute?: (interaction: MessageComponentInteraction) => Promise<void>;
-    modalExecute?: (interaction: ModalSubmitInteraction) => Promise<void>;
-    buttonExecute?: (interaction: MessageComponentInteraction) => Promise<void>;
-    cooldown: number;
-};
-/**
- * Interface
- */
-/**
- * @description Represents a command option for a modular command.
- */
-interface CommandOption {
-    name: string;
-    type: ApplicationCommandOptionType;
-    description: Record<Locale, string> | string;
-    required?: boolean;
-    choices?: APIApplicationCommandOptionChoice[];
-}
-/**
- * @class ModularButton
- * @description Represents a modular button that can be registered with Discord.js.
- * It allows for dynamic button creation and execution.
- */
-declare class ModularButton {
-    buttonObject: ButtonBuilder;
-    customId: string;
-    style: ButtonStyle;
-    execute: ButtonExecuteFunction;
-    /**
-     * Creates a new button for the command.
-     * @param {string} customId The custom ID for the button.
-     * @param {ButtonStyle} style The style of the button.
-     */
-    constructor(customId: string, style: ButtonStyle);
-    /**
-     * Sets the execute function for the button.
-     * @param {ButtonExecuteFunction} executeFunction The function to execute.
-     * @return {ModularButton} The button instance for chaining.
-     */
-    setExecute(executeFunction: ButtonExecuteFunction): this;
-}
+import ModularButton from './modularbutton.js';
+import { ButtonExecuteFunction, CommandExecuteFunction, CommandOption, ComponentExecuteFunction, ModalExecuteFunction, PermissionCheckFunction } from './types.js';
 /**
  * @description Represents a modular command that can be registered with Discord.js.
  * It allows for dynamic command creation and execution.
@@ -110,22 +30,23 @@ declare class ModularButton {
  *     PingCommand
  * ]);
  */
-declare class ModularCommand {
+export default class ModularCommand {
     name: string;
     description: string;
-    execute: ExecuteFunction<ChatInputCommandInteraction>;
-    componentExecute?: ExecuteFunction<MessageComponentInteraction>;
+    execute: CommandExecuteFunction;
+    buttonExecute?: ButtonExecuteFunction;
+    componentExecute?: ComponentExecuteFunction;
     modalExecute?: ModalExecuteFunction;
     options: CommandOption[];
     optionsLocalizations: Record<string, Record<Locale, string>>;
-    customIdHandlers: Record<string, ExecuteFunction<ChatInputCommandInteraction>>;
+    customIdHandlers: Record<string, CommandExecuteFunction>;
     cooldown: number;
     modals: Map<string, ModularModal>;
     buttons: Map<string, ModularButton>;
     buttonsArray: ModularButton[];
     isNSFW: boolean;
     descriptionLocalizations?: LocalizationMap;
-    localizationPhrases?: Record<Locale, any>;
+    localizationPhrases?: Record<Locale, string>;
     permissionCheck?: PermissionCheckFunction;
     componentId?: string;
     constructor(name: string);
@@ -144,23 +65,23 @@ declare class ModularCommand {
     setLocalizationOptions(localizations: Record<string, Record<Locale, string>>): this;
     /**
      * Sets the localization phrases for the command.
-     * @param {Record<Locale, any>} localizationPhrases The localization phrases.
+     * @param {Record<Locale, string>} localizationPhrases The localization phrases.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    setLocalizationPhrases(localizationPhrases: Record<Locale, any>): this;
+    setLocalizationPhrases(localizationPhrases: Record<Locale, string>): this;
     /**
      * Sets the execute function for the command.
-     * @param {ExecuteFunction<CommandInteraction>} executeFunction The function to execute.
+     * @param {CommandExecuteFunction} executeFunction The function to execute.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    setExecute(executeFunction: ExecuteFunction<ChatInputCommandInteraction>): this;
+    setExecute(executeFunction: CommandExecuteFunction): this;
     /**
      * Sets the component execute function for the command.
      * @param {string} componentId The base ID for the components.
-     * @param {ExecuteFunction<MessageComponentInteraction>} executeFunction The function to execute for component interactions.
+     * @param {ComponentExecuteFunction} executeFunction The function to execute for component interactions.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    setComponentExecute(componentId: string, executeFunction: ExecuteFunction<MessageComponentInteraction>): this;
+    setComponentExecute(componentId: string, executeFunction: ComponentExecuteFunction): this;
     /**
      * Set the minimun permissions required to execute the command.
      * @param {PermissionCheckFunction} permissionCheckFunction The function to check permissions.
@@ -187,10 +108,10 @@ declare class ModularCommand {
     /**
      * Adds a custom ID handler for the command.
      * @param {string} customId The custom ID to match.
-     * @param {ExecuteFunction<CommandInteraction<CacheType>>} handlerFunction The function to execute when the custom ID matches.
+     * @param {CommandInteraction<CacheType>} handlerFunction The function to execute when the custom ID matches.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    addCustomIDHandler(customId: string, handlerFunction: ExecuteFunction<ChatInputCommandInteraction>): this;
+    addCustomIDHandler(customId: string, handlerFunction: CommandExecuteFunction): this;
     /**
      * Creates a new modal for the command.
      * @param {string} modalId The ID for the modal.
@@ -205,11 +126,3 @@ declare class ModularCommand {
      */
     addButton(customId: string, style: ButtonStyle): ModularButton;
 }
-/**
- * Registers an array of modular commands.
- * @param {ModularCommand[]} commands An array of ModularCommand instances.
- * @returns {RegisteredCommand[]} An array of command data objects ready for Discord.js client.
- */
-declare const RegisterCommand: (commands: ModularCommand[]) => RegisteredCommand[];
-export default ModularCommand;
-export { RegisterCommand, ModularCommand, ModularButton, };

package/dist/modularcommand.js

@@ -8,14 +8,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModularButton = exports.ModularCommand = exports.RegisterCommand = void 0;
 /**
  * Imports
  */
 const discord_js_1 = require("discord.js");
-const locales_js_1 = require("./locales.js");
-const locales_js_2 = require("./locales.js");
 const modularmodal_js_1 = __importDefault(require("./modularmodal.js"));
+const modularbutton_js_1 = __importDefault(require("./modularbutton.js"));
+/**
+ * Interface
+ */
+/**
+ * @description Represents a command option for a modular command.
+ */
 /**
  * Variables
  */
@@ -27,37 +31,6 @@ const ALLOWED_OPTION_TYPE = [
     discord_js_1.ApplicationCommandOptionType.User,
     discord_js_1.ApplicationCommandOptionType.Channel,
 ];
-const COOLDOWNS_MAP = new Map();
-/**
- * @class ModularButton
- * @description Represents a modular button that can be registered with Discord.js.
- * It allows for dynamic button creation and execution.
- */
-class ModularButton {
-    /**
-     * Creates a new button for the command.
-     * @param {string} customId The custom ID for the button.
-     * @param {ButtonStyle} style The style of the button.
-     */
-    constructor(customId, style) {
-        this.execute = async () => { };
-        this.buttonObject = new discord_js_1.ButtonBuilder();
-        this.buttonObject.setCustomId(customId);
-        this.buttonObject.setStyle(style);
-        this.customId = customId;
-        this.style = style;
-    }
-    /**
-     * Sets the execute function for the button.
-     * @param {ButtonExecuteFunction} executeFunction The function to execute.
-     * @return {ModularButton} The button instance for chaining.
-     */
-    setExecute(executeFunction) {
-        this.execute = executeFunction;
-        return this;
-    }
-}
-exports.ModularButton = ModularButton;
 /**
  * @description Represents a modular command that can be registered with Discord.js.
  * It allows for dynamic command creation and execution.
@@ -119,7 +92,7 @@ class ModularCommand {
     }
     /**
      * Sets the localization phrases for the command.
-     * @param {Record<Locale, any>} localizationPhrases The localization phrases.
+     * @param {Record<Locale, string>} localizationPhrases The localization phrases.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationPhrases(localizationPhrases) {
@@ -128,7 +101,7 @@ class ModularCommand {
     }
     /**
      * Sets the execute function for the command.
-     * @param {ExecuteFunction<CommandInteraction>} executeFunction The function to execute.
+     * @param {CommandExecuteFunction} executeFunction The function to execute.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setExecute(executeFunction) {
@@ -138,7 +111,7 @@ class ModularCommand {
     /**
      * Sets the component execute function for the command.
      * @param {string} componentId The base ID for the components.
-     * @param {ExecuteFunction<MessageComponentInteraction>} executeFunction The function to execute for component interactions.
+     * @param {ComponentExecuteFunction} executeFunction The function to execute for component interactions.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setComponentExecute(componentId, executeFunction) {
@@ -186,7 +159,7 @@ class ModularCommand {
     /**
      * Adds a custom ID handler for the command.
      * @param {string} customId The custom ID to match.
-     * @param {ExecuteFunction<CommandInteraction<CacheType>>} handlerFunction The function to execute when the custom ID matches.
+     * @param {CommandInteraction<CacheType>} handlerFunction The function to execute when the custom ID matches.
      * @returns {ModularCommand} The command instance for chaining.
      */
     addCustomIDHandler(customId, handlerFunction) {
@@ -210,205 +183,10 @@ class ModularCommand {
      * @return {ModularButton} The created button instance.
      */
     addButton(customId, style) {
-        const button = new ModularButton(customId, style);
+        const button = new modularbutton_js_1.default(customId, style);
         this.buttons.set(customId, button);
         this.buttonsArray.push(button);
         return button;
     }
 }
-exports.ModularCommand = ModularCommand;
-/**
- * Registers an array of modular commands.
- * @param {ModularCommand[]} commands An array of ModularCommand instances.
- * @returns {RegisteredCommand[]} An array of command data objects ready for Discord.js client.
- */
-const RegisterCommand = (commands) => {
-    return commands.map(command => {
-        const commandBuilder = new discord_js_1.SlashCommandBuilder()
-            .setName(command.name)
-            .setDescription(command.description)
-            .setDescriptionLocalizations(command.descriptionLocalizations || null);
-        COOLDOWNS_MAP.set(command.name, new Map());
-        const options = {};
-        command.options.forEach(opt => {
-            const description = typeof opt.description === 'string' ?
-                opt.description :
-                (opt.description[discord_js_1.Locale.EnglishUS] || `The description for ${opt.name} in English.`);
-            const descriptionsLocalizations = typeof opt.description === 'object' ? opt.description : {};
-            if (!description) {
-                throw new Error(`Option '${opt.name}' is missing a description.`);
-            }
-            options[opt.name] = opt.type;
-            const optionBuilder = (option) => {
-                option.setName(opt.name)
-                    .setDescription(description)
-                    .setRequired(opt.required || false)
-                    .setDescriptionLocalizations(descriptionsLocalizations);
-                if (opt.choices && opt.choices.length > 0) {
-                    option.addChoices(...opt.choices);
-                }
-                return option;
-            };
-            switch (opt.type) {
-                case discord_js_1.ApplicationCommandOptionType.String:
-                    commandBuilder.addStringOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Boolean:
-                    commandBuilder.addBooleanOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Integer:
-                    commandBuilder.addIntegerOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Number:
-                    commandBuilder.addNumberOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.User:
-                    commandBuilder.addUserOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Channel:
-                    commandBuilder.addChannelOption(optionBuilder);
-                    break;
-                default:
-                    throw new Error(`Unsupported option type: ${opt.type}`);
-            }
-        });
-        const executeBuilder = async (interaction) => {
-            // User has permissions
-            if (command.permissionCheck && !command.permissionCheck({ interaction })) {
-                await interaction.reply({
-                    content: locales_js_1.LOCALE_FORBIDDEN[interaction.locale],
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
-            }
-            // User is using a NSFW command in a non-NSFW channel
-            if (command.isNSFW && (!interaction.channel || !('nsfw' in interaction.channel) || !interaction.channel.nsfw)) {
-                await interaction.reply({
-                    content: locales_js_1.LOCALE_NSFW[interaction.locale],
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
-            }
-            // User is in a cooldown
-            const lastTime = COOLDOWNS_MAP.get(command.name)?.get(interaction.user.id);
-            if (lastTime) {
-                const cooldownDuration = (Date.now() / 1000) - lastTime;
-                if (cooldownDuration < command.cooldown) {
-                    await interaction.reply({
-                        content: (0, locales_js_2.FormatSecondsLocale)(locales_js_1.LOCALE_DELAY[interaction.locale], command.cooldown - cooldownDuration),
-                        flags: discord_js_1.MessageFlags.Ephemeral,
-                    });
-                    return;
-                }
-                COOLDOWNS_MAP.get(command.name)?.set(interaction.user.id, Date.now() / 1000);
-            }
-            const args = {};
-            for (const option of Object.keys(options)) {
-                switch (options[option]) {
-                    case discord_js_1.ApplicationCommandOptionType.String:
-                        args[option] = interaction.options.getString(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Boolean:
-                        args[option] = interaction.options.getBoolean(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Integer:
-                        args[option] = interaction.options.getInteger(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Number:
-                        args[option] = interaction.options.getNumber(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.User:
-                        args[option] = interaction.options.getUser(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Channel:
-                        args[option] = interaction.options.getChannel(option, false);
-                        break;
-                    default:
-                        throw new Error(`Unsupported option type: ${options[option]}`);
-                }
-            }
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            const customId = interaction.customId;
-            if (customId && command.customIdHandlers[customId]) {
-                await command.customIdHandlers[customId]({
-                    interaction,
-                    args,
-                    command,
-                    locale: localeTable ? localeTable[localeTarget] : {},
-                });
-            }
-            else {
-                await command.execute({
-                    interaction,
-                    args,
-                    command,
-                    locale: localeTable ? localeTable[localeTarget] : {},
-                });
-            }
-        };
-        const componentExecuteBuilder = async (interaction) => {
-            if (!command.componentExecute)
-                return;
-            if (!interaction.customId.startsWith(command.getComponentId()))
-                return;
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await command.componentExecute({
-                interaction,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-            });
-        };
-        const modalExecuteBuilder = async (interaction) => {
-            const modalId = interaction.customId;
-            const modalObject = command.modals.get(modalId);
-            if (!modalObject)
-                return;
-            const args = {};
-            for (const [id] of modalObject.modalInputs.entries()) {
-                args[id] = interaction.fields.getTextInputValue(id);
-            }
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await modalObject.execute({
-                interaction,
-                args,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-            });
-        };
-        const buttonExecuteBuilder = async (interaction) => {
-            const buttonId = interaction.customId;
-            const buttonObject = command.buttons.get(buttonId);
-            if (!buttonObject)
-                return;
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await buttonObject.execute({
-                interaction,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-                message: interaction.message,
-            });
-        };
-        return {
-            data: commandBuilder,
-            execute: executeBuilder,
-            componentExecute: command.componentExecute ? componentExecuteBuilder : undefined,
-            modalExecute: command.modals.size > 0 ? modalExecuteBuilder : undefined,
-            buttonExecute: command.buttons.size > 0 ? buttonExecuteBuilder : undefined,
-            cooldown: command.cooldown,
-        };
-    });
-};
-exports.RegisterCommand = RegisterCommand;
 exports.default = ModularCommand;

package/dist/modularlocale.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @module ModularLocale
+ * @description Generic localization phrases used throughout the application.
+ * @license MIT
+ */
+import { Locale } from "discord.js";
+/**
+ * @description Class to handle localization in a modular way.
+ */
+declare class ModularLocale {
+    locale: Locale;
+    phrases: Record<string, string>;
+    seconds: Record<string, string>;
+    minutes: Record<string, string>;
+    constructor(locale: Locale);
+    /**
+     * Set the singular and plural forms for seconds.
+     * @param {string} singular The singular form (e.g., '{s} segundo').
+     * @param {string} plural The plural form (e.g., '{s} segundos').
+     * @returns {ModularLocale}
+     */
+    setSeconds(singular: string, plural: string): this;
+    /**
+     * Set the singular and plural forms for minutes.
+     * @param {string} singular The singular form (e.g., '{m} minuto').
+     * @param {string} plural The plural form (e.g., '{m} minutos').
+     * @returns {ModularLocale}
+     */
+    setMinutes(singular: string, plural: string): this;
+    /**
+     * Set the main phrase for the command delay.
+     * @param {string} phrase The phrase when only seconds or minutes are present.
+     * @returns {ModularLocale}
+     */
+    setPhrase(phrase: string): this;
+    /**
+     * Set the phrase when both seconds and minutes are present.
+     * @param {string} phrase The phrase for combined time.
+     * @returns {ModularLocale}
+     */
+    setPhrasePlural(phrase: string): this;
+    /**
+     * Set the phrase when only minutes are present.
+     * @param {string} phrase The phrase for when only minutes are present.
+     * @returns {ModularLocale}
+     */
+    setPhraseOnlyMinutes(phrase: string): this;
+    getPhrase: () => Record<string, string>;
+    getSeconds: () => Record<string, string>;
+    getMinutes: () => Record<string, string>;
+    /**
+     * Get the formatted phrase based on the time.
+     * @param {number} time The time in seconds.
+     * @returns {string} The formatted string.
+     */
+    formatTime(time: number): string;
+}
+/**
+ * @description Localization phrases for delay commands in ModularLocale structure.
+ * @example ```js
+ * const phrase = LOCALE_DELAY[Locale.EnglishUS];
+ * console.log( phrase.formatTime(64) );    // 'You must wait 4 seconds and 1 minute.'
+ * console.log( phrase.formatTime(390) );   // 'You must wait 30 seconds and 6 minutes.'
+ * console.log( phrase.formatTime(1) );     // 'You must wait 1 second.'
+ * console.log( phrase.formatTime(120) );   // 'You must wait 2 minutes.'
+ * ```
+ */
+declare const LOCALE_DELAY: {
+    "es-419": ModularLocale;
+    "en-US": ModularLocale;
+    "en-GB": ModularLocale;
+    "es-ES": ModularLocale;
+    "pt-BR": ModularLocale;
+    fr: ModularLocale;
+    de: ModularLocale;
+    it: ModularLocale;
+    ru: ModularLocale;
+    "zh-CN": ModularLocale;
+    "zh-TW": ModularLocale;
+    ja: ModularLocale;
+    ko: ModularLocale;
+    bg: ModularLocale;
+    cs: ModularLocale;
+    da: ModularLocale;
+    nl: ModularLocale;
+    fi: ModularLocale;
+    hu: ModularLocale;
+    no: ModularLocale;
+    pl: ModularLocale;
+    ro: ModularLocale;
+    "sv-SE": ModularLocale;
+    tr: ModularLocale;
+    uk: ModularLocale;
+    hi: ModularLocale;
+    id: ModularLocale;
+    el: ModularLocale;
+    hr: ModularLocale;
+    lt: ModularLocale;
+    th: ModularLocale;
+    vi: ModularLocale;
+};
+export default LOCALE_DELAY;
+export { LOCALE_DELAY, ModularLocale };