/**
 * `MaskFormatter` é usado para formatar strings. Seu comportamento
 * é controlado pelo formato do atributo `mask` que especifica quais
 * caracteres são válidos e onde devem estar posicionados, intercalando-os
 * com eventuais caracteres literais expressados no padrão informado.
 * Sua implementação é inspirada pela implementação em Java do [MaskFormatter](https://docs.oracle.com/javase/7/docs/api/javax/swing/text/MaskFormatter.html).
 *
 * Para o padrão da máscara podem ser usados os seguintes caracteres especiais:
 *
 * | Caractere | Comportamento                                                                                               |
 * |:---------:|-------------------------------------------------------------------------------------------------------------|
 * | #         | Qualquer número                                                                                             |
 * | '         | "Escapa" o caractere que vem na sequência. Útil quando desejamos converter um caractere especial em literal.|
 * | U         | Qualquer letra. Transforma letras minúsculas em maiúsculas.                                                 |
 * | L         | Qualquer letra. Transforma letras maiúsculas em minúsculas.                                                 |
 * | A         | Qualquer letra ou número.                                                                                   |
 * | Z         | Qualquer letra ou número. Transforma letras minúsculas em maiúsculas.                                       |
 * | ?         | Qualquer letra. Preserva maiúsculas e minúsculas.                                                           |
 * | *         | Qualquer caractere.                                                                                         |
 *
 * Os demais caracteres presentes no padrão serão tratados como literais, isto é,
 * serão apenas inseridos naquela posição.
 *
 * Quando o valor a ser formatado é menor que a máscara, um 'placeHolder'
 * será inserido em cada posição ausente, completando a formatação.
 * Por padrão será usado um espaço em branco como 'placeHolder', mas
 * esse valor pode ser alterado.
 *
 * Por exemplo:
 * '''
 *    const formatter: MaskFormatter = new MaskFormatter("###-####");
 *    formatter.placeholder = '_';
 *    console.log(formatter.format("123"));
 * '''
 * resultaria na string '123-____'.
 *
 * ##Veja mais alguns exemplos:
 * |Padrão          |Máscara           |Entrada       |Saída              |
 * |----------------|------------------|--------------|-------------------|
 * |Telefone        |(##) ####-####    |3432192515    |(34) 3219-2515     |
 * |CPF             |###.###.###-##    |12345678901   |123.456.789-01     |
 * |CNPJ            |ZZ.ZZZ.ZZZ/ZZZZ-##|1a3B5c7D9e1F31|1A.3B5.C7D9/E1F3-31|
 * |CEP             |##.###-###        |12345678      |12.345-678         |
 * |PLACA (veículo) |UUU-####          |abc1234       |ABC-1234           |
 * |Cor RGB         |'#AAAAAA        |00000F0       |#0000F0            |
 *
 */
export declare class MaskFormatter {
    private static DIGIT_KEY;
    private static LITERAL_KEY;
    private static UPPERCASE_KEY;
    private static LOWERCASE_KEY;
    private static ALPHA_NUMERIC_KEY;
    private static ALPHA_NUMERIC_UPPERCASE_KEY;
    private static CHARACTER_KEY;
    private static ANYTHING_KEY;
    static DEFAULT_MASKS: any;
    private _mask;
    private _maskChars;
    /**
     * Determina qual caractere será usado dos caracteres não presentes no valor,
     * ou seja, aqueles que o usuário ainda não informou. Por padrão usamos um espaço.
     */
    placeholder: string;
    /**
     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
     */
    set mask(mask: string);
    /**
     * Getter para mask.
     *
     * @return A última máscara informada.
     */
    get mask(): string;
    constructor(mask: string);
    /**
    * Aplica a máscara quando o input é alterado
    *
    * @param value Valor a ser aplicado com a máscara.
    * @return O valor processado de acordo com o padrão.
    */
    applyMask(value: string): string;
    /**
     * Remove a máscara formatando a string retornando sem máscara
     *
     * @param value Valor a ser formatado com máscara.
     * @return O valor processado de acordo com o padrão.
     */
    removeMask(value: string): string;
    /**
     * Formata a string passada baseada na máscara definda pelo atributo mask.
     *
     * @param value Valor a ser formatado.
     * @param trimBefore Executa um trim para remover espaços em branco.
     * @return O valor processado de acordo com o padrão.
     */
    format(value: string, trimBefore?: boolean): string;
    /**
     * Prepara a formatação internamente de acordo com o padrão.
     */
    private updateInternalMask;
    static MaskCharacter: {
        new (maskFormatter: MaskFormatter, type: string): {
            maskFormatter: MaskFormatter;
            type: string;
            /**
             * Cada subclasse deve sobrescrever retornando true caso represente.
             * um caractere literal. Por padrão o retorno é false.
             */
            isLiteral(): boolean;
            /**
             * Retorna se é um texto válido.
             *
             * @param aChar - Valor a ser validado.
             * @returns - Retorna se é um texto válido.
             */
            isValidCharacter(aChar: string): boolean;
            /**
             * Retorna o texto informado.
             *
             * @param aChar - Texto a ser retornado.
             * @returns - Texto informado.
             */
            getChar(aChar: string): string;
            /**
             * Adiciona valor encontrado.
             *
             * @param result - String a ser manipulada.
             * @param formatting - String de formatação a ser adicionada na result.
             * @param index - Índice que será utilizado para buscar no parâmetro formatting.
             *
             * @returns - Valor passado na result incrementado com o valor encontrado na formatting.
             *
             * @example
             * ```  const result = "";
             *       const formatting = "123456";
             *       const index = [0];
             *       const returnedResult = append(result, formatting, index);
             *   ```
             *   Retorna:
             *   ```returnedResult = "1";
             *      index = [1];
             *   ```
             */
            append(result: string, formatting: string, index: Array<number>): string;
            /**
             * Obtém tipo por extenso.
             *
             * @returns O tipo por extenso.
             * @example
             * Se o tipo for **ALPHA_NUMERIC_KEY** recebo **uma letra ou um número**
             */
            getFormatMessage(): string;
        };
    };
    private static LiteralCharacter;
    private static DigitMaskCharacter;
    private static UpperCaseCharacter;
    private static LowerCaseCharacter;
    private static AlphaNumericCharacter;
    private static AlphaNumericUpperCaseCharacter;
    private static CharCharacter;
}
export declare namespace MaskFormatter {
    type MaskCharacter = InstanceType<typeof MaskFormatter.MaskCharacter>;
}