Units

Package for converting and formatting units and numerical values.

@dynatrace-sdk/units

v1.5.0

npm install @dynatrace-sdk/units

Functions

abbreviateNumber

abbreviateNumber(input,scale,options): { formattedValue, postfix }

Abbreviates large numbers into a shorter format with metric prefixes.

Parameters

Name	Type	Description
input*required	number	Number to be abbreviated
scale*required	Scale	Scale configuration for abbreviation: base: Base number for scaling (e.g., 1000 for metric, 1024 for binary) levels: Array of prefix symbols (e.g., ['', 'k', 'M', 'G']) Default is decimal metric scale (k, M, G, T, etc.)
options*required	AdjustFractionDigitsOptions	Formatting options: minimumFractionDigits: Minimum decimal places maximumFractionDigits: Maximum decimal places roundingMode: How to handle rounding

Returns

Description
Object containing: formattedValue: The scaled numeric value as string postfix: The metric prefix symbol

Code example

// Basic decimal abbreviation
abbreviateNumber(1500)
// Returns: { formattedValue: '2', postfix: 'k' }

Code example

// Binary (bytes) abbreviation
abbreviateNumber(1048576, ExponentialOctalByteLevels)
// Returns: { formattedValue: '1', postfix: 'MiB' }

Code example

// Custom fraction digits
abbreviateNumber(1500000, ExponentialDecimalLevels, { maximumFractionDigits: 2 })
// Returns: { formattedValue: '1.50', postfix: 'M' }

adjustFractionDigits

adjustFractionDigits(input,options?): string

Formats a number with precise control over decimal places and handles very small values.

Parameters

Name	Type	Description
input*required	number	The number to format
options	AdjustFractionDigitsOptions	Formatting configuration: minimumFractionDigits: Minimum decimal places (defaults to 0) maximumFractionDigits: Maximum decimal places (defaults to minimumFractionDigits) minimumSignificantDigits: Minimum significant digits (default: 1) maximumSignificantDigits: Maximum significant digits (default: 21) locale: Override default locale (e.g., 'en-US', 'de-DE') useGrouping: Whether to use thousand separators

Returns

Description
Formatted number string, with special handling for very small values: Positive tiny values are prefixed with '< ' Negative tiny values are prefixed with '> ' Zero returns '0'

Code example

// Basic formatting
adjustFractionDigits(1234.5678, { maximumFractionDigits: 2 })
// Returns: '1,234.57'

Code example

// Format with custom locale
adjustFractionDigits(1234.5, { locale: 'de-DE', maximumFractionDigits: 1 })
// Returns: '1.234,5'

Code example

// Handle very small values
adjustFractionDigits(0.0000001, { maximumFractionDigits: 3 })
// Returns: '< 0.001'

convert

convert(input,from,to): number

Converts a numeric value from one unit to another within the same measurement system

Parameters

Name	Type	Description
input*required	number	The numeric value to convert
from*required	FromUnit	Source unit (e.g., units.length.meter, units.time.second)
to*required	ConvertibleTarget<FromUnit | ToUnit>	Target unit for conversion (must be compatible with source unit)

Returns

Description
Converted numeric value

Throws

Error Type	Error Message
undefined	Error if units are incompatible (different measurement systems)

Code example

// Convert length
import { convert, units } from "@dynatrace-sdk/units";
convert(1500, units.length.meter, units.length.kilometer)
// Returns: 1.5

Code example

// Convert temperature
convert(32, units.temperature.degree_fahrenheit, units.temperature.degree_celsius)
// Returns: 0

Code example

// Convert time
convert(3600, units.time.second, units.time.hour)
// Returns: 1

Code example

// Using unsafe mode to convert with runtime-determined unit
convert(100, outputUnit, units.data.mebibyte, true)

convert(input,from,to,unsafe): number

Parameters

Name	Type
input*required	number
from*required	ConvertibleUnit
to*required	ConvertibleUnit
unsafe*required	true

extractDisplayValueFromTimeValues

extractDisplayValueFromTimeValues(from,to,intl,precision,valueFrom?,valueTo?): FormatTimeValuesResult

Extracts the display value string from the from and to time values.

This function processes raw time values (which can be strings or TimeValue objects), validates them, and returns a formatted display string. It's a higher-level wrapper around formatTimeValues that handles parsing and validation.

Parameters

Name	Type	Description
from*required	null | TimeValue	The starting time value (can be null)
to*required	null | TimeValue	The ending time value (can be null)
intl*required	IntlShape	The internationalization shape for formatting messages
precision*required	TimePrecision	The time precision level ('minutes', 'seconds', or 'milliseconds'). Defaults to 'minutes'
valueFrom	string	Optional raw string value for debugging purposes
valueTo	string	Optional raw string value for debugging purposes

Returns

Description
An object containing the display value, validity flag, and hint message

Code example

const result = extractDisplayValueFromTimeValues(
  { value: 'now-1h', type: 'expression', absoluteDate: '2024-01-01T11:00:00Z' },
  { value: 'now', type: 'expression', absoluteDate: '2024-01-01T12:00:00Z' },
  intl,
  'minutes'
);
// Returns: { displayValue: "Last 1 hour", isInvalid: false, hint: "" }

format

format(number,options?): string

Converts and formats a numeric value using units and formatting options.

Parameters

Name	Type	Description
number*required	number	The numeric value to format
options	FormatOptions<FromUnit | ToUnit>	Formatting configuration options: cascade: Cascades value down to specified unit depth (e.g., '1 km 500 m' for depth 2) input: Source unit for conversion (e.g., units.length.meter) output: Target unit for conversion (if not specified, only formatting is applied) suffix: Custom suffix to override unit symbol minimumFractionDigits: Minimum number of decimal places maximumFractionDigits: Maximum number of decimal places (defaults to minimumFractionDigits or 0) minimumSignificantDigits: Minimum significant digits (default: 1) maximumSignificantDigits: Maximum significant digits (default: 21) locale: Locale for number formatting (defaults to platform locale) useGrouping: Whether to use thousand separators abbreviate: Whether to shorten large numbers (e.g., 1.5K)

Returns

Description
A formatted string with the number and its unit

Code example

// Format without units (abbreviation enabled by default)
format(1500)
// Returns: '2K'

Code example

// Format with unit conversion
format(1500, {
  input: units.length.meter,
  maximumFractionDigits: 1
})
// Returns: '1.5 km'

Code example

// Format with unit cascading
format(1500, {
  input: units.length.meter,
  cascade: 2
})
// Returns: '1 km 500 m'

formatCurrency

formatCurrency(number,currency,options?): string

Formats a number according to currency and locale conventions.

Parameters

Name	Type	Description
number*required	number	The numeric value to format
currency*required	undefined | "CHF" | "AED" | "AFN" | "ALL" | "AMD" | "ANG" | "AOA" | "ARS" | "AUD" | "AWG" | "AZN" | "BAM" | "BBD" | "BDT" | "BGN" | "BHD" | "BIF" | "BMD" | "BND" | "BOB" | "BRL" | "BSD" | "BTN" | "BWP" | "BYN" | "BZD" | "CAD" | "CDF" | "CLP" | "CNY" | "COP" | "CRC" | "CUC" | "CUP" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "EUR" | "FJD" | "FKP" | "GBP" | "GEL" | "GHS" | "GIP" | "GMD" | "GNF" | "GTQ" | "GYD" | "HKD" | "HNL" | "HRK" | "HTG" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KGS" | "KHR" | "KMF" | "KPW" | "KRW" | "KWD" | "KYD" | "KZT" | "LAK" | "LBP" | "LKR" | "LRD" | "LSL" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MNT" | "MOP" | "MRU" | "MUR" | "MVR" | "MWK" | "MXN" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PGK" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SBD" | "SCR" | "SDG" | "SEK" | "SGD" | "SHP" | "SLE" | "SLL" | "SOS" | "SRD" | "SSP" | "STN" | "SVC" | "SYP" | "SZL" | "THB" | "TJS" | "TMT" | "TND" | "TOP" | "TRY" | "TTD" | "TWD" | "TZS" | "UAH" | "UGX" | "USD" | "UYU" | "UZS" | "VES" | "VND" | "VUV" | "WST" | "XAF" | "XCD" | "XCG" | "XDR" | "XOF" | "XPF" | "XSU" | "YER" | "ZAR" | "ZMW" | "ZWL" |	ISO 4217 currency code (e.g., 'USD', 'EUR')
options	FormatCurrencyOptions	Currency formatting configuration: locale: Override default locale (e.g., 'en-US', 'de-DE') abbreviate: Whether to shorten large numbers (e.g., '$1.5K') minimumFractionDigits: Minimum decimal places maximumFractionDigits: Maximum decimal places useGrouping: Whether to use thousand separators Additional options from Intl.NumberFormat are supported

Returns

Description
Formatted currency string

Code example

// Format with default options
formatCurrency(1500, 'USD')
// Returns: '$1.50K'

Code example

// Format with custom locale and no abbreviation
formatCurrency(1500, 'EUR', {
  locale: 'de-DE',
  abbreviate: false
})
// Returns: '1.500,00 €'

Code example

// Format large number with abbreviation
formatCurrency(1500000, 'USD', { abbreviate: true })
// Returns: '$1.50M'

formatDate

formatDate(input,options?): string

Formats a date according to locale and timezone settings.

Parameters

Name	Type	Description
input*required	number | Date	The date to format, as either: Number of milliseconds since UNIX epoch JavaScript Date object
options	FormatDateOptions	Date formatting configuration: locale: Override default locale (e.g., 'en-US', 'de-DE') timeZone: Timezone name (e.g., 'UTC', 'America/New_York') dateStyle: Full date formatting style ('full', 'long', 'medium', 'short') timeStyle: Time formatting style ('full', 'long', 'medium', 'short') hour12: Whether to use 12-hour clock (true) or 24-hour clock (false) Additional options from Intl.DateTimeFormatOptions are supported

Returns

Description
Formatted date string according to locale and options

Code example

// Format date with default locale and timezone
formatDate(new Date())
// Returns: '5/27/2025'

Code example

// Format with custom locale and timezone
formatDate(new Date(), {
  locale: 'de-DE',
  timeZone: 'Europe/Berlin',
  dateStyle: 'full'
})
// Returns: 'Dienstag, 27. Mai 2025'

Code example

// Format timestamp with custom style
formatDate(1621344000000, {
  dateStyle: 'short',
  timeStyle: 'short'
})
// Returns: '5/27/25, 2:30 PM'

formatLong

formatLong(value,options?): string

Formats large numbers with precise decimal handling, useful for scientific or financial calculations.

Parameters

Name	Type	Description
value*required	string | number | bigint	The value to format. Accepts: number: Regular JavaScript number bigint: For values beyond Number.MAX_SAFE_INTEGER string: Numeric string representation
options	FormatLong	Formatting configuration: locale: Override default locale (e.g., 'en-US', 'de-DE') minimumFractionDigits: Minimum decimal places maximumFractionDigits: Maximum decimal places minimumSignificantDigits: Minimum significant digits maximumSignificantDigits: Maximum significant digits useGrouping: Whether to use thousand separators

Returns

Description
Formatted number string with precise decimal handling

Code example

// Format large number
formatLong('123456789.123456789')
// Returns: '123,456,789.123'

Code example

// Format with custom locale and fraction digits
formatLong(123456.789, {
  locale: 'de-DE',
  maximumFractionDigits: 2
})
// Returns: '123.456,79'

Code example

// Format BigInt value
formatLong(BigInt('9007199254740991'))
// Returns: '9,007,199,254,740,991'

formatTimeValues

formatTimeValues(from,to,intl,precision,fromDate,toDate,hint): FormatTimeValuesResult

Returns the display value props for given time values that include relative expressions.

This function formats two time values (from and to) into a human-readable display string, handling both absolute dates and relative expressions like "Last 5 minutes" or "Tomorrow".

Parameters

Name	Type	Description
from*required	TimeValue	The starting time value
to*required	TimeValue	The ending time value
intl*required	IntlShape	The internationalization shape for formatting messages
precision*required	TimePrecision	The time precision level ('minutes', 'seconds', or 'milliseconds')
fromDate*required	Date	The from date as a Date object
toDate*required	Date	The to date as a Date object
hint*required	string	Optional hint message for additional context

Returns

Description
An object containing the display value, validity flag, and hint

Code example

const result = formatTimeValues(
  { value: 'now-5m', type: 'expression', absoluteDate: '2024-01-01T12:00:00Z' },
  { value: 'now', type: 'expression', absoluteDate: '2024-01-01T12:05:00Z' },
  intl,
  'minutes',
  new Date('2024-01-01T12:00:00Z'),
  new Date('2024-01-01T12:05:00Z'),
  ''
);
// Returns: { displayValue: "Last 5 minutes", isInvalid: false, hint: "" }

formatTimeframe

formatTimeframe(value,intl,precision): FormatTimeValuesResult

Formats a timeframe (from/to date strings or TimeValue objects) into a human-readable display string.

Handles parsing of string values. It accepts objects with from and to properties that can be either strings or TimeValue objects.

Parameters

Name	Type	Description
value*required	null | { from, to }	An object containing from and/or to properties. The properties can be either: - Strings: timeframe expressions (e.g., "now-1h") or ISO 8601 date strings - TimeValue objects: already parsed time values At least one of from or to must be provided.
intl*required	IntlShape	The Intl shape object for internationalization
precision*required	TimePrecision	The precision level for formatting dates ('minutes', 'seconds', or 'milliseconds'). Defaults to 'minutes'.

Returns

Description
An object containing the formatted display value, validation status, and optional hint message

Code example

// With string values
const result = formatTimeframe(
  { from: 'now-1h', to: 'now' },
  intl
);
// Returns: { displayValue: "Last 1 hour", isInvalid: false, hint: "" }

// With ISO 8601 strings
const result2 = formatTimeframe(
  { from: '2024-01-01T00:00:00Z', to: '2024-01-02T00:00:00Z' },
  intl
);
// Returns: { displayValue: "Jan 1, 2024, 00:00 → Jan 2, 2024, 00:00", isInvalid: false, hint: "" }

// With TimeValue objects
const result3 = formatTimeframe(
  {
    from: { value: 'now-1h', type: 'expression', absoluteDate: '2024-01-01T11:00:00Z' },
    to: { value: 'now', type: 'expression', absoluteDate: '2024-01-01T12:00:00Z' }
  },
  intl
);
// Returns: { displayValue: "Last 1 hour", isInvalid: false, hint: "" }

formatTimeframeToParts

formatTimeframeToParts(from,to,intl,clampFutureToDateToNow,separator): string |

Formats a timeframe into a localized array of strings.

This function converts the from and to dates into timezone-aware strings using the user's locale, and returns their formatted representations along with a separator string. The IntlShape passed to the function is used to determine the language, while the IntlShape created in the function (intlTimeFormat) is used to determine the type of time display.

If the current time is within the timeframe and clampFutureToDateToNow is true, the to date is clamped to "now" to avoid showing future dates.

Parameters

Name	Type	Description
from*required	Date	Start date in the timeframe
to*required	Date	End date in the timeframe
intl*required	IntlShape	Intl object
clampFutureToDateToNow*required	boolean	If false, the to date won't be clamped to Now
separator*required	MessageDescriptor

Returns

Description
an array of timeframe parts.

Code example

// Format timeframe
formatTimeframeToParts(new Date('2020-01-01'), new Date('2021-01-01'), intl //en)
// Returns: `["01 Jan, 2020, 00:00","to","01 Jan, 2021, 00:00"]`

Code example

// Format timeframe with the funture date to "Now"
formatTimeframeToParts(new Date('2020-01-01'), new Date('2026-01-01'), intl //en)
// Returns: `["01 Jan, 2020, 00:00","to","Now"]`

formatUnit

formatUnit(unit): string

Formats a unit into a human-readable string representation.

Parameters

Name	Type	Description
unit*required	FormattableUnit	The unit to format, consisting of group, index, and exponent values

Returns

Description
Formatted unit string

Code example

// Format a simple unit
formatUnit([{ group: 'meter', index: 3, exponent: 1 }])
// Returns: 'km'

Code example

// Format a compound unit
formatUnit([
  { group: 'meter', index: 0, exponent: 1 },
  { group: 'hour', index: 0, exponent: '–1' }
])
// Returns: 'm/s'

Code example

// Format with exponents
formatUnit([{ group: 'meter', index: 0, exponent: 2 }])
// Returns: 'm^2'

getFormatting

getFormatting(number,options?): Formatting

Converts and formats a number into its constituent parts for flexible display.

Parameters

Name	Type	Description
number*required	number	The numeric value to format
options	FormatOptions<FromUnit | ToUnit>	Formatting configuration options: cascade: Cascades value down to specified unit depth (e.g., '1 km 500 m' for depth 2) input: Source unit for conversion (e.g., units.length.meter) output: Target unit for conversion suffix: Custom suffix to override unit symbol minimumFractionDigits: Minimum number of decimal places maximumFractionDigits: Maximum number of decimal places minimumSignificantDigits: Minimum significant digits (default: 1) maximumSignificantDigits: Maximum significant digits (default: 21) locale: Locale for number formatting useGrouping: Whether to use thousand separators abbreviate: Whether to shorten large numbers (e.g., 1.5K)

Returns

Description
An array of formatting parts, where each part contains: separator: The spacing between value and symbol symbol: The unit symbol or suffix symbolPrefix: Whether the symbol appears before the value value: The formatted numeric string

Code example

// Format bytes with default options
getFormatting(1500)
// Returns: [{ value: '2K', symbol: '', separator: '', symbolPrefix: false }]

Code example

// Format with custom units and fraction digits
getFormatting(1500, {
  input: units.length.meter,
  maximumFractionDigits: 2
})
// Returns: [{ value: '1.5', symbol: 'km', separator: ' ', symbolPrefix: false }]

mapGrailUnit

mapGrailUnit(grailUnit): GrailUnitEquivalency

Maps a Grail unit string to its corresponding units system equivalent.

Parameters

Name	Type	Description
grailUnit*required	string	The Grail unit string to convert (e.g., 'BytePerSecond')

Returns

Description
Unit equivalency object containing: unit: Corresponding units system unit type: Type of measurement (e.g., 'data', 'time') base: Base unit for the measurement type

Code example

// Map data transfer rate unit
mapGrailUnit('BytePerSecond')
// Returns: { 'namespace': 'datarate', 'unitName': 'Bps', 'unit': [ { 'group': 'byte_m', 'index': 0, 'exponent': 1 }, { 'group': 'second', 'index': 0, 'exponent': '–1' } ] }

parseTime

⚠️ Deprecated Use the parseTimeAsTimeValue function instead

parseTime(candidate?,relativeDate): null | TimeDetails

Converts a string representation of time into a structured TimeDetails object.

Parameters

Name	Type	Description
candidateDEPRECATED	null | string	Input string to parse. Supports: ISO 8601 format (e.g., '2025-05-27T14:30:00Z') Relative expressions (e.g., 'now-30m', 'now+1h') Date formats (e.g., '2025-05-27', '14:30') 'now' keyword
relativeDateDEPRECATED*required	number	Reference timestamp for relative expressions (defaults to current time)

Returns

Description
TimeDetails object containing: normalized: Cleaned and standardized input string date: JavaScript Date object type: 'expression' for relative times or 'iso8601' for absolute times Returns null if parsing fails

Code example

// Parse ISO datetime
parseTime('2025-05-27T14:30:00Z')
// Returns: {
//   normalized: '2025-05-27T14:30:00Z',
//   date: Date('2025-05-27T14:30:00.000Z'),
//   type: 'iso8601'
// }

Code example

// Parse relative time
parseTime('now-30m')
// Returns: {
//   normalized: 'now-30m',
//   date: [Date 30 minutes before current time],
//   type: 'expression'
// }

Code example

// Parse date format
parseTime('2025-05-27 14:30')
// Returns: {
//   normalized: '2025-05-27T14:30:00Z',
//   date: Date('2025-05-27T14:30:00.000Z'),
//   type: 'iso8601'
// }

parseTimeAsTimeValue

parseTimeAsTimeValue(candidate?,relativeDate?,precision?): TimeValue | null

Converts various time string formats into a normalized TimeValue object.

Parameters

Name	Type	Description
candidate	null | string	Input string to parse. Supports: ISO 8601 (e.g., '2025-05-27T14:30:00Z') Relative expressions (e.g., 'now-30m', 'now+1h') Date formats (e.g., '2025-05-27', '14:30') 'now' keyword
relativeDate	number	Reference timestamp for relative expressions
precision	"day" | "minutes" | "seconds" | "milliseconds"	Output precision level: 'day': Date only 'minutes': Up to minutes 'seconds': Up to seconds 'milliseconds': Up to milliseconds

Returns

Description
TimeValue object containing: type: 'expression' | 'iso8601' value: Normalized input string absoluteDate: Resolved ISO timestamp Returns null if parsing fails

Code example

// Parse ISO datetime
parseTime('2025-05-27T14:30:00Z')
// Returns: {
//   type: 'iso8601',
//   value: '2025-05-27T14:30:00Z',
//   absoluteDate: '2025-05-27T14:30:00Z'
// }

Code example

// Parse relative time
parseTime('now-30m')
// Returns: {
//   type: 'expression',
//   value: 'now()-30m',
//   absoluteDate: [ISO string 30 minutes before now]
// }

variantNames

variantNames(unit): VariantNames<U>

Returns the names of all units to which the provided unit can be converted.

Parameters

Name	Type	Description
unit*required	U	The source unit to find convertible variants for (e.g., units.length.meter)

Returns

Description
Array of unit names that are valid conversion targets

Code example

// Get all length unit names
variantNames(units.length.meter)
// Returns:
// ['meter', 'kilometer', 'centimeter', 'millimeter', ...]

Code example

// Get temperature unit names
variantNames(units.temperature.degree_celsius)
// Returns:
// ['degree_celsius', 'degree_fahrenheit', ...]

variantUnits

variantUnits(unit): VariantUnits<U>

Returns all units to which the provided unit can be converted.

Parameters

Name	Type	Description
unit*required	U	The source unit to find convertible variants for (e.g., units.length.meter)

Returns

Description
Array of unit objects that are valid conversion targets

Code example

// Get all length units
variantUnits(units.length.meter)
// Returns:
// [
//   [{ 'group': 'meter', 'index': -15, 'exponent': 1 }],
//   [{ 'group': 'meter', 'index': 30, 'exponent': 1 }],
//   ...
// ]

Code example

// Get convertible temperature units
variantUnits(units.temperature.degree_celsius)
// Returns:
// [
//   [{ 'group': 'degree_celsius', 'index': 0, 'exponent': 1 }],
//   [{ 'group': 'degree_fahrenheit', 'index': 0, 'exponent': 1 }],
//   ...
// ]

Constants

ExponentialDecimalLevels

Abbreviation levels for decimal metric prefixes from kilo to quecto, 10^3, 10^6, ...

Properites

Name	Type
base*required	number
levels*required	Array<string>

ExponentialOctalBitLevels

Abbreviation levels for bit binary prefixes from kilobit to quebibit, 2^10, 2^20, ...

Properites

Name	Type
base*required	number
levels*required	Array<string>

ExponentialOctalByteLevels

Abbreviation levels for byte binary prefixes from kibibyte to quebibyte, 2^10, 2^20, ...

Properites

Name	Type
base*required	number
levels*required	Array<string>

timeframeTranslations

Properites

Name	Type
M*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
d*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
full-day*required	(intl: IntlShape) => string
h*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
invalid*required	(intl: IntlShape) => string
invalidFrom*required	(intl: IntlShape) => string
invalidOrder*required	(intl: IntlShape) => string
invalidTimeframe*required	(intl: IntlShape) => string
invalidTo*required	(intl: IntlShape) => string
m*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
ms*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
now*required	(intl: IntlShape) => string
q*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
remaining-day*required	(intl: IntlShape) => string
roundDown-M*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-d*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-h*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-m*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-q*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-s*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-w*required	(intl: IntlShape, values: { amount, prefix }) => string
roundDown-y*required	(intl: IntlShape, values: { amount, prefix }) => string
s*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
to*required	(intl: IntlShape) => string
today*required	(intl: IntlShape) => string
tomorrow*required	(intl: IntlShape) => string
w*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
y*required	(intl: IntlShape, values: { offset, prefix, suffix }) => string
yesterday*required	(intl: IntlShape) => string

units

Grouped collection of all the supported units

Properites

Name	Type
acceleration*required	{ foot_per_second_squared, meter_per_second_squared }
amount*required	{ mole, one }
angle*required	{ degree, milliradian, minute, radian, revolution, second }
area*required	{ square_attometer, square_centimeter, square_decimeter, square_femtometer, square_foot, square_inch, square_kilometer, square_meter, square_micrometer, square_mile, square_millimeter, square_nanometer, square_picometer, square_yard, square_yoctometer, square_zeptometer }
currencyDEPRECATED*required	{ aud, cad, chf, cny, eur, gbp, jpy, nzd, usd }
data*required	{ bit, bit_binary, byte, byte_binary, exabit, exabyte, exibit, exibyte, gibibit, gibibyte, gigabit, gigabyte, kibibit, kibibyte, kilobit, kilobyte, mebibit, mebibyte, megabit, megabyte, pebibit, pebibyte, petabit, petabyte, quebibit, quebibyte, quettabit, quettabyte, robibit, robibyte, ronnabit, ronnabyte, tebibit, tebibyte, terabit, terabyte, yobibit, yobibyte, yottabit, yottabyte, zebibit, zebibyte, zettabit, zettabyte }
datarate*required	{ Bph, Bpm, Bps, GBph, GBpm, GBps, Gbitph, Gbitpm, Gbitps, GiBph, GiBpm, GiBps, Gibitph, Gibitpm, Gibitps, MBph, MBpm, MBps, Mbitph, Mbitpm, Mbitps, MiBph, MiBpm, MiBps, Mibitph, Mibitpm, Mibitps, bitph, bitpm, bitps, kBph, kBpm, kBps, kbitph, kbitpm, kbitps, kiBph, kiBpm, kiBps, kibitph, kibitpm, kibitps }
electricity*required	{ ampere, attoampere, attocoulomb, attofarad, attohenry, attoohm, attosiemens, attotesla, attovolt, attowatt, attoweber, centiampere, centicoulomb, centifarad, centihenry, centiohm, centisiemens, centitesla, centivolt, centiwatt, centiweber, coulomb, decaampere, decacoulomb, decafarad, decahenry, decaohm, decasiemens, decatesla, decavolt, decawatt, decaweber, deciampere, decicoulomb, decifarad, decihenry, deciohm, decisiemens, decitesla, decivolt, deciwatt, deciweber, exaampere, exacoulomb, exafarad, exahenry, exaohm, exasiemens, exatesla, exavolt, exawatt, exaweber, farad, femtoampere, femtocoulomb, femtofarad, femtohenry, femtoohm, femtosiemens, femtotesla, femtovolt, femtowatt, femtoweber, gigaampere, gigacoulomb, gigafarad, gigahenry, gigaohm, gigasiemens, gigatesla, gigavolt, gigawatt, gigaweber, hectoampere, hectocoulomb, hectofarad, hectohenry, hectoohm, hectosiemens, hectotesla, hectovolt, hectowatt, hectoweber, henry, kiloampere, kilocoulomb, kilofarad, kilohenry, kiloohm, kilosiemens, kilotesla, kilovolt, kilowatt, kiloweber, megaampere, megacoulomb, megafarad, megahenry, megaohm, megasiemens, megatesla, megavolt, megawatt, megaweber, microampere, microcoulomb, microfarad, microhenry, microohm, microsiemens, microtesla, microvolt, microwatt, microweber, milliampere, millicoulomb, millifarad, millihenry, milliohm, millisiemens, millitesla, millivolt, milliwatt, milliweber, nanoampere, nanocoulomb, nanofarad, nanohenry, nanoohm, nanosiemens, nanotesla, nanovolt, nanowatt, nanoweber, ohm, petaampere, petacoulomb, petafarad, petahenry, petaohm, petasiemens, petatesla, petavolt, petawatt, petaweber, picoampere, picocoulomb, picofarad, picohenry, picoohm, picosiemens, picotesla, picovolt, picowatt, picoweber, quectoampere, quectocoulomb, quectofarad, quectohenry, quectoohm, quectosiemens, quectotesla, quectovolt, quectowatt, quectoweber, quettaampere, quettacoulomb, quettafarad, quettahenry, quettaohm, quettasiemens, quettatesla, quettavolt, quettawatt, quettaweber, ronnaampere, ronnacoulomb, ronnafarad, ronnahenry, ronnaohm, ronnasiemens, ronnatesla, ronnavolt, ronnawatt, ronnaweber, rontoampere, rontocoulomb, rontofarad, rontohenry, rontoohm, rontosiemens, rontotesla, rontovolt, rontowatt, rontoweber, siemens, teraampere, teracoulomb, terafarad, terahenry, teraohm, terasiemens, teratesla, teravolt, terawatt, teraweber, tesla, volt, watt, weber, yoctoampere, yoctocoulomb, yoctofarad, yoctohenry, yoctoohm, yoctosiemens, yoctotesla, yoctovolt, yoctowatt, yoctoweber, yottaampere, yottacoulomb, yottafarad, yottahenry, yottaohm, yottasiemens, yottatesla, yottavolt, yottawatt, yottaweber, zeptoampere, zeptocoulomb, zeptofarad, zeptohenry, zeptoohm, zeptosiemens, zeptotesla, zeptovolt, zeptowatt, zeptoweber, zettaampere, zettacoulomb, zettafarad, zettahenry, zettaohm, zettasiemens, zettatesla, zettavolt, zettawatt, zettaweber }
energy*required	{ attojoule, attowatt_hour, centijoule, centiwatt_hour, decajoule, decawatt_hour, decijoule, deciwatt_hour, exajoule, exawatt_hour, femtojoule, femtowatt_hour, gigajoule, gigawatt_hour, hectojoule, hectowatt_hour, joule, kilojoule, kilowatt_hour, megajoule, megawatt_hour, microjoule, microwatt_hour, millijoule, milliwatt_hour, nanojoule, nanowatt_hour, petajoule, petawatt_hour, picojoule, picowatt_hour, quectojoule, quectowatt_hour, quettajoule, quettawatt_hour, ronnajoule, ronnawatt_hour, rontojoule, rontowatt_hour, terajoule, terawatt_hour, watt_hour, yoctojoule, yoctowatt_hour, yottajoule, yottawatt_hour, zeptojoule, zeptowatt_hour, zettajoule, zettawatt_hour }
force*required	{ attonewton, centinewton, decanewton, decinewton, exanewton, femtonewton, giganewton, hectonewton, kilonewton, meganewton, micronewton, millinewton, nanonewton, newton, petanewton, piconewton, pound, quectonewton, quettanewton, ronnanewton, rontonewton, teranewton, yoctonewton, yottanewton, zeptonewton, zettanewton }
frequency*required	{ attohertz, centihertz, decahertz, decihertz, exahertz, femtohertz, gigahertz, hectohertz, hertz, kilohertz, megahertz, microhertz, millihertz, nanohertz, petahertz, picohertz, quectohertz, quettahertz, ronnahertz, rontohertz, terahertz, yoctohertz, yottahertz, zeptohertz, zettahertz }
length*required	{ astronomical_unit, attometer, centimeter, decameter, decimeter, exameter, femtometer, foot, gigameter, hectometer, inch, kilometer, lightyear, megameter, meter, micrometer, mile, millimeter, nanometer, petameter, picometer, quectometer, quettameter, ronnameter, rontometer, terameter, yard, yoctometer, yottameter, zeptometer, zettameter }
level*required	{ decibel_milliwatt }
liquidDEPRECATED*required	{ attoliter, attolitre, centiliter, centilitre, decaliter, decalitre, deciliter, decilitre, exaliter, exalitre, femtoliter, femtolitre, gigaliter, gigalitre, hectoliter, hectolitre, kiloliter, kilolitre, liter, litre, megaliter, megalitre, microliter, microlitre, milliliter, millilitre, nanoliter, nanolitre, petaliter, petalitre, picoliter, picolitre, quectoliter, quectolitre, quettaliter, quettalitre, ronnaliter, ronnalitre, rontoliter, rontolitre, teraliter, teralitre, yoctoliter, yoctolitre, yottaliter, yottalitre, zeptoliter, zeptolitre, zettaliter, zettalitre }
load*required	{ millisecond_per_minute, nanosecond_per_minute, second_per_minute }
mass*required	{ attogram, centigram, decagram, decigram, exagram, femtogram, gigagram, grain, gram, hectogram, kilogram, megagram, microgram, milligram, nanogram, ounce, petagram, picogram, pound, quectogram, quettagram, ronnagram, rontogram, teragram, tonne, yoctogram, yottagram, zeptogram, zettagram }
percentage*required	{ one, parts_per_billion, parts_per_million, parts_per_trillion, per_mille, percent, promille }
physics*required	{ attocandela, attogray, attolumen, attolux, attosievert, attosteradian, candela, centicandela, centigray, centilumen, centilux, centisievert, centisteradian, decacandela, decagray, decalumen, decalux, decasievert, decasteradian, decicandela, decigray, decilumen, decilux, decisievert, decisteradian, exacandela, exagray, exalumen, exalux, exasievert, exasteradian, femtocandela, femtogray, femtolumen, femtolux, femtosievert, femtosteradian, gigacandela, gigagray, gigalumen, gigalux, gigasievert, gigasteradian, gray, hectocandela, hectogray, hectolumen, hectolux, hectosievert, hectosteradian, kilocandela, kilogray, kilolumen, kilolux, kilosievert, kilosteradian, lumen, lux, megacandela, megagray, megalumen, megalux, megasievert, megasteradian, microcandela, microgray, microlumen, microlux, microsievert, microsteradian, millicandela, milligray, millilumen, millilux, millisievert, millisteradian, nanocandela, nanogray, nanolumen, nanolux, nanosievert, nanosteradian, petacandela, petagray, petalumen, petalux, petasievert, petasteradian, picocandela, picogray, picolumen, picolux, picosievert, picosteradian, quectocandela, quectogray, quectolumen, quectolux, quectosievert, quectosteradian, quettacandela, quettagray, quettalumen, quettalux, quettasievert, quettasteradian, ronnacandela, ronnagray, ronnalumen, ronnalux, ronnasievert, ronnasteradian, rontocandela, rontogray, rontolumen, rontolux, rontosievert, rontosteradian, sievert, steradian, teracandela, teragray, teralumen, teralux, terasievert, terasteradian, yoctocandela, yoctogray, yoctolumen, yoctolux, yoctosievert, yoctosteradian, yottacandela, yottagray, yottalumen, yottalux, yottasievert, yottasteradian, zeptocandela, zeptogray, zeptolumen, zeptolux, zeptosievert, zeptosteradian, zettacandela, zettagray, zettalumen, zettalux, zettasievert, zettasteradian }
pressure*required	{ attopascal, bar, centipascal, decapascal, decipascal, exapascal, femtopascal, gigapascal, hectopascal, kilopascal, megapascal, micropascal, millipascal, nanopascal, pascal, petapascal, picopascal, psi, quectopascal, quettapascal, ronnapascal, rontopascal, terapascal, yoctopascal, yottapascal, zeptopascal, zettapascal }
ratio*required	{ attobel, bel, centibel, decabel, decibel, exabel, femtobel, gigabel, hectobel, kilobel, megabel, microbel, millibel, nanobel, petabel, picobel, quectobel, quettabel, ronnabel, rontobel, terabel, yoctobel, yottabel, zeptobel, zettabel }
temperature*required	{ degree_celsius, degree_fahrenheit, degree_rankine, kelvin }
time*required	{ attosecond, centisecond, day, decasecond, decisecond, exasecond, femtosecond, gigasecond, hectosecond, hour, kilosecond, megasecond, microsecond, millisecond, minute, month, nanosecond, petasecond, picosecond, quectosecond, quettasecond, ronnasecond, rontosecond, second, terasecond, week, year, yoctosecond, yottasecond, zeptosecond, zettasecond }
time_squared*required	{ second_squared, square_second }
unspecified*required	{ core, count, count_per_hour, count_per_minute, count_per_request, count_per_second, gigapixel, megapixel, millicore, msu, none, pixel, ratio, state, unspecified }
velocity*required	{ kilometer_per_hour, meter_per_hour, meter_per_second, miles_per_hour }
volume*required	{ attoliter, attolitre, centiliter, centilitre, cubic_decimeter, cubic_foot, cubic_inch, cubic_meter, decaliter, decalitre, deciliter, decilitre, exaliter, exalitre, femtoliter, femtolitre, gigaliter, gigalitre, hectoliter, hectolitre, kiloliter, kilolitre, liter, litre, megaliter, megalitre, microliter, microlitre, milliliter, millilitre, nanoliter, nanolitre, petaliter, petalitre, picoliter, picolitre, quectoliter, quectolitre, quettaliter, quettalitre, ronnaliter, ronnalitre, rontoliter, rontolitre, teraliter, teralitre, yoctoliter, yoctolitre, yottaliter, yottalitre, zeptoliter, zeptolitre, zettaliter, zettalitre }

Types

AdjustFractionDigitsOptions

Properties

Name	Type	Description
locale	string | Array<string>	The locale according to which the number will be adjusted.
maximumFractionDigits	number	Maximum number of decimal digits.
maximumSignificantDigits	number	Maximum number of significant digits. Default is 21
minimumFractionDigits	number	Minimum number of decimal digits.
minimumSignificantDigits	number	Minimum number of significant digits. Default is 1
useGrouping	boolean	Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators.

FormatCurrencyOptions

Properties

Name	Type	Description
abbreviate	boolean	It will shorten the number to a shorter format. (e.g. input: 1500, output: 1.5k).
locale	string | Array<string>	The locale according to which the number will be formatted.

FormatDateOptions

Interface that extends Intl.DateTimeFormatOptions to pass an optional property to overwrite the default locale. See MDN.

Properties

Name	Type	Description
locale	string | Array<string>	The locale according to which the number will be formatted.

FormatOptions

Properties

Name	Type	Description
abbreviate	boolean	It will shorten the number to a shorter format. (e.g. input: 1500, output: 1.5k).
cascade	number	Will search for the biggest unit within its group and cascade it down the the specified depth. The last number will get rounded to maximumFractionDigits. (e.g. format(1500, { input: units.length.meter, cascade: 2}), output: '1 km 500 m')).
input	FromUnit	If input unit is defined, it will convert it to the best fitting unit. (e.g. format(1500, { input: units.length.meter }), output: '1.5 km')).
locale	string | Array<string>	The locale that will be used to format the number. By default it will use the platform locale specified by the user.
maximumFractionDigits	number	The amount of maximumFractionDigits points. See MDN. If minimumFractionDigits is passed, set to minimumFractionDigits by default. Otherwise set to 0 by default.
maximumSignificantDigits	number	Maximum number of significant digits. Default is 21
minimumFractionDigits	number	The amount of minimumFractionDigits points. See MDN.
minimumSignificantDigits	number	Minimum number of significant digits. Default is 1
output	OutputUnit<UndefinedCoalescing<FromUnit | > | ToUnit>	If not specified, the conversion is disabled (e.g. format(1500), output: 1.5K).
suffix	string	A custom suffix that overwrites the unit symbol.
useGrouping	boolean	Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators See MDN

TimeValue

The value of a part of a timeframe.

Properties

Name	Type	Description
absoluteDate*required	string	The actual selected date as ISOString, equals the value in case of an 'iso8601'-type.
type*required	"expression" | "iso8601"	Defines the type of the value.
value*required	string	The sanitized value.