import { Temporal } from 'temporal-polyfill';
/**
 * A FEEL <date> (e.g. `2020-04-06`).
 */
export declare class FeelDate {
    /**
     * @internal underlying temporal value
     */
    readonly value: Temporal.PlainDate;
    /**
     * @internal canonical ISO-8601 form; drives both display and
     * structural comparison
     */
    readonly iso: string;
    constructor(value: Temporal.PlainDate);
    get year(): number;
    get month(): number;
    get day(): number;
    get weekday(): number;
    /**
     * Return the underlying `Temporal.PlainDate`.
     *
     * Escape hatch for consumers that need the raw temporal value. The
     * returned type is implementation specific and may change.
     */
    unwrap(): Temporal.PlainDate;
    toString(): string;
    toJSON(): string;
}
/**
 * A FEEL <time>, either local (e.g. `10:30:00`) or zoned
 * (e.g. `10:30:00Z`, `10:30:00+05:00`, `10:30:00@Europe/Paris`).
 */
export declare class FeelTime {
    /**
     * @internal wall-clock time
     */
    readonly value: Temporal.PlainTime;
    /**
     * @internal time zone identifier, `null` for a local time
     */
    readonly zone: string | null;
    /**
     * @internal canonical form (wall-clock plus zone); drives both
     * display and structural comparison
     */
    readonly iso: string;
    constructor(value: Temporal.PlainTime, zone?: string | null);
    get hour(): number;
    get minute(): number;
    get second(): number;
    get timezone(): string;
    /**
     * The zone offset as a {@link FeelDuration}, or `null` for a local time.
     */
    get 'time offset'(): FeelDuration;
    /**
     * Return the underlying wall-clock `Temporal.PlainTime`.
     *
     * Escape hatch for consumers that need the raw temporal value. Zone
     * information is available via {@link timezone} / {@link 'time offset'}.
     */
    unwrap(): Temporal.PlainTime;
    toString(): string;
    toJSON(): string;
}
/**
 * A FEEL <date and time>, either local (e.g. `2020-04-06T10:30:00`) or
 * zoned (e.g. `...Z`, `...+05:00`, `...@Europe/Paris`).
 */
export declare class FeelDateTime {
    /**
     * @internal wall-clock date and time
     */
    readonly value: Temporal.PlainDateTime;
    /**
     * @internal time zone identifier, `null` for a local date time
     */
    readonly zone: string | null;
    /**
     * @internal canonical form (wall-clock plus zone); drives both
     * display and structural comparison
     */
    readonly iso: string;
    constructor(value: Temporal.PlainDateTime, zone?: string | null);
    get year(): number;
    get month(): number;
    get day(): number;
    get hour(): number;
    get minute(): number;
    get second(): number;
    get weekday(): number;
    get timezone(): string;
    get 'time offset'(): FeelDuration;
    /**
     * Return the underlying wall-clock `Temporal.PlainDateTime`.
     *
     * Escape hatch for consumers that need the raw temporal value. Zone
     * information is available via {@link timezone} / {@link 'time offset'}.
     */
    unwrap(): Temporal.PlainDateTime;
    toString(): string;
    toJSON(): string;
}
/**
 * A FEEL <duration>, both `years and months` and `days and time`
 * durations (e.g. `P1Y2M`, `P2DT3H`).
 */
export declare class FeelDuration {
    /**
     * @internal normalized underlying duration
     */
    readonly value: Temporal.Duration;
    /**
     * @internal whether this is a years and months (rather than a
     * days and time) duration; retained so the category survives even a
     * zero-valued duration (e.g. `P0M` vs `PT0S`)
     */
    readonly yearsMonths: boolean;
    /**
     * @internal category-aware canonical ISO-8601 form; drives both
     * display and structural comparison
     */
    readonly iso: string;
    constructor(value: Temporal.Duration, yearsMonths?: boolean);
    get years(): number;
    get months(): number;
    get days(): number;
    get hours(): number;
    get minutes(): number;
    get seconds(): number;
    /**
     * Return the underlying `Temporal.Duration`.
     *
     * Escape hatch for consumers that need the raw temporal value. The
     * returned type is implementation specific and may change.
     */
    unwrap(): Temporal.Duration;
    toString(): string;
    toJSON(): string;
}
/**
 * Any FEEL temporal instant (date, time or date time).
 */
export type FeelTemporal = FeelDate | FeelTime | FeelDateTime;
export declare function isDate(obj: any): obj is FeelDate;
export declare function isTime(obj: any): obj is FeelTime;
export declare function isDateTime(obj: any): obj is FeelDateTime;
export declare function isDuration(obj: any): obj is FeelDuration;
/**
 * Whether the value is any temporal instant (date, time or date time),
 * i.e. anything but a duration.
 */
export declare function isTemporal(obj: any): obj is FeelTemporal;
/**
 * Whether the temporal value carries a time zone.
 */
export declare function isZoned(obj: any): boolean;
/**
 * Whether two zone identifiers denote the same zone, for the purpose of
 * strict (`is`) equality: fixed offsets compare by offset (`Z` equals
 * `+00:00`), named zones only by identifier.
 */
export declare function zoneEquals(a: string | null, b: string | null): boolean;
/**
 * Convert a temporal value to a comparable number of milliseconds.
 *
 * Wall-clock (zone-less) values are anchored to UTC so they compare
 * consistently among themselves.
 */
export declare function toComparable(value: any): number | null;
/**
 * Whether two durations are equal, comparing years / months durations by
 * month and days / time durations by second (mirroring FEEL semantics).
 */
export declare function durationEquals(a: FeelDuration, b: FeelDuration): boolean;
export declare function duration(opts: string | number): FeelDuration | null;
/**
 * Return the absolute (non-negative) value of a duration.
 */
export declare function absDuration(d: FeelDuration): FeelDuration;
/**
 * Add (`sign > 0`) or subtract (`sign < 0`) a duration from a temporal
 * instant, returning a new temporal instant.
 *
 * A local <date> combined with a time-bearing duration is promoted to a
 * UTC <date and time> (bare dates are anchored in UTC).
 */
export declare function addDuration(temporal: FeelTemporal, dur: FeelDuration, sign: number): FeelTemporal;
/**
 * Subtract two temporal instants, yielding a {@link FeelDuration}.
 */
export declare function subtractTemporals(a: FeelTemporal, b: FeelTemporal): FeelDuration;
/**
 * Add (`sign > 0`) or subtract (`sign < 0`) two durations of the same
 * kind, returning `null` for a mixed-kind combination.
 *
 * Years / months and days / time durations are distinct FEEL types;
 * combining the two kinds is undefined (mirroring camunda/feel-scala,
 * which has no mixed-kind arithmetic case and yields `null`).
 */
export declare function addDurations(a: FeelDuration, b: FeelDuration, sign: number): FeelDuration | null;
/**
 * The <years and months duration> between two dates.
 */
export declare function yearsAndMonthsDuration(from: FeelDate, to: FeelDate): FeelDuration;
/**
 * Extract the calendar date of a date time.
 */
export declare function dateOf(dateTime: FeelDateTime): FeelDate;
/**
 * Extract the time-of-day of a date time, preserving its time zone.
 */
export declare function timeOf(dateTime: FeelDateTime): FeelTime;
/**
 * The midnight (UTC) time of a date.
 */
export declare function timeOfDate(_date: FeelDate): FeelTime;
/**
 * Combine a date (or the date part of a date time) with a time into a
 * date time, carrying over the time's zone.
 */
export declare function combine(date: FeelDate | FeelDateTime, time: FeelTime): FeelDateTime;
/**
 * Construct a {@link FeelDate} from components, returning `null` for
 * invalid input.
 */
export declare function dateFrom(year: number, month: number, day: number): FeelDate | null;
/**
 * Construct a {@link FeelTime} from components, returning `null` for
 * invalid input.
 *
 * An optional `offset` (a days and time duration) sets the time's zone,
 * e.g. `duration("PT5H")` yields a `+05:00` time.
 */
export declare function timeFrom(hour: number, minute: number, second: number, offset?: FeelDuration | null): FeelTime | null;
/**
 * Parse a FEEL <date> string (`2020-01-01`).
 *
 * Returns `null` if the input is not a valid date.
 */
export declare function parseDate(str: string): FeelDate | null;
/**
 * Parse a FEEL <time> string (`10:30:00`, `10:30:00Z`,
 * `10:30:00+01:00`, `10:30:00@Europe/Paris`).
 */
export declare function parseTime(str: string): FeelTime | null;
/**
 * Parse a FEEL <date and time> string (`2020-01-01T10:30:00`,
 * `...Z`, `...@Europe/Paris`).
 */
export declare function parseDateTime(str: string): FeelDateTime | null;
/**
 * Parse a FEEL date-ish string into the most specific temporal value:
 * a plain <date> or, if the string carries a time / zone, a
 * <date and time>.
 */
export declare function date(str: string): FeelTemporal | null;
/**
 * Parse a FEEL <time> string into a {@link FeelTime}.
 */
export declare function time(str: string): FeelTime | null;
/**
 * Parse a FEEL <date and time> string into a {@link FeelDateTime}.
 */
export declare function dateAndTime(str: string): FeelDateTime | null;
/**
 * The current system date and time as a zoned value.
 */
export declare function now(): FeelDateTime;
/**
 * The current system date.
 */
export declare function today(): FeelDate;
/**
 * Coerce a raw temporal value into its FEEL wrapper.
 *
 * Accepts the wrapper types (returned as-is), native `Temporal` values
 * and native `Date` instances. Anything else is returned untouched.
 */
export declare function toFeel(value: any): any;