import { NamedMatch, NamedRegExp } from "../characters";
import { DateFactory, DateFactoryParts, Format, Options } from "./core";
import { Parser } from "../parsing";
import { Mapper } from "../collections";
import DateTimeFormatPart = Intl.DateTimeFormatPart;
export declare class Spaces {
    static codes: string[];
    static spaces: string;
    static pattern: RegExp;
    static handle(value: string): string;
    static remove(value: string): string;
}
export declare const numberPattern: (locale: string) => string;
export declare function mapIgnoreError<A, B>(mapper: Mapper<A, B>): import("../transducers").FlatMapTransducer<A, B>;
export declare function separatorsOf(amount: string): string[];
export declare type AllowedDecimalSeparators = '.' | ',' | '٫';
export declare function isDecimalSeparator(value: any): value is AllowedDecimalSeparators;
export declare function decimalSeparator(value: any): AllowedDecimalSeparators;
export declare class NumberParser implements Parser<number> {
    private decimalSeparator;
    private locale;
    readonly strictNumberPattern: RegExp;
    readonly globalNumberPattern: NamedRegExp;
    constructor(decimalSeparator: (amount: string) => AllowedDecimalSeparators, locale: string);
    parse(value: string): number;
    parseAll(value: string): number[];
    private parseSingle;
    private convert;
    private numberOf;
}
export declare type Locale = string;
export declare function numberParser(): Parser<number>;
export declare function numberParser(decimalSeparatorOrLocale: AllowedDecimalSeparators | Locale): Parser<number>;
export declare function numberParser(decimalSeparator: AllowedDecimalSeparators, locale: Locale): Parser<number>;
export declare const inferDecimalSeparator: (locale: string) => AllowedDecimalSeparators;
export declare class RegexBuilder {
    private locale;
    private options;
    private formatted;
    constructor(locale: string, options: Options, formatted: DateTimeFormatPart[]);
    static create(locale: string, options?: string | Options): RegexBuilder;
    get pattern(): string;
    private lengthOf;
    private addExtraLiterals;
    private monthsPattern;
}
export declare function escapeCharacters(value: string): string;
export declare class DateParser {
    static create(locale: string, options: Options): import("../parsing").MappingParser<DateTimeFormatPart[], Date>;
}
export declare class DateTimeFormatPartParser {
    static create(regex: NamedRegExp, locale: string): Parser<DateTimeFormatPart[]>;
    static convert(matches: NamedMatch[], locale: string): DateTimeFormatPart[];
    static preProcess(value: string, locale: string): string;
}
export declare function dateFrom(parts: DateTimeFormatPart[], locale: string, options: Options): Date;
export declare class DefaultDateFactory implements DateFactory {
    create({ year, month, day }: DateFactoryParts): Date;
}
export declare const defaultParserOptions: (Format | Options)[];
export declare function parser(locale: string, options?: Format | Options): Parser<Date>;
export declare function formatBuilder(locale: string, format: Format, strict?: boolean): RegexBuilder;