Duration API

/**
 * Create Duration from milliseconds
 * @param count - Number of milliseconds
 * @param opts - Options including locale, numberingSystem, conversionAccuracy
 */
static fromMillis(count: number, opts?): Duration;

/**
 * Create Duration from object with duration units
 * @param obj - Object with duration properties (years, months, days, etc.)
 * @param opts - Options including locale, numberingSystem, conversionAccuracy
 */
static fromObject(obj: object, opts?): Duration;

/**
 * Create Duration from Duration-like input
 * @param durationLike - Duration instance, object, or number (milliseconds)
 */
static fromDurationLike(durationLike: Duration | object | number): Duration;

/**
 * Parse Duration from ISO 8601 duration string
 * @param text - ISO 8601 duration string (e.g., "P1Y2M3DT4H5M6S")
 * @param opts - Options including locale, numberingSystem, conversionAccuracy
 */
static fromISO(text: string, opts?): Duration;

/**
 * Parse Duration from ISO 8601 time string (if less than 24 hours)
 * @param text - ISO 8601 time string (e.g., "14:30:15")
 * @param opts - Options including locale, numberingSystem, conversionAccuracy
 */
static fromISOTime(text: string, opts?): Duration;

/**
 * Create an invalid Duration
 * @param reason - Reason for invalidity
 * @param explanation - Additional explanation
 */
static invalid(reason: string, explanation?: string): Duration;

/**
 * Check if object is a Duration instance
 * @param o - Object to check
 */
static isDuration(o: any): boolean;

// Configuration
locale: string;
numberingSystem: string;

// Duration components
years: number;
quarters: number;
months: number;
weeks: number;
days: number;
hours: number;
minutes: number;
seconds: number;
milliseconds: number;

// Validation
isValid: boolean;
invalidReason: string | null;
invalidExplanation: string | null;

/**
 * Format duration with custom format string
 * @param fmt - Format pattern using duration tokens
 * @param opts - Options including round
 */
toFormat(fmt: string, opts?): string;

/**
 * Human-readable string with all significant units
 * @param opts - Options including listStyle, unitDisplay, locale
 */
toHuman(opts?): string;

/**
 * Convert to JavaScript object
 */
toObject(): object;

/**
 * Convert to ISO 8601 duration string
 */
toISO(): string;

/**
 * Convert to ISO 8601 time string (if less than 24 hours)
 * @param opts - Options including suppressMilliseconds, suppressSeconds
 */
toISOTime(opts?): string;

/**
 * JSON representation (ISO string)
 */
toJSON(): string;

/**
 * String representation (ISO format)
 */
toString(): string;

/**
 * Total duration in milliseconds
 */
toMillis(): number;

/**
 * Total duration in milliseconds (for sorting/comparison)
 */
valueOf(): number;

/**
 * Add another duration
 * @param duration - Duration to add or object with duration units
 */
plus(duration: Duration | object): Duration;

/**
 * Subtract another duration
 * @param duration - Duration to subtract or object with duration units
 */
minus(duration: Duration | object): Duration;

/**
 * Return negative duration
 */
negate(): Duration;

/**
 * Transform duration units with function
 * @param fn - Function to apply to each unit value
 */
mapUnits(fn: (value: number, unit: string) => number): Duration;

/**
 * Get value of specific unit
 * @param unit - Unit name (years, months, days, etc.)
 */
get(unit: string): number;

/**
 * Set specific duration values
 * @param values - Object with duration properties to set
 */
set(values: object): Duration;

/**
 * Reconfigure duration settings
 * @param opts - Options including locale, numberingSystem, conversionAccuracy
 */
reconfigure(opts: {locale?, numberingSystem?, conversionAccuracy?}): Duration;

/**
 * Convert duration to single unit
 * @param unit - Target unit (years, months, days, hours, minutes, seconds, milliseconds)
 */
as(unit: string): number;

/**
 * Normalize duration to canonical representation
 */
normalize(): Duration;

/**
 * Convert to different units
 * @param units - Array of target units in preferred order
 */
shiftTo(...units: string[]): Duration;

/**
 * Check equality with other Duration
 * @param other - Duration to compare
 */
equals(other: Duration): boolean;

/**
 * Low-order conversion matrix for precise calculations
 */
static lowOrderMatrix: object;

/**
 * Casual conversion matrix (default) - 1 month = 30 days, 1 year = 365 days
 */
static casualMatrix: object;

/**
 * Accurate conversion matrix for more precise date-aware calculations
 */
static accurateMatrix: object;

import { Duration } from "luxon";

// Creating durations
const duration1 = Duration.fromObject({ hours: 2, minutes: 30 });
const duration2 = Duration.fromMillis(5400000); // 1.5 hours in milliseconds
const duration3 = Duration.fromISO("PT2H30M"); // ISO duration string

console.log(duration1.hours);    // 2
console.log(duration1.minutes);  // 30
console.log(duration1.toMillis()); // 9000000

// Formatting
console.log(duration1.toFormat("h 'hours', m 'minutes'")); // "2 hours, 30 minutes"
console.log(duration1.toHuman()); // "2 hours, 30 minutes"
console.log(duration1.toISO());   // "PT2H30M"

// Unit conversion
console.log(duration1.as('minutes')); // 150
console.log(duration1.shiftTo('minutes').minutes); // 150

// Arithmetic
const total = duration1.plus({ minutes: 15 }); // 2 hours, 45 minutes
const difference = duration1.minus({ minutes: 30 }); // 2 hours
const negative = duration1.negate(); // -2 hours, -30 minutes

// Working with different conversion matrices
const precise = Duration.fromObject(
  { months: 1, days: 15 }, 
  { conversionAccuracy: 'longterm' }
);