import type { Enumerate, LocaleCode, NumberRange } from '../number/types';
import type { LooseLiteral, TupleOf } from '../utils/types';
import { INTERNALS } from './constants';
import type { ChronosInput, ChronosInternals, ChronosMethods, ChronosObject, ChronosPlugin, DateRangeOptions, FormatOptions, MilliSecond, MonthName, Quarter, RangeWithDates, RelativeDateRange, RelativeRangeOptions, StrictFormat, TimeDuration, TimeParts, TimeUnit, UTCOffSet, WeekDay } from './types';
/**
 * * Creates a new immutable `Chronos` instance.
 *
 * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
 * and convert it to the **equivalent local time** using the current environment's UTC offset.*
 *
 * @param value - A date value (`number`, `string`, `Date`, or `Chronos` object).
 * - If a string is provided, it should be in a format that can be parsed by the Date constructor.
 * - If a number is provided, it should be a timestamp (milliseconds since the Unix epoch).
 * - If a Date object is provided, it will be used as is.
 * - If a Chronos object is provided, it will be converted to a Date object.
 *
 * **It also accepts number values as following:**
 * - **`year, month, date, hours, minutes, seconds, milliseconds`**: Individual components of a date-time to construct a `Chronos` instance.
 *   - **`year`**: A number representing the year. If the year is between 0 and 99, it will be assumed to be the year 1900 + the provided year.
 *   - **`month`**: A number between 1 and 12 representing the month (1 for January, 12 for December). It is adjusted internally to a 0-based index (0 for January, 11 for December).
 *   - **`date`**: A number between 1 and 31 representing the day of the month.
 *   - **`hours`**: A number between 0 and 23 representing the hour of the day.
 *   - **`minutes`**: A number between 0 and 59 representing the minutes past the hour.
 *   - **`seconds`**: A number between 0 and 59 representing the seconds past the minute.
 *   - **`milliseconds`**: A number between 0 and 999 representing the milliseconds past the second.
 *
 * @returns Instance of `Chronos` with all methods and properties.
 */
export declare class Chronos {
    #private;
    /** Use `readonly and/or private` methods outside `Chronos`. Purpose: Plugin creation. */
    protected static [INTERNALS]: ChronosInternals;
    /**
     * * Chronos date/time in Native JS `Date` format.
     *
     * - **NOTE**: It is **HIGHLY** advised *not to rely* on this public property to access native JS `Date`. It's not reliable when timezone and/or UTC related operations are performed. If you really need to use native `Date`, use `toDate` method.  THis property is purely for developer convenience and sugar.
     */
    native: Date;
    /** Origin of the `Chronos` instance (Method that created `new Chronos`), useful fo tracking instance. */
    origin: ChronosMethods | 'root';
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * Accepts no arguments (defaults to now).
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor();
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * @param value - A date value in `number`, it should be a timestamp (milliseconds since the Unix epoch).
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(value: number);
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
     * and convert it to the **equivalent local time** using the current environment's UTC offset.*
     *
     * @param value - A date value in `string`, it should be in a format that can be parsed by the `Date` constructor.
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(value: string);
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
     * and convert it to the **equivalent local time** using the current environment's UTC offset.*
     *
     * @param value - A date value as `Date` object, it will be used as is.
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(value: Date);
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
     * and convert it to the **equivalent local time** using the current environment's UTC offset.*
     *
     * @param value - A date value as `Chronos` object.
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(value: Chronos);
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
     * and convert it to the **equivalent local time** using the current environment's UTC offset.*
     *
     * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year.
     * @param month The month as a number between 1 and 12 (January to December).
     * @param date The date as a number between 1 and 31.
     * @param hours Must be supplied if minutes is supplied. A number from 0 to 23 (midnight to 11pm) that specifies the hour.
     * @param minutes Must be supplied if seconds is supplied. A number from 0 to 59 that specifies the minutes.
     * @param seconds Must be supplied if milliseconds is supplied. A number from 0 to 59 that specifies the seconds.
     * @param ms A number from 0 to 999 that specifies the milliseconds.
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number);
    /**
     * * Creates a new immutable `Chronos` instance.
     *
     * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
     * and convert it to the **equivalent local time** using the current environment's UTC offset.*
     *
     * @param value - A date value (`number`, `string`, `Date`, or `Chronos` object).
     * - If a string is provided, it should be in a format that can be parsed by the `Date` constructor.
     * - If a number is provided, it should be a timestamp (milliseconds since the Unix epoch).
     * - If a Date object is provided, it will be used as is.
     * - If a Chronos object is provided, it will be used directly.
     *
     * @returns Instance of `Chronos` with all methods and properties.
     */
    constructor(value?: ChronosInput);
    [Symbol.iterator](): IterableIterator<[string, number]>;
    /**
     * * Enables primitive coercion like `console.log`, `${chronos}`, etc.
     * @param hint - The type hint provided by the JS engine.
     * @returns The primitive value based on the hint.
     */
    [Symbol.toPrimitive](hint: string): string | number;
    [Symbol.replace](string: string, replacement: string): string;
    [Symbol.search](string: string): number;
    [Symbol.split](string: string): string[];
    get [Symbol.toStringTag](): string;
    /** Gets the full year of the date. */
    get year(): number;
    /** Gets the month (0-11) of the date. */
    get month(): Enumerate<12>;
    /** Gets the day of the month (1-31). */
    get date(): NumberRange<1, 31>;
    /** Gets the day of the week (0-6, where 0 is Sunday). */
    get weekDay(): Enumerate<7>;
    /** Gets the hour (0-23) of the date. */
    get hour(): Enumerate<24>;
    /** Gets the minute (0-59) of the date. */
    get minute(): Enumerate<60>;
    /** Gets the second (0-59) of the date. */
    get second(): Enumerate<60>;
    /** Gets the millisecond (0-999) of the date. */
    get millisecond(): MilliSecond;
    /** Gets ISO weekday: 1 = Monday, 7 = Sunday */
    get isoWeekDay(): 1 | 2 | 5 | 3 | 4 | 6 | 7;
    /** Gets ISO month (1–12 instead of 0–11) */
    get isoMonth(): NumberRange<1, 12>;
    /** Returns the Unix timestamp (seconds since the Unix epoch: January 1, 1970, UTC). */
    get unix(): number;
    /** Gets the time value in milliseconds since midnight, January 1, 1970 UTC. */
    get timestamp(): number;
    /** * Gets the last date (number) of the current month `(28, 29, 30 or 31)`. */
    get lastDateOfMonth(): NumberRange<28, 31>;
    /** @instance Returns a debug-friendly string for `console.log` or `util.inspect`. */
    inspect(): string;
    /** @instance Enables JSON.stringify and logging in the console (in Browser environment) to show readable output. */
    toJSON(): string;
    /** @instance Enables arithmetic and comparison operations (e.g., +new Chronos()). */
    valueOf(): number;
    /** @instance Clones and returns a new Chronos instance with the same date. */
    clone(): Chronos;
    /** @instance Gets the native `Date` instance (read-only). */
    toDate(): Date;
    /** @instance Returns a string representation of a date. The format of the string depends on the locale. */
    toString(): string;
    /** @instance Returns ISO string with local time zone offset */
    toLocalISOString(): string;
    /** @instance Returns a date as a string value in ISO format. */
    toISOString(): string;
    /**
     * @instance Wrapper over native `toLocaleString`
     * @description Converts a date and time to a string by using the current or specified locale.
     *
     * @param locales A locale string, array of locale strings, Intl.Locale object, or array of Intl.Locale objects that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
     * @param options An object that contains one or more properties that specify comparison options.
     */
    toLocaleString(locale?: LocaleCode | Intl.Locale | (LocaleCode | Intl.Locale)[], options?: Intl.DateTimeFormatOptions): string;
    /** @instance Returns the time value in milliseconds since midnight, January 1, 1970 UTC. */
    getTimeStamp(): number;
    /**
     * @instance Formats the current date into a custom string format (local time by default).
     *
     * @param format - The desired format string (Default: `dd, mmm DD, YYYY HH:mm:ss` → e.g., `Sun, Apr 06, 2025 16:11:55`).
     *
     * - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
     * - For example, `[Today is] ddd` results in `Today is Sunday`, and `YYYY[ year]` results in `2025 year`.
     *
     * - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `HH`, `H`, `hh`, `h`, `mm`, `m`, `ss`, `s`, `ms`, `mss`, `a`, `A`, and `ZZ`.
     * - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/format#format-tokens format tokens} for detailed usage.
     *
     * @param useUTC - Optional boolean to format the date using UTC time.
     * When `true`, it behaves like `formatUTC()` and outputs time based on UTC offset. Defaults to `false`.
     *
     * @returns Formatted date string using the specified format.
     * Uses local time by default unless `useUTC` is set to `true`.
     */
    format(format?: string, useUTC?: boolean): string;
    /**
     * @instance Formats the date into a predefined strict string format using local time or UTC.
     *
     * @remarks Offers over 21,000 predefined formats with full IntelliSense support.
     *
     * @param format - The desired format string. Defaults to `'dd, mmm DD, YYYY HH:mm:ss'`
     *                 (e.g., `'Sun, Apr 06, 2025 16:11:55'`).
     *	 - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/format#format-tokens format tokens} for detailed usage.
     *
     * @param useUTC - If `true`, formats the date in UTC (equivalent to `formatUTC()`);
     *                 Defaults to `false` (local time).
     * @returns A formatted date string in the specified format
     */
    formatStrict(format?: StrictFormat, useUTC?: boolean): string;
    /**
     * @instance Formats the date into a custom string format (UTC time).
     *
     * @param format - The desired format (Default format is `dd, mmm DD, YYYY HH:mm:ss:mss` = `Sun, Apr 06, 2025 16:11:55:379`).
     *
     * - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
     * - For example, `[Today is] ddd` results in `Today is Sunday`, and `YYYY[ year]` results in `2025 year`.
     *
     * - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `HH`, `H`, `hh`, `h`, `mm`, `m`, `ss`, `s`, `mss`, `a`, `A`, and `ZZ`.
     * - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/format#format-tokens format tokens} for detailed usage.
     *
     * @returns Formatted date string in desired format (UTC time).
     */
    formatUTC(format?: string): string;
    /**
     * @instance Adds seconds and returns a new immutable instance.
     * @param seconds - Number of seconds to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addSeconds(seconds: number): Chronos;
    /**
     * @instance Adds minutes and returns a new immutable instance.
     * @param minutes - Number of minutes to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addMinutes(minutes: number): Chronos;
    /**
     * @instance Adds hours and returns a new immutable instance.
     * @param hours - Number of hours to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addHours(hours: number): Chronos;
    /**
     * @instance Adds days and returns a new immutable instance.
     * @param days - Number of days to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addDays(days: number): Chronos;
    /**
     * @instance Adds weeks and returns a new immutable instance.
     * @param weeks - Number of weeks to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addWeeks(weeks: number): Chronos;
    /**
     * @instance Adds months and returns a new immutable instance.
     * @param months - Number of months to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addMonths(months: number): Chronos;
    /**
     * @instance Adds years and returns a new immutable instance.
     * @param years - Number of years to add.
     * @returns A new `Chronos` instance with the updated date.
     */
    addYears(years: number): Chronos;
    /**
     * @instance Checks if the current year is a leap year.
     * - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
     * - For example, 2000 and 2400 are leap years, but 1900 and 2100 are not.
     * @param year - Optional year to check. Default is the year from current `Chronos` instance.
     * @returns `true` if the year is a leap year, `false` otherwise.
     */
    isLeapYear(year?: number): boolean;
    /** @instance Checks if another date is exactly equal to this one */
    isEqual(other: ChronosInput): boolean;
    /** @instance Checks if another date is exactly equal to or before this one */
    isEqualOrBefore(other: ChronosInput): boolean;
    /** @instance Checks if another date is exactly equal to or after this one */
    isEqualOrAfter(other: ChronosInput): boolean;
    /**
     * @instance Checks if another date is the same as this one in a specific unit.
     * @param other The other date to compare.
     * @param unit The unit to compare.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    isSame(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
    /**
     * @instance Checks if this date is before another date in a specific unit.
     * @param other The other date to compare.
     * @param unit The unit to compare.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    isBefore(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
    /**
     * @instance Checks if this date is after another date in a specific unit.
     * @param other The other date to compare.
     * @param unit The unit to compare.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    isAfter(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
    /**
     * @instance Checks if this date is the same or before another date in a specific unit.
     * @param other The other date to compare.
     * @param unit The unit to compare.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    isSameOrBefore(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
    /**
     * @instance Checks if this date is the same or after another date in a specific unit.
     * @param other The other date to compare.
     * @param unit The unit to compare.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    isSameOrAfter(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
    /**
     * @instance Checks if the current date is between the given start and end dates.
     *
     * @param start - The start of the range.
     * @param end - The end of the range.
     * @param inclusive - Specifies whether the comparison is inclusive or exclusive:
     * - `'[]'`: inclusive of both start and end (≥ start and ≤ end)
     * - `'[)'`: inclusive of start, exclusive of end (≥ start and < end)
     * - `'(]'`: exclusive of start, inclusive of end (> start and ≤ end)
     * - `'()'`: exclusive of both start and end (> start and < end)
     *
     * @returns `true` if the current date is within the specified range based on the `inclusive` mode.
     */
    isBetween(start: ChronosInput, end: ChronosInput, inclusive?: '[]' | '[)' | '(]' | '()'): boolean;
    /**
     * @instance Checks if the date is within daylight saving time (DST).
     * @returns Whether the date is in DST.
     */
    isDST(): boolean;
    /** @instance Checks if current day is the first day of the current month. */
    isFirstDayOfMonth(): boolean;
    /** @instance Checks if current day is the last day of the current month. */
    isLastDayOfMonth(): boolean;
    /** @instance Returns a new Chronos instance set to the first day of the current month. */
    firstDayOfMonth(): Chronos;
    /** @instance Returns a new Chronos instance set to the last day of the current month. */
    lastDayOfMonth(): Chronos;
    /**
     * @instance Returns a new Chronos instance at the start of a given unit.
     * @param unit The unit to reset (e.g., year, month, day).
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    startOf(unit: TimeUnit, weekStartsOn?: Enumerate<7>): Chronos;
    /**
     * @instance Returns a new Chronos instance at the end of a given unit.
     * @param unit The unit to adjust (e.g., year, month, day).
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     */
    endOf(unit: TimeUnit, weekStartsOn?: Enumerate<7>): Chronos;
    /**
     * @instance Returns a new Chronos instance with the specified unit added.
     * @param number The number of time unit to add (can be negative).
     * @param unit The time unit to add.
     */
    add(number: number, unit: TimeUnit): Chronos;
    /**
     * @instance Returns a new Chronos instance with the specified unit subtracted.
     * @param number The number of time unit to subtract (can be negative).
     * @param unit The time unit to add.
     */
    subtract(number: number, unit: TimeUnit): Chronos;
    /**
     * @instance Gets the value of a specific time unit from the date.
     * @param unit The unit to retrieve.
     */
    get(unit: TimeUnit): number;
    /**
     * @instance Returns a new Chronos instance with the specified unit set to the given value.
     * @param unit The unit to modify.
     * @param value The value to set for the unit.
     */
    set(unit: TimeUnit, value: number): Chronos;
    /**
     * @instance Returns the difference between this and another date in the given unit.
     * @param other The other date to compare.
     * @param unit The unit in which to return the difference.
     */
    diff(other: ChronosInput, unit: TimeUnit): number;
    /**
     * @instance Returns a human-readable relative calendar time like "Today at 3:00 PM"
     * @param baseDate Optional base date to compare with.
     */
    calendar(baseDate?: ChronosInput): string;
    /** @instance Returns a short human-readable string like "2h ago", "in 5m" */
    fromNowShort(): string;
    /**
     * @instance Sets the date to the Monday of the specified ISO week number within the current year.
     * This method assumes ISO week logic, where week 1 is the week containing January 4th.
     *
     * @param week The ISO week number (1–53) to set the date to.
     * @returns A new Chronos instance set to the start (Monday) of the specified week.
     */
    setWeek(week: NumberRange<1, 53>): Chronos;
    /**
     * @instance Calculates the ISO 8601 week number of the year.
     *
     * ISO weeks start on Monday, and the first week of the year is the one containing January 4th.
     *
     * @returns Week number (1–53).
     */
    getWeek(): NumberRange<1, 53>;
    /**
     * @instance Calculates the week number of the year based on custom week start.
     * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
     * @returns Week number (1-53).
     */
    getWeekOfYear(weekStartsOn?: Enumerate<7>): NumberRange<1, 53>;
    /**
     * @instance Returns the ISO week-numbering year for the current date.
     *
     * The ISO week-numbering year may differ from the calendar year.
     * For example, January 1st may fall in the last ISO week of the previous year.
     *
     * @param weekStartsOn Optional: Defines the start day of the week (0 = Sunday, 1 = Monday).
     *                     Defaults to 0 (Sunday). Use 1 for strict ISO 8601.
     * @returns The ISO week-numbering year.
     */
    getWeekYear(weekStartsOn?: Enumerate<7>): number;
    /** @instance Returns day of year (1 - 366) */
    getDayOfYear(): NumberRange<1, 366>;
    /** @instance Returns number of days in current month */
    daysInMonth(): NumberRange<28, 31>;
    /** @instance Converts to object with all date unit parts */
    toObject(): ChronosObject;
    /** @instance Converts to array with all date unit parts */
    toArray(): TupleOf<number, 12>;
    /**
     * @instance Returns the **calendar quarter** (1 to 4) of the current date.
     *
     * @remarks
     * A calendar year is divided into four quarters:
     *
     * - `Q1`: January to March
     * - `Q2`: April to June
     * - `Q3`: July to September
     * - `Q4`: October to December
     *
     * This method strictly uses the **calendar year**. For fiscal quarters, use `toFiscalQuarter()` instead.
     *
     * @example
     * new Chronos('2025-02-14').toQuarter(); // 1
     * new Chronos('2025-08-09').toQuarter(); // 3
     *
     * @returns The calendar quarter number (1–4).
     */
    toQuarter(): Quarter;
    /**
     * @instance Returns the system's current UTC offset formatted as `+06:00` or `-07:00`.
     *
     * - *Unlike `Date.prototype.getTimezoneOffset()`, which returns the offset in minutes **behind** UTC (positive for locations west of UTC and negative for east), this method returns the more intuitive sign format used in time zone representations (e.g., `UTC+06:00` means 6 hours **ahead** of UTC).*
     *
     * @returns The (local) system's UTC offset in `±HH:mm` format.
     */
    getUTCOffset(): string;
    /**
     * @instance Returns the timezone offset of this `Chronos` instance in `+06:00` or `-07:00` format maintaining current timezone.
     *
     * - *Unlike `Date.prototype.getTimezoneOffset()`, which returns the offset in minutes **behind** UTC (positive for locations west of UTC and negative for east), this method returns the more intuitive sign format used in time zone representations (e.g., `UTC+06:00` means 6 hours **ahead** of UTC).*
     *
     * @returns The timezone offset string in `±HH:mm` format maintaining the current timezone regardless of system having different one.
     */
    getTimeZoneOffset(): string;
    /**
     * @instance Returns the system's UTC offset in minutes.
     *
     * - *Unlike JavaScript's `Date.prototype.getTimezoneOffset()`, this method returns a positive value if the local time is ahead of UTC, and negative if behind UTC.*
     *
     * For example, for `UTC+06:00`, this returns `360`; for `UTC-05:30`, this returns `-330`.
     *
     * @returns The system's UTC offset in minutes, matching the sign convention used in `±HH:mm`.
     */
    getUTCOffsetMinutes(): number;
    /**
     * @instance Returns the current `Chronos` instance's UTC offset in minutes.
     *
     * This reflects the parsed or stored offset used internally by Chronos and follows the same
     * sign convention: positive for timezones ahead of UTC, negative for behind.
     *
     * @returns The UTC offset in minutes maintaining the current timezone regardless of system having different one.
     */
    getTimeZoneOffsetMinutes(): number;
    /**
     * @instance Returns the current time zone name as a full descriptive string (e.g. `"Bangladesh Standard Time"`).
     * @param utc Optional UTC offset in `"UTC+06:00"` format. When passed, it bypasses the current time zone offset.
     * @returns Time zone name in full descriptive string or UTC offset if it is not a valid time zone.
     * @remarks
     * - This method uses a predefined mapping of UTC offsets to time zone names.
     * - If multiple time zones share the same UTC offset, it returns the **first match** from the predefined list.
     * - If no match is found (which is rare), it falls back to returning the UTC offset (e.g. `"UTC+06:00"`).
     */
    getTimeZoneName(utc?: UTCOffSet): LooseLiteral<UTCOffSet>;
    /** @instance Returns new Chronos instance in UTC */
    toUTC(): Chronos;
    /** @instance Returns new Chronos instance in local time */
    toLocal(): Chronos;
    /**
     * @instance Rounds the current date-time to the nearest specified unit and interval.
     *
     * - *Rounding is based on proximity to the start or end of the specified unit.*
     * - *For example, rounding `2025-05-23` by 'day' returns either midnight of May 23 or May 24, depending on the time of day.*
     *
     * @param unit - The time unit to round to (`year`, `month`, `week`, `day`, `hour`, `minute`, `second`, `millisecond`).
     * @param nearest - Optional granularity of rounding. (Defaults to `1`).
     *
     * @returns A new `Chronos` instance at the nearest rounded point in time. For wrong unit returns current instance.
     *
     * @remarks
     * - Rounding for `'month'` is based on how far into the month the date is. If past the midpoint, it rounds to the next month.
     *   - Month indices are 0-based internally (January = 0), but the resulting date reflects the correct calendar month.
     * - For `'week'` unit, rounding is performed by comparing proximity to the start and end of the ISO week (Monday to Sunday).
     *   - If the date is closer to the next Monday, it rounds forward; otherwise, it rounds back to the previous Monday.
     */
    round(unit: TimeUnit, nearest?: number): Chronos;
    /**
     * @instance Returns the full time duration breakdown between current input (start) and another time (to).
     * @param toTime The time to compare with. Defaults to now.
     * @param absolute If true, returns all values as positive numbers. Defaults to `true`.
     * @returns An object of time units: years, months, days, hours, minutes, seconds, milliseconds.
     */
    duration(toTime?: ChronosInput, absolute?: boolean): TimeDuration;
    /**
     * @instance Returns the name of the current day or optional day index.
     * @param index Optional day index (0–6, where 0 is Sunday) to override current day.
     * @returns Name of the weekday.
     */
    day(index?: Enumerate<7>): WeekDay;
    /**
     * @instance Returns the name of the current month or optional month index.
     * @param index Optional month index (0–11, where 0 is January) to override current month.
     * @returns Name of the month.
     */
    monthName(index?: Enumerate<12>): MonthName;
    /**
     * @instance Returns an array of ISO date strings within a specific date range.
     *
     * - If the input is a fixed range (`from` and `to`), it includes all dates between them.
     * - If the input is a relative range (`span` and `unit`), it starts from current date and goes forward.
     * - If `skipDays` are provided, matching weekdays are excluded from the result.
     *
     * @param options - Configuration for the date range. Accepts a fixed (`RangeWithDates`) format.
     * @returns Array of ISO date strings in either local or UTC format, excluding any skipped weekdays if specified.
     *
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/calculation#getdatesinrange the documentation site} for detailed usage.
     *
     * @example
     * // Using a fixed date range:
     * new Chronos().getDatesInRange({ from: '2025-01-01', to: '2025-01-03' });
     * // → ['2025-01-01T00:00:00+06:00', '2025-01-02T00:00:00+06:00', '2025-01-03T00:00:00+06:00']
     *
     * @example
     * // Using a relative date range with skipDays:
     * new Chronos().getDatesInRange({ span: 7, unit: 'day', skipDays: ['Saturday', 'Sunday'] });
     * // → Array of 7 dates excluding weekends
     *
     * @example
     * // UTC format:
     * new Chronos().getDatesInRange({ span: 2, unit: 'day', format: 'utc' });
     * // → ['2025-06-16T00:00:00.000Z', '2025-06-17T00:00:00.000Z']
     */
    getDatesInRange(options?: RangeWithDates): string[];
    /**
     * @instance Returns an array of ISO date strings within a specific date range.
     *
     * - If the input is a fixed range (`from` and `to`), it includes all dates between them.
     * - If the input is a relative range (`span` and `unit`), it starts from current date and goes forward.
     * - If `skipDays` are provided, matching weekdays are excluded from the result.
     *
     * @param options - Configuration for the date range. Accepts a relative (`RelativeDateRange`) format.
     * @returns Array of ISO date strings in either local or UTC format, excluding any skipped weekdays if specified.
     *
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/calculation#getdatesinrange the documentation site} for detailed usage.
     *
     * @example
     * // Using a relative date range with skipDays:
     * new Chronos().getDatesInRange({ span: 7, unit: 'day', skipDays: ['Saturday', 'Sunday'] });
     * // → Array of 7 dates excluding weekends
     *
     * @example
     * // UTC format:
     * new Chronos().getDatesInRange({ span: 2, unit: 'day', format: 'utc' });
     * // → ['2025-06-16T00:00:00.000Z', '2025-06-17T00:00:00.000Z']
     *
     * @example
     * // Using a fixed date range:
     * new Chronos().getDatesInRange({ from: '2025-01-01', to: '2025-01-03' });
     * // → ['2025-01-01T00:00:00+06:00', '2025-01-02T00:00:00+06:00', '2025-01-03T00:00:00+06:00']
     */
    getDatesInRange(options?: RelativeDateRange): string[];
    /**
     * @static Parses a date string with a given format (limited support only).
     *
     * * **Supported format tokens**:
     * - `YYYY`: Full year (e.g., 2023)
     * - `YY`: Two-digit year (e.g., 23 for 2023, 99 for 1999)
     * - `MM`: Month (01-12)
     * - `M`: Month (1-9)
     * - `DD`: Day of the month (01-31)
     * - `D`: Day of the month (1-9)
     * - `HH`: Hour (00-23)
     * - `H`: Hour (0-9)
     * - `mm`: Minute (00-59)
     * - `m`: Minute (0-9)
     * - `ss`: Second (00-59)
     * - `s`: Second (0-9)
     *
     * **Example**:
     * ```ts
     * Chronos.parse('23-12-31 15:30:45', 'YY-MM-DD HH:mm:ss');
     * // returns Chronos instance with the parsed date 2023-12-31T15:30:45
     * ```
     *
     * @param dateStr - The date string to be parsed
     * @param format - The format of the date string. Tokens like `YYYY`, `MM`, `DD`, `HH`, `mm`, `ss` are used to specify the structure.
     * @returns A new `Chronos` instance representing the parsed date.
     * @throws `Error` If the date string does not match the format.
     */
    static parse(dateStr: string, format: string): Chronos;
    /**
     * @static Returns the current date and time in a specified format in local time.
     * * Default format is dd, `mmm DD, YYYY HH:mm:ss` = `Sun, Apr 06, 2025 16:11:55`
     * @param options - Configure format string and whether to format using utc offset.
     * @returns Formatted date string in desired format.
     */
    static today(options?: FormatOptions): string;
    /**
     * @static Returns a new `Chronos` instance representing yesterday's date.
     *
     * @returns A `Chronos` instance for the previous calendar day.
     */
    static yesterday(): Chronos;
    /**
     * @static Returns a new `Chronos` instance representing tomorrow's date.
     *
     * @returns A `Chronos` instance for the next calendar day.
     */
    static tomorrow(): Chronos;
    /**
     * @static Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).
     * * It basically calls `Date.now()`.
     * @returns The number of milliseconds elapsed since the Unix epoch.
     */
    static now(): number;
    /**
     * @static Creates a UTC-based Chronos instance.
     * If no date is provided, it uses the current date and time.
     *
     * **This is the base time, meaning conversion in other timezone will consider UTC time as the base time.**
     *
     * @param dateLike Optional input date to base the UTC time on.
     * If omitted, the current system date/time is used.
     * @returns A new Chronos instance representing the UTC equivalent of the input.
     */
    static utc(dateLike?: ChronosInput): Chronos;
    /**
     * @static Formats a time-only string into a formatted time string.
     *
     * @param time - Time string to be formatted. Supported formats include:
     * - `HH:mm` → e.g., `'14:50'`
     * - `HH:mm:ss` → e.g., `'14:50:00'`
     * - `HH:mm:ss.mss` → e.g., `'14:50:00.800'`
     * - `HH:mm+TimeZoneOffset(HH)` → e.g., `'14:50+06'`
     * - `HH:mm+TimeZoneOffset(HH:mm)` → e.g., `'14:50+06:00'`
     * - `HH:mm:ss+TimeZoneOffset(HH)` → e.g., `'14:50:00+06'`
     * - `HH:mm:ss+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00+05:30'`
     * - `HH:mm:ss.mss+TimeZoneOffset(HH)` → e.g., `'14:50:00.800+06'`
     * - `HH:mm:ss.mss+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00.800+06:30'`
     *
     * * *Input will default to today's date and assume local timezone if no offset is provided.*
     *
     * @param format - Format string accepted by `formatStrict()` method (`TimeParts`). Default: `hh:mm:ss a` → 02:33:36 pm.
     * @returns Formatted time string in local (System) time.
     */
    static formatTimePart(time: string, format?: TimeParts): string;
    /**
     * @static Returns ISO date strings for each occurrence of a weekday from today, spanning a relative time range.
     *
     * @param day - The weekday to match (e.g., `'Wednesday'`, `'Sunday'`).
     * @param options - Relative range (e.g., 7 days, 4 weeks) and output format (local with timezone or utc).
     * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the time span.
     *
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/statics#getdatesforday the documentation site} for detailed usage.
     *
     * @example
     * Chronos.getDatesForDay('Wednesday', { span: 7, unit: 'day' });
     * //=> [ '2025-05-28T21:16:06.198+06:00', '2025-06-04T21:16:06.198+06:00' ]
     *
     * @example
     * Chronos.getDatesForDay('Wednesday', {
     *   span: 7,
     *   unit: 'day',
     *   format: 'utc'
     * });
     * //=> [ '2025-05-28T15:17:10.812Z', '2025-06-04T15:17:10.812Z' ]
     */
    static getDatesForDay(day: WeekDay, options?: RelativeRangeOptions): string[];
    /**
     * @static Returns ISO date strings for each occurrence of a weekday between two fixed dates.
     *
     * @param day - The weekday to match (e.g., `'Monday'`, `'Friday'`).
     * @param options - Absolute date range (e.g. `'2025-06-30'`, ` new Date()`, `new Chronos()` etc.) and output format (local with timezone or utc).
     * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the range.
     *
     * - Please refer to {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/statics#getdatesforday the documentation site} for detailed usage.
     *
     * @example
     * Chronos.getDatesForDay('Monday', {
     *   from: '2025-05-28',
     *   to: '2025-06-30',
     *   format: 'local'
     * });
     * //=> [ '2025-01-06T...', '2025-01-13T...', ... ]
     */
    static getDatesForDay(day: WeekDay, options?: DateRangeOptions): string[];
    /**
     * @static Returns earliest Chronos
     * @param dates Date inputs.
     */
    static min(...dates: ChronosInput[]): Chronos;
    /**
     * @static Returns latest Chronos
     * @param dates Date inputs.
     */
    static max(...dates: ChronosInput[]): Chronos;
    /**
     * @static Checks if the year in the date string or year (from 0 - 9999) is a leap year.
     * - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
     * - For example, 2000 and 2400 are leap years, but 1900 and 2100 are not.
     *
     * @description
     * This method accepts different types of date inputs and extracts the year to check if it's a leap year.
     * If the provided date is a `number`, it will be treated as a year (must be a valid year from 0 to 9999).
     * If the year is out of this range (negative or larger than 9999), it will be treated as a Unix timestamp.
     * If the provided date is a string or a `Date` object, it will be parsed and the year will be extracted.
     * If a `Chronos` instance is passed, the year will be directly accessed from the instance.
     *
     * @param date - A `number` (year or Unix timestamp), `string`, `Date`, or `Chronos` instance representing a date.
     * @returns `true` if the year is a leap year, `false` otherwise.
     */
    static isLeapYear(date: ChronosInput): boolean;
    /**
     * @static Checks if the given value is a valid `Date` object.
     * - A value is considered valid if it is an instance of the built-in `Date` class.
     * - This does not check whether the date itself is valid (e.g., `new Date('invalid')`).
     * @param value - The value to test.
     * @returns `true` if the value is a valid Date object, otherwise `false`.
     */
    static isValidDate(value: unknown): value is Date;
    /**
     * @static Checks if the given value is a valid date string.
     * - A value is considered a valid date string if it is a string and can be parsed by `Date.parse()`.
     * - This uses the native JavaScript date parser internally.
     * @param value - The value to test.
     * @returns `true` if the value is a valid date string, otherwise `false`.
     */
    static isDateString(value: unknown): value is string;
    /**
     * @static Checks if the given value is an instance of `Chronos`.
     * - Useful for verifying Chronos objects in type guards or validations.
     * @param value - The value to test.
     * @returns `true` if the value is an instance of `Chronos`, otherwise `false`.
     */
    static isValidChronos(value: unknown): value is Chronos;
    /**
     * @static Injects a plugin into the `Chronos` system.
     * @param plugin The plugin to inject.
     *
     * - **NOTE:** *Once a plugin is injected, all the registered methods for that plugin will be available for the whole project.*
     * - See full list of plugins and the methods they register {@link https://nhb-toolbox.vercel.app/docs/classes/Chronos/plugins#-official-plugins here}
     */
    static use(plugin: ChronosPlugin): void;
}
//# sourceMappingURL=Chronos.d.ts.map