/**
 * Initialise character count component
 *
 * @deprecated Use {@link createAll | `createAll(CharacterCount, options)`} instead.
 * @param {InitOptions & Partial<CharacterCountConfig>} [options]
 */
export function initCharacterCounts(options?: InitOptions & Partial<CharacterCountConfig>): void;
/**
 * Character count component
 *
 * Tracks the number of characters or words in the `.nhsuk-js-character-count`
 * `<textarea>` inside the element. Displays a message with the remaining number
 * of characters/words available, or the number of characters/words in excess.
 *
 * You can configure the message to only appear after a certain percentage
 * of the available characters/words has been entered.
 *
 * @augments {ConfigurableComponent<CharacterCountConfig>}
 */
export class CharacterCount extends ConfigurableComponent<CharacterCountConfig, HTMLElement> {
    /**
     * Character count functions
     *
     * @constant
     * @satisfies {Record<string, CharacterCountFunction>}
     */
    static countFunctions: Readonly<{
        /**
         * Count code points (string length)
         *
         * @param {string} text - Textarea value
         * @returns {number} Count
         */
        length(text: string): number;
        /**
         * Count grapheme clusters (user-perceived characters)
         *
         * @param {string} text - Textarea value
         * @param {CharacterCountContext} context - Object containing the config and segmenter
         * @returns {number} Count
         */
        characters(text: string, context: CharacterCountContext): number;
        /**
         * Count words
         *
         * If the (deprecated) `maxwords` option is set, count words between
         * consecutive whitespace rather than using the segmenter
         *
         * @param {string} text - Textarea value
         * @param {CharacterCountContext} context - Object containing the config and segmenter
         * @returns {number} Count
         */
        words(text: string, context: CharacterCountContext): number;
    }>;
    /**
     * Character count default config
     *
     * @see {@link CharacterCountConfig}
     * @constant
     * @type {CharacterCountConfig}
     */
    static defaults: CharacterCountConfig;
    /**
     * Character count config schema
     *
     * @constant
     * @satisfies {Schema<CharacterCountConfig>}
     */
    static schema: Readonly<{
        properties: {
            maxwords: {
                type: "number";
            };
            maxlength: {
                type: "number";
            };
            threshold: {
                type: "number";
            };
            countType: {
                type: "string";
            };
            countFunction: {
                type: "function";
            };
            textareaDescriptionClass: {
                type: "string";
            };
            visibleCountMessageClass: {
                type: "string";
            };
            screenReaderCountMessageClass: {
                type: "string";
            };
            i18n: {
                type: "object";
            };
        };
        anyOf: ({
            required: "maxwords"[];
            errorMessage: string;
        } | {
            required: "maxlength"[];
            errorMessage: string;
        })[];
    }>;
    /**
     * @param {Element | null} $root - HTML element to use for component
     * @param {Partial<CharacterCountConfig>} [config] - Character count config
     */
    constructor($root: Element | null, config?: Partial<CharacterCountConfig>);
    length: number;
    /**
     * @type {Intl.Segmenter | null}
     */
    segmenter: Intl.Segmenter | null;
    /**
     * @type {number | null}
     */
    lastInputTimestamp: number | null;
    lastInputValue: string;
    /**
     * @type {number | null}
     */
    valueChecker: number | null;
    i18n: I18n;
    countFunction: CharacterCountFunction;
    countFunctionContext: CharacterCountContext;
    maxLength: number;
    $textarea: HTMLInputElement | HTMLTextAreaElement;
    $errorMessage: Element | null;
    $screenReaderCountMessage: HTMLDivElement;
    $visibleCountMessage: HTMLDivElement;
    /**
     * Character count config override
     *
     * @param {Partial<CharacterCountConfig>} datasetConfig - Config specified by dataset
     * @returns {Partial<CharacterCountConfig>} Config to override by dataset
     */
    configOverride(datasetConfig: Partial<CharacterCountConfig>): Partial<CharacterCountConfig>;
    /**
     * Count the number of characters (or words) in the given text, using the
     * configured count type, and update the component-wide count
     *
     * @param {string} [text] - Deprecated
     */
    updateCount(text?: string): void;
    /**
     * @deprecated
     * @param {string} text - The text to count the characters of
     */
    count(text: string): number;
    /**
     * Bind change events
     *
     * Set up event listeners on the $textarea so that the count messages update
     * when the user types.
     */
    bindChangeEvents(): void;
    /**
     * Update count message if textarea value has changed
     */
    updateIfValueChanged(): void;
    /**
     * @deprecated Use {@link CharacterCount.updateIfValueChanged} instead.
     */
    checkIfValueChanged(): void;
    /**
     * Update count message
     *
     * Helper function to update both the visible and screen reader-specific
     * counters simultaneously (e.g. on init)
     */
    updateCountMessage(): void;
    /**
     * Update visible count message
     */
    updateVisibleCountMessage(): void;
    /**
     * Update screen reader count message
     */
    updateScreenReaderCountMessage(): void;
    /**
     * Get count message
     *
     * @returns {string} Status message
     */
    getCountMessage(): string;
    /**
     * @deprecated Use {@link CharacterCount.getCountMessage} instead.
     */
    formattedUpdateMessage(): string;
    /**
     * Formats the message shown to users according to what's counted
     * and how many remain
     *
     * @param {number} remainingNumber - The number of words/characters remaining
     * @param {CharacterCountConfig['countType']} [countType] - Deprecated
     * @returns {string} Status message
     */
    formatCountMessage(remainingNumber: number, countType?: CharacterCountConfig["countType"]): string;
    /**
     * Check if count is over threshold
     *
     * Checks whether the value is over the configured threshold for the input.
     * If there is no configured threshold, it is set to 0 and this function will
     * always return true.
     *
     * @returns {boolean} true if the current count is over the config.threshold
     *   (or no threshold is set)
     */
    isOverThreshold(): boolean;
    /**
     * Handle input event
     *
     * Update the visible character counter and keep track of when the last update
     * happened for each keypress
     */
    handleInput(): void;
    /**
     * @deprecated Use {@link CharacterCount.handleInput} instead.
     */
    handleKeyUp(): void;
    /**
     * Handle focus event
     *
     * Speech recognition software such as Dragon NaturallySpeaking will modify
     * the fields by directly changing its `value`. These changes don't trigger
     * events in JavaScript, so we need to poll to handle when and if they occur.
     *
     * Once the keyup event hasn't been detected for at least 1000 ms (1s), check
     * if the textarea value has changed and update the count message if it has.
     *
     * This is so that the update triggered by the manual comparison doesn't
     * conflict with debounced KeyboardEvent updates.
     */
    handleFocus(): void;
    /**
     * Handle blur event
     *
     * Stop checking the textarea value once the textarea no longer has focus
     */
    handleBlur(): void;
}
/**
 * Character count config
 */
export type CharacterCountConfig = {
    /**
     * - The maximum number of characters (or words
     * if `countType` is set to `"words"`).
     */
    maxlength?: number | undefined;
    /**
     * - Deprecated. Use `maxlength` with
     * `countType: "words"` instead.
     */
    maxwords?: number | undefined;
    /**
     * - The percentage value of the limit at
     * which point the count message is displayed. If this attribute is set, the
     * count message will be hidden by default.
     */
    threshold?: number | undefined;
    /**
     * - The count type
     * (`"characters"`, `"length"` or `"words"`) used to count the text.
     */
    countType: "characters" | "length" | "words";
    /**
     * - Custom character or
     * word counting function.
     */
    countFunction?: CharacterCountFunction | undefined;
    /**
     * - Textarea description class
     */
    textareaDescriptionClass: string;
    /**
     * - Visible count message class
     */
    visibleCountMessageClass: string;
    /**
     * - Screen reader count message class
     */
    screenReaderCountMessageClass: string;
    /**
     * - Character count translations
     */
    i18n?: CharacterCountTranslations | undefined;
};
/**
 * Character count function
 */
export type CharacterCountFunction = (text: string, context: CharacterCountContext) => number;
/**
 * Character count context
 */
export type CharacterCountContext = {
    /**
     * - Character count config
     */
    config: CharacterCountConfig;
    /**
     * - Character count segmenter
     */
    segmenter: CharacterCount["segmenter"];
};
/**
 * Messages shown to users as they type. It provides feedback on how many words
 * or characters they have remaining or if they are over the limit. This also
 * includes a message used as an accessible description for the textarea.
 */
export type CharacterCountTranslations = {
    /**
     * - Message displayed
     * when the number of characters is under the configured maximum, `maxlength`.
     * This message is displayed visually and through assistive technologies. The
     * component will replace the `%{count}` placeholder with the number of
     * remaining characters. This is a pluralised list of messages.
     */
    charactersUnderLimit?: TranslationPluralForms | undefined;
    /**
     * - Message displayed when the number of
     * characters reaches the configured maximum, `maxlength`. This message is
     * displayed visually and through assistive technologies.
     */
    charactersAtLimit?: string | undefined;
    /**
     * - Message displayed
     * when the number of characters is over the configured maximum, `maxlength`.
     * This message is displayed visually and through assistive technologies. The
     * component will replace the `%{count}` placeholder with the number of
     * remaining characters. This is a pluralised list of messages.
     */
    charactersOverLimit?: TranslationPluralForms | undefined;
    /**
     * - Message displayed when
     * the number of words is under the configured maximum, `maxlength`. This
     * message is displayed visually and through assistive technologies. The
     * component will replace the `%{count}` placeholder with the number of
     * remaining words. This is a pluralised list of messages.
     */
    wordsUnderLimit?: TranslationPluralForms | undefined;
    /**
     * - Message displayed when the number of
     * words reaches the configured maximum, `maxlength`. This message is
     * displayed visually and through assistive technologies.
     */
    wordsAtLimit?: string | undefined;
    /**
     * - Message displayed when
     * the number of words is over the configured maximum, `maxlength`. This
     * message is displayed visually and through assistive technologies. The
     * component will replace the `%{count}` placeholder with the number of
     * remaining words. This is a pluralised list of messages.
     */
    wordsOverLimit?: TranslationPluralForms | undefined;
    /**
     * - Message made
     * available to assistive technologies, if none is already present in the
     * HTML, to describe that the component accepts only a limited amount of
     * content. It is visible on the page if `countType` is not supported or
     * JavaScript is unavailable. The component will replace the `%{count}`
     * placeholder with the value of the `maxlength` parameter.
     */
    textareaDescription?: TranslationPluralForms | undefined;
};
import type { InitOptions } from '../../index.mjs';
import { ConfigurableComponent } from '../../configurable-component.mjs';
import { I18n } from '../../i18n.mjs';
import type { TranslationPluralForms } from '../../i18n.mjs';
//# sourceMappingURL=character-count.d.mts.map