import * as i0 from '@angular/core';
import { Signal, PipeTransform, InjectionToken, Provider } from '@angular/core';
import { Nullable } from '@fundamental-ngx/cdk/utils';
import * as i1 from '@angular/cdk/platform';

/**
 * Datetime Adapter is an abstract class that must be implemented by each adapter.
 * It's used to encapsulate a date/time manipulations as result
 * others places that uses it remain date type agnostic.
 *
 */
declare abstract class DatetimeAdapter<D> {
    /**
     * Gets the year component of the given date.
     * @param date The date to extract the year from.
     * @returns The year number.
     */
    abstract getYear(date: D): number;
    /**
     * Gets the month of the given date.
     * @param date The date to extract the month from.
     * @returns The month number (min 1, max 12).
     */
    abstract getMonth(date: D): number;
    /**
     * Gets the day of month of the given date.
     * @param date The date to extract the date of the month from.
     * @returns The date number (min 1, max 31).
     */
    abstract getDate(date: D): number;
    /**
     * Gets the day of the week component of the given date.
     * @param date The date to extract the day of the week from.
     * @returns The day of week number (min 1, max 7, 1 = Sunday).
     */
    abstract getDayOfWeek(date: D): number;
    /**
     * Gets hours of the given date.
     * @param date The date to extract the hours from.
     * @returns The hours number (min 0, max 23).
     */
    abstract getHours(date: D): number;
    /**
     * Gets minutes of the given date.
     * @param date The date to extract the minutes from.
     * @returns The minutes number (min 0, max 59).
     */
    abstract getMinutes(date: D): number;
    /**
     * Gets seconds of the given date.
     * @param date The date to extract the seconds from.
     * @returns The seconds number (min 0, max 59).
     */
    abstract getSeconds(date: D): number;
    /**
     * Set hours.
     * @param date The date to set hours to.
     * @param hours
     * @returns The new date instance.
     */
    abstract setHours(date: D, hours: number): D;
    /**
     * Set minutes.
     * @param date The date to set minutes to.
     * @param minutes
     * @returns The new date instance.
     */
    abstract setMinutes(date: D, minutes: number): D;
    /**
     * Set seconds.
     * @param date The date to set seconds to.
     * @param seconds
     * @returns The new date instance.
     */
    abstract setSeconds(date: D, seconds: number): D;
    /**
     * Gets week number of the given date
     * @param date The date to extract the week number from.
     * @returns The week number (min 1, max 53).
     */
    abstract getWeekNumber(date: D): number;
    /**
     * Gets a list of names for the months.
     * @param style The naming style (e.g. long = 'January', short = 'Jan', narrow = 'J').
     * @returns An ordered list of all month names, starting with January.
     */
    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    /**
     * Gets a list of names for the dates of the month.
     * @returns An ordered list of all date of the month names, starting with '1'.
     */
    abstract getDateNames(): string[];
    /**
     * Gets a list of names for the days of the week.
     * @param style The naming style (e.g. long = 'Sunday', short = 'Sun', narrow = 'S').
     * @returns An ordered list of all weekday names, starting with Sunday.
     */
    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    /**
     * Gets the name for the year of the given date.
     * @param date The date to get the year name from.
     * @returns The name of the given year (e.g. '2020').
     */
    abstract getYearName(date: D): string;
    /**
     * Gets the name for the week of the given date.
     * @param date The date to get the week name from.
     * @returns The name of the the week.
     */
    abstract getWeekName(date: D): string;
    /**
     * Gets a list of hour names.
     * @returns An ordered list of all hours (0 - 24).
     */
    abstract getHourNames(options: {
        twoDigit: boolean;
        meridian: boolean;
    }): string[];
    /**
     * Gets a list of minute names.
     * @param options Configuration options for minute names
     * @param options.twoDigit Whether to format minutes with two digits (e.g., '05' vs '5')
     * @param options.minuteStep The interval between minutes (e.g., 1 for every minute, 5 for 5-minute intervals, 15 for 15-minute intervals). Defaults to 1.
     * @returns An ordered list of minute names based on the step interval.
     */
    abstract getMinuteNames(options: {
        twoDigit: boolean;
        minuteStep?: number;
    }): string[];
    /**
     * Gets a list of second names.
     * @returns An ordered list of all hours (0 - 24).
     */
    abstract getSecondNames(options: {
        twoDigit: boolean;
    }): string[];
    /**
     * Gets a list of day periods.
     * @returns List of day periods, starts from AM ['AM', 'PM'].
     */
    abstract getDayPeriodNames(): [string, string];
    /**
     * Gets the first day of the week.
     * @returns The first day of the week (0-indexed, 0 = Sunday).
     */
    abstract getFirstDayOfWeek(): number;
    /**
     * Gets the number of days in the month of the given date.
     * @param date The date whose month should be checked.
     * @returns The number of days in the month of the given date.
     */
    abstract getNumDaysInMonth(date: D): number;
    /**
     * Parses a date from a user-provided value.
     * @param value The value to parse.
     * @param parseFormat The expected format of the value being parsed
     *     (type is implementation-dependent).
     * @returns The parsed date.
     */
    abstract parse(value: unknown, parseFormat: unknown): D | null;
    /**
     * Formats a date as a string according to the given format.
     * @param date The value to format.
     * @param displayFormat The format to use to display the date as a string.
     * @returns The formatted date string.
     */
    abstract format(date: Nullable<D>, displayFormat: unknown): string;
    /**
     * Creates a date with the given year, month, and date.
     * @param year The full year of the date. (e.g. 1989).
     * @param month The month of the date (1 = January). Must be an integer 1 - 12.
     * @param date The month date. Must be an integer 1 - length of the given month.
     * @returns The new date, or null if invalid.
     */
    abstract createDate(year: number, month?: number, date?: number): D;
    /**
     * Gets today's date where time value is set to 0
     * @returns Today's date.
     */
    abstract today(): D;
    /**
     * Gets date and time at this moment.
     * @returns date and time at this moment.
     */
    abstract now(): D;
    /**
     * Adds the given number of years to the date. Years are counted as if flipping 12 pages on the
     * calendar for each year and then finding the closest date in the new month. For example when
     * adding 1 year to Feb 29, 2016, the resulting date will be Feb 28, 2017.
     * @param date The date to add years to.
     * @param years The number of years to add (may be negative).
     * @returns A new date equal to the given one with the specified number of years added.
     */
    abstract addCalendarYears(date: D, years: number): D;
    /**
     * Adds the given number of months to the date. Months are counted as if flipping a page on the
     * calendar for each month and then finding the closest date in the new month. For example when
     * adding 1 month to Jan 31, 2017, the resulting date will be Feb 28, 2017.
     * @param date The date to add months to.
     * @param months The number of months to add (may be negative).
     * @returns A new date equal to the given one with the specified number of months added.
     */
    abstract addCalendarMonths(date: D, months: number): D;
    /**
     * Adds the given number of days to the date. Days are counted as if moving one cell on the
     * calendar for each day.
     * @param date The date to add days to.
     * @param days The number of days to add (may be negative).
     * @returns A new date equal to the given one with the specified number of days added.
     */
    abstract addCalendarDays(date: D, days: number): D;
    /**
     * Clones the given date.
     * @param date The date to clone
     * @returns A new date equal to the given date.
     */
    abstract clone(date: D): D;
    /**
     * Method that check equality of 2 dates.
     * Does not take into account time value
     * @param date1 The first date to compare with
     * @param date2 The second date to compare with
     * @returns If dates are equal or not
     */
    abstract datesEqual(date1: Nullable<D>, date2: Nullable<D>): boolean;
    /**
     * Method that check equality of 2 dates taking into account time value as well
     * @param date1 The first date to compare with
     * @param date2 The second date to compare with
     * @returns If dates are equal or not
     */
    abstract dateTimesEqual(date1: Nullable<D>, date2: Nullable<D>): boolean;
    /**
     * Method to check if date is between 2 dates
     * @param dateToCheck The date to check if it's in a range
     * @param startDate The start date of a range
     * @param endDate The end date of a range
     * @returns If date is in a given date range
     */
    abstract isBetween(dateToCheck: D, startDate: D, endDate: D): boolean;
    /**
     * Method that checks validity of current date.
     * @param date The date to be checked
     */
    abstract isValid(date: Nullable<D>): date is D;
    /**
     * Gets the ISO 8601 date-time string for the given date.
     *
     * Returns a **local** (timezone-unaware) string in the format `YYYY-MM-DDTHH:mm:ss`.
     * This is intentionally **not** RFC 3339 compliant because no timezone designator is appended.
     *
     * This method is used to generate date strings that are compatible with native HTML attributes
     * such as the `min` or `max` attribute of an `<input>`.
     *
     * To produce an RFC 3339 string, append a timezone designator to the result:
     * ```ts
     * const rfc3339Utc = adapter.toIso8601(date) + 'Z';          // UTC
     * const rfc3339Local = adapter.toIso8601(date) + '+05:30';    // with offset
     * ```
     *
     * @param date The date to get the ISO date string for.
     * @returns The ISO 8601 date-time string without timezone designator.
     */
    abstract toIso8601(date: D): string;
    /**
     * Format option includes period info.
     * @param displayFormat The format to use to display the date as a string.
     * @returns If time format includes period info.
     */
    abstract isTimeFormatIncludesDayPeriod(displayFormat: unknown): boolean;
    /**
     * Format option includes hours info.
     * @param displayFormat The format to use to display the date as a string.
     * @returns If time format includes minutes info.
     */
    abstract isTimeFormatIncludesHours(displayFormat: unknown): boolean;
    /**
     * Format option includes minutes info.
     * @param displayFormat The format to use to display the date as a string.
     * @returns If time format includes minutes info.
     */
    abstract isTimeFormatIncludesMinutes(displayFormat: unknown): boolean;
    /**
     * Format option includes seconds info.
     * @param displayFormat The format to use to display the date as a string.
     * @returns If time format includes seconds info.
     */
    abstract isTimeFormatIncludesSeconds(displayFormat: unknown): boolean;
    /**
     * @param date The date being referenced.
     * @returns String representing how much time has passed since the date param.
     */
    abstract fromNow?(date: D): string;
    /** Current locale as a readonly signal. */
    readonly locale: Signal<string>;
    /** @hidden */
    private readonly _locale;
    protected constructor();
    /**
     * Sets the locale used for all dates.
     * @param locale The new locale.
     */
    setLocale(locale: string): void;
    /**
     * Set hours, minutes and seconds at once.
     * @param date The date to set time to.
     * @param hours
     * @param minutes
     * @param seconds
     * @returns The new date instance.
     */
    setTime(date: D, hours: number, minutes: number, seconds: number): D;
    /**
     * Get Amount of weeks in given month/year
     * @param year The year of the date
     * @param month The month of the date
     * @param firstDayOfWeek The first day of week. 1 - Sunday, 2 - Monday, ..., 7 - Saturday
     * @returns Number of weeks in the given month
     */
    getAmountOfWeeks(year: number, month: number, firstDayOfWeek: number): number;
    /**
     * Compares two dates.
     * @param first The first date to compare.
     * @param second The second date to compare.
     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
     *     a number greater than 0 if the first date is later.
     */
    compareDate(first: D, second: D): number;
}

declare class DateFormatPipe<D> implements PipeTransform {
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** @hidden */
    private readonly _dateTimeFormats;
    /** Format date object */
    transform(date: D, noDateMessage?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatPipe<any>, "dateFormat", true>;
}
declare class DateTimeFormatPipe<D> implements PipeTransform {
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** @hidden */
    private readonly _dateTimeFormats;
    /** Format date object */
    transform(date: D, noDateMessage?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeFormatPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeFormatPipe<any>, "dateTimeFormat", true>;
}
declare class DateFromNowPipe<D> implements PipeTransform {
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** Format date object */
    transform(date: D, noDateMessage?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateFromNowPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateFromNowPipe<any>, "dateFromNow", true>;
}
declare class DayPeriodFormatPipe<D> implements PipeTransform {
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** Format date object for day period */
    transform(date: D, customFormat?: any, noDateMessage?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DayPeriodFormatPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DayPeriodFormatPipe<any>, "dayPeriodFormat", true>;
}
declare class TranslateDayPeriodPipe implements PipeTransform {
    /** @hidden */
    private readonly _translationResolver;
    /** @hidden */
    private readonly _currentLanguageSignal;
    /** Format date object for day period */
    transform(value: string | null): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslateDayPeriodPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TranslateDayPeriodPipe, "translateDayPeriod", true>;
}

/**
 * DateTimeFormats is intended to keep options
 * related to date-time formatting / parsing
 *
 */
interface DateTimeFormats {
    parse: {
        dateInput: unknown;
        timeInput: unknown;
        dateTimeInput: unknown;
    };
    display: {
        dateInput: unknown;
        timeInput: unknown;
        dateTimeInput: unknown;
        dateA11yLabel: unknown;
        monthA11yLabel: unknown;
        yearA11yLabel: unknown;
    };
    rangeDelimiter: string;
}
/**
 * DateTimeFormats injection token
 */
declare const DATE_TIME_FORMATS: InjectionToken<DateTimeFormats>;

/**
 * Converts a given time string to a desired format.
 *
 * @param {string} inputStr - The input time string to be converted.
 * @returns {string} - The converted time string in the desired format.
 */
declare function convertToDesiredFormat(inputStr: string): string;

/**
 * FdDate class is used to represent date and time.
 *
 * It's a simplified analog of native Date instance.
 * It gives some convenience methods to work with date or time data.
 *
 */
declare class FdDate {
    /**
     * The year of the date.
     */
    year: number;
    /**
     * The month of the date. 1 = January, 12 = December.
     */
    month: number;
    /**
     * Day of the date. Starts at 1.
     */
    day: number;
    /**
     * Date hours. 0 - 23.
     */
    hour: number;
    /**
     * Date minutes. 0 - 59.
     */
    minute: number;
    /**
     * Date seconds. 0 - 59.
     */
    second: number;
    /**
     * Validation state
     */
    /** @hidden */
    private _isValid;
    /**
     * Create FdDate
     * @param year e.g. 2020
     * @param month 1 = January, 12 = December
     * @param day 1 - 31
     * @param hour 0 - 23
     * @param minute 0 - 59
     * @param second 0 - 59
     */
    constructor(year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number);
    /**
     * Create FdDate instance of the current moment
     */
    static getNow(): FdDate;
    /**
     * Gets today's FdDate where hour, minute and second is set to 0
     */
    static getToday(): FdDate;
    /**
     *  Convert js date object to FdDate model
     */
    static getFdDateByDate(date: Date): FdDate;
    /**
     * Set hour, minute and second data
     * @param hour
     * @param minute
     * @param second
     */
    setTime(hour: number, minute?: number, second?: number): FdDate;
    /**
     * Get amount of milliseconds from 01.01.1970
     */
    getTimeStamp(): number;
    /**
     * Get number of weekday ex. Sunday = 1, Monday = 2, Tuesday = 3 etc.
     */
    getDayOfWeek(): number;
    /**
     * Get native date object from FdDate.
     */
    toDate(): Date;
    /**
     * Method that checks validity of current FdDate instance.
     */
    isDateValid(): boolean;
    /**
     * Get string representation in yyyy-mm-ddThh:mm:ss format
     */
    toString(): string;
    /**
     * The valueOf() method returns the primitive value of a FdDate.
     * Returns: The number of milliseconds between 1 January 1970 00:00:00 UTC and the given date.
     */
    valueOf(): number;
    /**
     * Get date string in yyyy-mm-dd format
     */
    toDateString(): string;
    /**
     * Get time string in hh:mm:ss format
     */
    toTimeString(): string;
}

declare const FD_DATETIME_FORMATS: DateTimeFormats;

/** Pads a number to at least 2 digits. Years are padded to at least 4 digits. */
declare function _leftPad(n: number, minLength?: number): string;
/** Converts date to ISO 8601 date-time string without timezone designator (`YYYY-MM-DDTHH:mm:ss`). */
declare function toIso8601(fdDate: {
    year: number;
    month: number;
    day: number;
    hour: number;
    minute: number;
    second: number;
}): string;
/**
 * @param params e.g. { year: 2020, month: 1, day: 1, hour: 0, minute: 0, second: 0 }
 */
declare function isValidByParams(params: {
    year: number;
    month: number;
    day?: number;
    hour?: number;
    minute?: number;
    second?: number;
}): boolean;

type CustomDateTimeFormatOptions = Omit<Intl.DateTimeFormatOptions, 'dayPeriod'> & {
    dayPeriod?: boolean;
};
/**
 * DatetimeAdapter implementation based on FdDate.
 *
 * This uses FdDate as a date model and relies on Intl.DateTimeFormat
 * for formatting and translation purposes.
 *
 */
declare class FdDatetimeAdapter extends DatetimeAdapter<FdDate> {
    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */
    private readonly _fixYearsRangeIssue;
    /** Cached Intl.RelativeTimeFormat instance, invalidated on locale change. */
    private _relativeTimeFormatter;
    /** Cached result of _isFormatDayFirst(), invalidated on locale change. */
    private _dayFirstCache;
    /** @hidden */
    constructor();
    /** @hidden */
    setLocale(locale: string): void;
    /** @hidden */
    fromNow(date: FdDate): string;
    /** Get year */
    getYear(date: FdDate): number;
    /** Get month */
    getMonth(date: FdDate): number;
    /** Get date */
    getDate(date: FdDate): number;
    /** Get day of week */
    getDayOfWeek(date: FdDate): number;
    /** Get hours */
    getHours(date: FdDate): number;
    /** Get minutes */
    getMinutes(date: FdDate): number;
    /** Get seconds */
    getSeconds(date: FdDate): number;
    /** Get week number */
    getWeekNumber(fdDate: FdDate): number;
    /** Get month names */
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    /** Get date names */
    getDateNames(): string[];
    /** Get day of week names */
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    /** Get year name */
    getYearName(date: FdDate): string;
    /** Get week name */
    getWeekName(date: FdDate): string;
    /** Get hour names */
    getHourNames({ meridian, twoDigit }: {
        twoDigit: boolean;
        meridian: boolean;
    }): string[];
    /** Get minute names */
    getMinuteNames({ twoDigit, minuteStep }: {
        twoDigit: boolean;
        minuteStep?: number;
    }): string[];
    /** Get second names */
    getSecondNames({ twoDigit }: {
        twoDigit: boolean;
    }): string[];
    /** Get day period names */
    getDayPeriodNames(): [string, string];
    /** Set hours */
    setHours(date: FdDate, hours: number): FdDate;
    /** Set minutes */
    setMinutes(date: FdDate, minutes: number): FdDate;
    /** Set seconds */
    setSeconds(date: FdDate, seconds: number): FdDate;
    /** Get first day of week */
    getFirstDayOfWeek(): number;
    /** Get number of days in a month */
    getNumDaysInMonth(fdDate: FdDate): number;
    /** Create a date object */
    createDate(year: number, month?: number, date?: number): FdDate;
    /** Get a today date object */
    today(): FdDate;
    /** Get a now date object */
    now(): FdDate;
    /** Parse any value to date object */
    parse(value: any, parseFormat?: Intl.DateTimeFormatOptions): FdDate | null;
    /** Format date object to string */
    format(date: FdDate, displayFormat: CustomDateTimeFormatOptions): string;
    /** Add years to a date */
    addCalendarYears(date: FdDate, years: number): FdDate;
    /** Add months to a date */
    addCalendarMonths(fdDate: FdDate, months: number): FdDate;
    /** Add days to a date */
    addCalendarDays(fdDate: FdDate, days: number): FdDate;
    /** Clone a date object */
    clone(date: FdDate): FdDate;
    /** Check if date object is valid */
    isValid(date: FdDate): date is FdDate;
    /** Check if date between given dates */
    isBetween(dateToCheck: FdDate, startDate: FdDate, endDate: FdDate): boolean;
    /** Check if dates are equal */
    datesEqual(date1: FdDate, date2: FdDate): boolean;
    /** Check if dates and time are equal */
    dateTimesEqual(date1: FdDate, date2: FdDate): boolean;
    /** {@inheritDoc DatetimeAdapter.toIso8601} */
    toIso8601(fdDate: FdDate): string;
    /** Check if a time format includes a day period */
    isTimeFormatIncludesDayPeriod(displayFormat: CustomDateTimeFormatOptions): boolean;
    /** Check if a time format includes hours */
    isTimeFormatIncludesHours(displayFormat: Intl.DateTimeFormatOptions): boolean;
    /** Check if a time format includes minutes */
    isTimeFormatIncludesMinutes(displayFormat: Intl.DateTimeFormatOptions): boolean;
    /** Check if a time format includes seconds */
    isTimeFormatIncludesSeconds(displayFormat: Intl.DateTimeFormatOptions): boolean;
    /** Format with custom pattern including day period names */
    private _formatWithDayPeriod;
    /** Insert day period into the formatted string */
    private _insertDayPeriod;
    /** Get day period name based on the hour */
    private _getDayPeriodName;
    /** Format date using Intl.DateTimeFormat */
    private _formatWithIntl;
    /**
     * @hidden
     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
     * other browsers do not. We remove them to make output consistent and because they interfere with
     * date parsing.
     * @param str The string to strip direction characters from.
     * @returns The stripped string.
     */
    private _stripDirectionalityCharacters;
    /** @hidden */
    private _format;
    /**
     * @hidden
     * Create native Date instance from FdDate
     * @param date FdDate instance
     * @returns date Native date instance
     */
    private _createDateInstanceByFdDate;
    /**
     * @hidden
     * Create native Date instance in UTC
     * @param year The year
     * @param month The month as a number between 0 and 11
     * @param day The date as a number between 1 and 31.
     * @param hours The hours as a number between 0 - 24
     * @param minutes The minutes as a number between 0 - 59
     * @param seconds The seconds as a number between 0 - 59
     * @param milliseconds The milliseconds as a number between 0 - 999
     */
    private _createUTCDateInstance;
    /** @hidden */
    private _createFdDateFromDateInstance;
    /**
     * @hidden
     *
     * Parse a time string into hours, minutes, seconds and apply to today's date.
     * Supports: "14:30", "14:30:45", "10:30 PM", "10:30PM", "14.30" (dot separator).
     *
     * @param timeStr Time string to parse
     * @returns date Native date instance (Invalid Date if parsing fails)
     */
    private _parseTimeString;
    /**
     * @hidden
     *
     * Try to parse a date string with common separators (/, -, .)
     * using locale awareness for day/month ordering.
     *
     * @param value Date string (e.g. "12.03.2026", "03/12/2026", "2026-03-12")
     * @returns Native Date instance or null if parsing fails
     */
    private _parseDateString;
    /**
     * @hidden
     *
     * Parse a locale-native datetime string that contains both a date and a time
     * component (e.g. "20/05/2026 16:33" fr-FR, "20.5.2026, 16:33" de-DE).
     *
     * Strategy: split on the first 4-digit year boundary (everything before+including
     * the year is the date part; everything after the optional ", " separator is the
     * time part), delegate each half to the existing helpers, then combine.
     *
     * @param value Datetime string to parse
     * @returns Native Date instance or null if parsing fails
     */
    private _parseDateTimeString;
    /**
     * @hidden
     *
     * Detect whether the current locale formats dates with day before month.
     * Uses Intl.DateTimeFormat.formatToParts to inspect the locale's ordering.
     *
     * @returns true if locale puts day before month (e.g. de-DE, en-GB)
     */
    private _isFormatDayFirst;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdDatetimeAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FdDatetimeAdapter>;
}

/**
 * @deprecated
 * Use imports of `DateFormatPipe`, `DateTimeFormatPipe`, `DateFromNowPipe` instead.
 */
declare class FdDatetimePipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdDatetimePipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FdDatetimePipesModule, never, [typeof DateFormatPipe, typeof DateTimeFormatPipe, typeof DateFromNowPipe, typeof DayPeriodFormatPipe, typeof TranslateDayPeriodPipe], [typeof DateFormatPipe, typeof DateTimeFormatPipe, typeof DateFromNowPipe, typeof DayPeriodFormatPipe, typeof TranslateDayPeriodPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FdDatetimePipesModule>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FdDatetimeAdapterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdDatetimeAdapterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FdDatetimeAdapterModule, never, [typeof i1.PlatformModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FdDatetimeAdapterModule>;
}
declare class FdDatetimeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdDatetimeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FdDatetimeModule, never, [typeof FdDatetimeAdapterModule, typeof FdDatetimePipesModule], [typeof FdDatetimePipesModule, typeof FdDatetimeAdapterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FdDatetimeModule>;
}

/**
 * Provides default datetime formats and datetime adapter.
 */
declare function provideDateTimeFormats(): Provider[];

export { DATE_TIME_FORMATS, DateFormatPipe, DateFromNowPipe, DateTimeFormatPipe, DatetimeAdapter, DayPeriodFormatPipe, FD_DATETIME_FORMATS, FdDate, FdDatetimeAdapter, FdDatetimeAdapterModule, FdDatetimeModule, FdDatetimePipesModule, TranslateDayPeriodPipe, _leftPad, convertToDesiredFormat, isValidByParams, provideDateTimeFormats, toIso8601 };
export type { DateTimeFormats };
