export namespace lowOrderMatrix {
    export namespace weeks {
        let days: number;
        let hours: number;
        let minutes: number;
        let seconds: number;
        let milliseconds: number;
    }
    export namespace days_1 {
        let hours_1: number;
        export { hours_1 as hours };
        let minutes_1: number;
        export { minutes_1 as minutes };
        let seconds_1: number;
        export { seconds_1 as seconds };
        let milliseconds_1: number;
        export { milliseconds_1 as milliseconds };
    }
    export { days_1 as days };
    export namespace hours_2 {
        let minutes_2: number;
        export { minutes_2 as minutes };
        let seconds_2: number;
        export { seconds_2 as seconds };
        let milliseconds_2: number;
        export { milliseconds_2 as milliseconds };
    }
    export { hours_2 as hours };
    export namespace minutes_3 {
        let seconds_3: number;
        export { seconds_3 as seconds };
        let milliseconds_3: number;
        export { milliseconds_3 as milliseconds };
    }
    export { minutes_3 as minutes };
    export namespace seconds_4 {
        let milliseconds_4: number;
        export { milliseconds_4 as milliseconds };
    }
    export { seconds_4 as seconds };
}
export namespace casualMatrix {
    export namespace years {
        export let quarters: number;
        export let months: number;
        let weeks_1: number;
        export { weeks_1 as weeks };
        let days_2: number;
        export { days_2 as days };
        let hours_3: number;
        export { hours_3 as hours };
        let minutes_4: number;
        export { minutes_4 as minutes };
        let seconds_5: number;
        export { seconds_5 as seconds };
        let milliseconds_5: number;
        export { milliseconds_5 as milliseconds };
    }
    export namespace quarters_1 {
        let months_1: number;
        export { months_1 as months };
        let weeks_2: number;
        export { weeks_2 as weeks };
        let days_3: number;
        export { days_3 as days };
        let hours_4: number;
        export { hours_4 as hours };
        let minutes_5: number;
        export { minutes_5 as minutes };
        let seconds_6: number;
        export { seconds_6 as seconds };
        let milliseconds_6: number;
        export { milliseconds_6 as milliseconds };
    }
    export { quarters_1 as quarters };
    export namespace months_2 {
        let weeks_3: number;
        export { weeks_3 as weeks };
        let days_4: number;
        export { days_4 as days };
        let hours_5: number;
        export { hours_5 as hours };
        let minutes_6: number;
        export { minutes_6 as minutes };
        let seconds_7: number;
        export { seconds_7 as seconds };
        let milliseconds_7: number;
        export { milliseconds_7 as milliseconds };
    }
    export { months_2 as months };
}
export const daysInYearAccurate: number;
export const daysInMonthAccurate: number;
export namespace accurateMatrix {
    export namespace years_1 {
        let quarters_2: number;
        export { quarters_2 as quarters };
        let months_3: number;
        export { months_3 as months };
        let weeks_4: number;
        export { weeks_4 as weeks };
        export { daysInYearAccurate as days };
        let hours_6: number;
        export { hours_6 as hours };
        let minutes_7: number;
        export { minutes_7 as minutes };
        let seconds_8: number;
        export { seconds_8 as seconds };
        let milliseconds_8: number;
        export { milliseconds_8 as milliseconds };
    }
    export { years_1 as years };
    export namespace quarters_3 {
        let months_4: number;
        export { months_4 as months };
        let weeks_5: number;
        export { weeks_5 as weeks };
        let days_5: number;
        export { days_5 as days };
        let hours_7: number;
        export { hours_7 as hours };
        let minutes_8: number;
        export { minutes_8 as minutes };
        let seconds_9: number;
        export { seconds_9 as seconds };
        let milliseconds_9: number;
        export { milliseconds_9 as milliseconds };
    }
    export { quarters_3 as quarters };
    export namespace months_5 {
        let weeks_6: number;
        export { weeks_6 as weeks };
        export { daysInMonthAccurate as days };
        let hours_8: number;
        export { hours_8 as hours };
        let minutes_9: number;
        export { minutes_9 as minutes };
        let seconds_10: number;
        export { seconds_10 as seconds };
        let milliseconds_10: number;
        export { milliseconds_10 as milliseconds };
    }
    export { months_5 as months };
}
/**
 * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". Conceptually, it's just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime#plus} to add a Duration object to a DateTime, producing another DateTime.
 *
 * Here is a brief overview of commonly used methods and getters in Duration:
 *
 * * **Creation** To create a Duration, use {@link Duration.fromMillis}, {@link Duration.fromObject}, or {@link Duration.fromISO}.
 * * **Unit values** See the {@link Duration#years}, {@link Duration#months}, {@link Duration#weeks}, {@link Duration#days}, {@link Duration#hours}, {@link Duration#minutes}, {@link Duration#seconds}, {@link Duration#milliseconds} accessors.
 * * **Configuration** See  {@link Duration#locale} and {@link Duration#numberingSystem} accessors.
 * * **Transformation** To create new Durations out of old ones use {@link Duration#plus}, {@link Duration#minus}, {@link Duration#normalize}, {@link Duration#set}, {@link Duration#reconfigure}, {@link Duration#shiftTo}, and {@link Duration#negate}.
 * * **Output** To convert the Duration into other representations, see {@link Duration#as}, {@link Duration#toISO}, {@link Duration#toFormat}, and {@link Duration#toJSON}
 *
 * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation.
 */
export default class Duration {
    /**
     * Create Duration from a number of milliseconds.
     * @param {number} count of milliseconds
     * @param {Object} opts - options for parsing
     * @param {string} [opts.locale='en-US'] - the locale to use
     * @param {string} opts.numberingSystem - the numbering system to use
     * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
     * @return {Duration}
     */
    static fromMillis(count: number, opts: {
        locale?: string;
        numberingSystem: string;
        conversionAccuracy?: string;
    }): Duration;
    /**
     * Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
     * If this object is empty then a zero milliseconds duration is returned.
     * @param {Object} obj - the object to create the DateTime from
     * @param {number} obj.years
     * @param {number} obj.quarters
     * @param {number} obj.months
     * @param {number} obj.weeks
     * @param {number} obj.days
     * @param {number} obj.hours
     * @param {number} obj.minutes
     * @param {number} obj.seconds
     * @param {number} obj.milliseconds
     * @param {Object} [opts=[]] - options for creating this Duration
     * @param {string} [opts.locale='en-US'] - the locale to use
     * @param {string} opts.numberingSystem - the numbering system to use
     * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
     * @param {string} [opts.matrix=Object] - the custom conversion system to use
     * @return {Duration}
     */
    static fromObject(obj: {
        years: number;
        quarters: number;
        months: number;
        weeks: number;
        days: number;
        hours: number;
        minutes: number;
        seconds: number;
        milliseconds: number;
    }, opts?: {
        locale?: string;
        numberingSystem: string;
        conversionAccuracy?: string;
        matrix?: string;
    }): Duration;
    /**
     * Create a Duration from DurationLike.
     *
     * @param {Object | number | Duration} durationLike
     * One of:
     * - object with keys like 'years' and 'hours'.
     * - number representing milliseconds
     * - Duration instance
     * @return {Duration}
     */
    static fromDurationLike(durationLike: any | number | Duration): Duration;
    /**
     * Create a Duration from an ISO 8601 duration string.
     * @param {string} text - text to parse
     * @param {Object} opts - options for parsing
     * @param {string} [opts.locale='en-US'] - the locale to use
     * @param {string} opts.numberingSystem - the numbering system to use
     * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
     * @param {string} [opts.matrix=Object] - the preset conversion system to use
     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
     * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
     * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
     * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
     * @return {Duration}
     */
    static fromISO(text: string, opts: {
        locale?: string;
        numberingSystem: string;
        conversionAccuracy?: string;
        matrix?: string;
    }): Duration;
    /**
     * Create a Duration from an ISO 8601 time string.
     * @param {string} text - text to parse
     * @param {Object} opts - options for parsing
     * @param {string} [opts.locale='en-US'] - the locale to use
     * @param {string} opts.numberingSystem - the numbering system to use
     * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
     * @param {string} [opts.matrix=Object] - the conversion system to use
     * @see https://en.wikipedia.org/wiki/ISO_8601#Times
     * @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
     * @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
     * @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
     * @example Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
     * @example Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
     * @return {Duration}
     */
    static fromISOTime(text: string, opts: {
        locale?: string;
        numberingSystem: string;
        conversionAccuracy?: string;
        matrix?: string;
    }): Duration;
    /**
     * Create an invalid Duration.
     * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
     * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
     * @return {Duration}
     */
    static invalid(reason: string, explanation?: string): Duration;
    /**
     * @private
     */
    private static normalizeUnit;
    /**
     * Check if an object is a Duration. Works across context boundaries
     * @param {object} o
     * @return {boolean}
     */
    static isDuration(o: object): boolean;
    /**
     * @private
     */
    private constructor();
    /**
     * @access private
     */
    values: any;
    /**
     * @access private
     */
    loc: any;
    /**
     * @access private
     */
    conversionAccuracy: string;
    /**
     * @access private
     */
    invalid: any;
    /**
     * @access private
     */
    matrix: {
        weeks: {
            days: number;
            hours: number;
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
        days: {
            hours: number;
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
        hours: {
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
        minutes: {
            seconds: number;
            milliseconds: number;
        };
        seconds: {
            milliseconds: number;
        };
        years: {
            quarters: number;
            months: number;
            weeks: number;
            days: number;
            hours: number;
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
        quarters: {
            months: number;
            weeks: number;
            days: number;
            hours: number;
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
        months: {
            weeks: number;
            days: number;
            hours: number;
            minutes: number;
            seconds: number;
            milliseconds: number;
        };
    };
    /**
     * @access private
     */
    isLuxonDuration: boolean;
    /**
     * Get  the locale of a Duration, such 'en-GB'
     * @type {string}
     */
    get locale(): string;
    /**
     * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
     *
     * @type {string}
     */
    get numberingSystem(): string;
    /**
     * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens:
     * * `S` for milliseconds
     * * `s` for seconds
     * * `m` for minutes
     * * `h` for hours
     * * `d` for days
     * * `w` for weeks
     * * `M` for months
     * * `y` for years
     * Notes:
     * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits
     * * Tokens can be escaped by wrapping with single quotes.
     * * The duration will be converted to the set of units in the format string using {@link Duration#shiftTo} and the Durations's conversion accuracy setting.
     * @param {string} fmt - the format string
     * @param {Object} opts - options
     * @param {boolean} [opts.floor=true] - floor numerical values
     * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
     * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
     * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
     * @return {string}
     */
    toFormat(fmt: string, opts?: {
        floor?: boolean;
    }): string;
    /**
     * Returns a string representation of a Duration with all units included.
     * To modify its behavior, use `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant.
     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
     * @param {Object} opts - Formatting options. Accepts the same keys as the options parameter of the native `Intl.NumberFormat` constructor, as well as `listStyle`.
     * @param {string} [opts.listStyle='narrow'] - How to format the merged list. Corresponds to the `style` property of the options parameter of the native `Intl.ListFormat` constructor.
     * @example
     * ```js
     * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 })
     * dur.toHuman() //=> '1 day, 5 hours, 6 minutes'
     * dur.toHuman({ listStyle: "long" }) //=> '1 day, 5 hours, and 6 minutes'
     * dur.toHuman({ unitDisplay: "short" }) //=> '1 day, 5 hr, 6 min'
     * ```
     */
    toHuman(opts?: {
        listStyle?: string;
    }): any;
    /**
     * Returns a JavaScript object with this Duration's values.
     * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 }
     * @return {Object}
     */
    toObject(): any;
    /**
     * Returns an ISO 8601-compliant string representation of this Duration.
     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
     * @example Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S'
     * @example Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S'
     * @example Duration.fromObject({ months: 5 }).toISO() //=> 'P5M'
     * @example Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M'
     * @example Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S'
     * @return {string}
     */
    toISO(): string;
    /**
     * Returns an ISO 8601-compliant string representation of this Duration, formatted as a time of day.
     * Note that this will return null if the duration is invalid, negative, or equal to or greater than 24 hours.
     * @see https://en.wikipedia.org/wiki/ISO_8601#Times
     * @param {Object} opts - options
     * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
     * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
     * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
     * @param {string} [opts.format='extended'] - choose between the basic and extended format
     * @example Duration.fromObject({ hours: 11 }).toISOTime() //=> '11:00:00.000'
     * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressMilliseconds: true }) //=> '11:00:00'
     * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressSeconds: true }) //=> '11:00'
     * @example Duration.fromObject({ hours: 11 }).toISOTime({ includePrefix: true }) //=> 'T11:00:00.000'
     * @example Duration.fromObject({ hours: 11 }).toISOTime({ format: 'basic' }) //=> '110000.000'
     * @return {string}
     */
    toISOTime(opts?: {
        suppressMilliseconds?: boolean;
        suppressSeconds?: boolean;
        includePrefix?: boolean;
        format?: string;
    }): string;
    /**
     * Returns an ISO 8601 representation of this Duration appropriate for use in JSON.
     * @return {string}
     */
    toJSON(): string;
    /**
     * Returns an ISO 8601 representation of this Duration appropriate for use in debugging.
     * @return {string}
     */
    toString(): string;
    /**
     * Returns an milliseconds value of this Duration.
     * @return {number}
     */
    toMillis(): number;
    /**
     * Returns an milliseconds value of this Duration. Alias of {@link toMillis}
     * @return {number}
     */
    valueOf(): number;
    /**
     * Make this Duration longer by the specified amount. Return a newly-constructed Duration.
     * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
     * @return {Duration}
     */
    plus(duration: Duration | any | number): Duration;
    /**
     * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
     * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
     * @return {Duration}
     */
    minus(duration: Duration | any | number): Duration;
    /**
     * Scale this Duration by the specified amount. Return a newly-constructed Duration.
     * @param {function} fn - The function to apply to each unit. Arity is 1 or 2: the value of the unit and, optionally, the unit name. Must return a number.
     * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits(x => x * 2) //=> { hours: 2, minutes: 60 }
     * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits((x, u) => u === "hours" ? x * 2 : x) //=> { hours: 2, minutes: 30 }
     * @return {Duration}
     */
    mapUnits(fn: Function): Duration;
    /**
     * Get the value of unit.
     * @param {string} unit - a unit such as 'minute' or 'day'
     * @example Duration.fromObject({years: 2, days: 3}).get('years') //=> 2
     * @example Duration.fromObject({years: 2, days: 3}).get('months') //=> 0
     * @example Duration.fromObject({years: 2, days: 3}).get('days') //=> 3
     * @return {number}
     */
    get(unit: string): number;
    /**
     * "Set" the values of specified units. Return a newly-constructed Duration.
     * @param {Object} values - a mapping of units to numbers
     * @example dur.set({ years: 2017 })
     * @example dur.set({ hours: 8, minutes: 30 })
     * @return {Duration}
     */
    set(values: any): Duration;
    /**
     * "Set" the locale and/or numberingSystem.  Returns a newly-constructed Duration.
     * @example dur.reconfigure({ locale: 'en-GB' })
     * @return {Duration}
     */
    reconfigure({ locale, numberingSystem, conversionAccuracy, matrix }?: {
        locale: any;
        numberingSystem: any;
        conversionAccuracy: any;
        matrix: any;
    }): Duration;
    /**
     * Return the length of the duration in the specified unit.
     * @param {string} unit - a unit such as 'minutes' or 'days'
     * @example Duration.fromObject({years: 1}).as('days') //=> 365
     * @example Duration.fromObject({years: 1}).as('months') //=> 12
     * @example Duration.fromObject({hours: 60}).as('days') //=> 2.5
     * @return {number}
     */
    as(unit: string): number;
    /**
     * Reduce this Duration to its canonical representation in its current units.
     * Assuming the overall value of the Duration is positive, this means:
     * - excessive values for lower-order units are converted to higher-order units (if possible, see first and second example)
     * - negative lower-order units are converted to higher order units (there must be such a higher order unit, otherwise
     *   the overall value would be negative, see third example)
     * - fractional values for higher-order units are converted to lower-order units (if possible, see fourth example)
     *
     * If the overall value is negative, the result of this method is equivalent to `this.negate().normalize().negate()`.
     * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
     * @example Duration.fromObject({ days: 5000 }).normalize().toObject() //=> { days: 5000 }
     * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
     * @example Duration.fromObject({ years: 2.5, days: 0, hours: 0 }).normalize().toObject() //=> { years: 2, days: 182, hours: 12 }
     * @return {Duration}
     */
    normalize(): Duration;
    /**
     * Rescale units to its largest representation
     * @example Duration.fromObject({ milliseconds: 90000 }).rescale().toObject() //=> { minutes: 1, seconds: 30 }
     * @return {Duration}
     */
    rescale(): Duration;
    /**
     * Convert this Duration into its representation in a different set of units.
     * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
     * @return {Duration}
     */
    shiftTo(...units: any[]): Duration;
    /**
     * Shift this Duration to all available units.
     * Same as shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds")
     * @return {Duration}
     */
    shiftToAll(): Duration;
    /**
     * Return the negative of this Duration.
     * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
     * @return {Duration}
     */
    negate(): Duration;
    /**
     * Get the years.
     * @type {number}
     */
    get years(): number;
    /**
     * Get the quarters.
     * @type {number}
     */
    get quarters(): number;
    /**
     * Get the months.
     * @type {number}
     */
    get months(): number;
    /**
     * Get the weeks
     * @type {number}
     */
    get weeks(): number;
    /**
     * Get the days.
     * @type {number}
     */
    get days(): number;
    /**
     * Get the hours.
     * @type {number}
     */
    get hours(): number;
    /**
     * Get the minutes.
     * @type {number}
     */
    get minutes(): number;
    /**
     * Get the seconds.
     * @return {number}
     */
    get seconds(): number;
    /**
     * Get the milliseconds.
     * @return {number}
     */
    get milliseconds(): number;
    /**
     * Returns whether the Duration is invalid. Invalid durations are returned by diff operations
     * on invalid DateTimes or Intervals.
     * @return {boolean}
     */
    get isValid(): boolean;
    /**
     * Returns an error code if this Duration became invalid, or null if the Duration is valid
     * @return {string}
     */
    get invalidReason(): string;
    /**
     * Returns an explanation of why this Duration became invalid, or null if the Duration is valid
     * @type {string}
     */
    get invalidExplanation(): string;
    /**
     * Equality check
     * Two Durations are equal iff they have the same units and the same values for each unit.
     * @param {Duration} other
     * @return {boolean}
     */
    equals(other: Duration): boolean;
}
