import { ExtractResult, MetaData } from "@microsoft/recognizers-text";
import { BaseNumberExtractor } from "@microsoft/recognizers-text-number";
import { IDateTimeParser, DateTimeParseResult } from "./parsers";
import { StringMap } from "./utilities";
import { BaseDateParser } from "./baseDate";
import { BaseTimeParser } from "./baseTime";
import { BaseDatePeriodParser } from "./baseDatePeriod";
import { BaseTimePeriodParser } from "./baseTimePeriod";
import { IDateTimeExtractor, BaseDateTimeParser } from "./baseDateTime";
import { BaseDateTimePeriodParser } from "./baseDateTimePeriod";
import { BaseSetParser } from "./baseSet";
import { BaseDurationParser } from "./baseDuration";
import { BaseHolidayParser } from "./baseHoliday";
import { DateTimeOptions } from "./dateTimeRecognizer";
export interface IMergedExtractorConfiguration {
    dateExtractor: IDateTimeExtractor;
    timeExtractor: IDateTimeExtractor;
    dateTimeExtractor: IDateTimeExtractor;
    datePeriodExtractor: IDateTimeExtractor;
    timePeriodExtractor: IDateTimeExtractor;
    dateTimePeriodExtractor: IDateTimeExtractor;
    holidayExtractor: IDateTimeExtractor;
    durationExtractor: IDateTimeExtractor;
    setExtractor: IDateTimeExtractor;
    integerExtractor: BaseNumberExtractor;
    afterRegex: RegExp;
    beforeRegex: RegExp;
    sinceRegex: RegExp;
    fromToRegex: RegExp;
    singleAmbiguousMonthRegex: RegExp;
    ambiguousRangeModifierPrefix: RegExp;
    potentialAmbiguousRangeRegex: RegExp;
    prepositionSuffixRegex: RegExp;
    numberEndingPattern: RegExp;
    unspecificDatePeriodRegex: RegExp;
    filterWordRegexList: RegExp[];
    AmbiguityFiltersDict: Map<RegExp, RegExp>;
}
export declare class BaseMergedExtractor implements IDateTimeExtractor {
    protected readonly config: IMergedExtractorConfiguration;
    protected readonly options: DateTimeOptions;
    private static readonly NumberOrConnectorRegex;
    constructor(config: IMergedExtractorConfiguration, options: DateTimeOptions);
    extract(source: string, refDate: Date): ExtractResult[];
    private checkCalendarFilterList;
    private numberEndingRegexMatch;
    protected addTo(destination: ExtractResult[], source: ExtractResult[], text: string): void;
    private shouldSkipFromMerge;
    private filterUnspecificDatePeriod;
    private filterAmbiguity;
    private filterAmbiguousSingleWord;
    protected addMod(ers: ExtractResult[], source: string): void;
    protected tryMergeModifierToken(er: ExtractResult, regex: RegExp, source: string, potentialAmbiguity?: boolean): boolean;
    protected assignModMetadata(metadata: MetaData): MetaData;
    protected hasTokenIndex(source: string, regex: RegExp): {
        matched: boolean;
        index: number;
    };
}
export interface IMergedParserConfiguration {
    beforeRegex: RegExp;
    afterRegex: RegExp;
    sinceRegex: RegExp;
    dateParser: BaseDateParser;
    holidayParser: BaseHolidayParser;
    timeParser: BaseTimeParser;
    dateTimeParser: BaseDateTimeParser;
    datePeriodParser: BaseDatePeriodParser;
    timePeriodParser: BaseTimePeriodParser;
    dateTimePeriodParser: BaseDateTimePeriodParser;
    durationParser: BaseDurationParser;
    setParser: BaseSetParser;
}
export declare class BaseMergedParser implements IDateTimeParser {
    readonly parserTypeName = "datetimeV2";
    protected readonly config: IMergedParserConfiguration;
    private readonly options;
    private readonly dateDefaultValue;
    private readonly dateMinValue;
    private readonly dateTimeMinValue;
    constructor(config: IMergedParserConfiguration, options: DateTimeOptions);
    parse(er: ExtractResult, refTime?: Date): DateTimeParseResult | null;
    setParseResult(slot: DateTimeParseResult, hasBefore: boolean, hasAfter: boolean, hasSince: boolean): DateTimeParseResult;
    protected getParseResult(extractorResult: ExtractResult, referenceDate: Date): DateTimeParseResult | null;
    protected combineMod(originalMod: string, newMod: string): string;
    protected determineDateTimeType(type: string, hasMod: boolean): string;
    protected determineSourceEntityType(sourceType: string, newType: string, hasMod: boolean): string | null;
    dateTimeResolutionForSplit(slot: DateTimeParseResult): DateTimeParseResult[];
    protected dateTimeResolution(slot: DateTimeParseResult, hasBefore: boolean, hasAfter: boolean, hasSince: boolean): {
        [s: string]: StringMap[];
    };
    protected isObject(o: any): boolean;
    protected addResolutionFieldsAny(dic: Map<string, any>, key: string, value: any): void;
    protected addResolutionFields(dic: StringMap, key: string, value: string): void;
    protected generateFromResolution(type: string, resolutions: StringMap, mod: string): StringMap;
    private addSingleDateTimeToResolution;
    private addPeriodToResolution;
    protected getValues(obj: any): any[];
    protected processDoubleTimex(resolutionDic: Map<string, any>, futureKey: string, pastKey: string, originTimex: string): void;
    private HasDoubleTimex;
    protected resolveAMPM(valuesMap: Map<string, any>, keyName: string): void;
}