@types/intl

Version 1.2.2
Published 26 days ago
2.55 kB
No dependencies
MIT license

Install

npm i @types/intl

yarn add @types/intl

pnpm add @types/intl

Overview

TypeScript definitions for intl

Index

Variables

Collator
DateTimeFormat
DisplayNames
ListFormat
Locale
NumberFormat
PluralRules
RelativeTimeFormat
Segmenter

Interfaces

Collator
- compare()
- resolvedOptions()
CollatorOptions
DateTimeFormat
- format()
- resolvedOptions()
DateTimeFormat
- formatToParts()
DateTimeFormat
- formatRange()
- formatRangeToParts()
DateTimeFormatOptions
DateTimeFormatOptions
DateTimeFormatOptions
DateTimeFormatPart
- type
- value
DisplayNames
- of()
- resolvedOptions()
DisplayNamesOptions
ListFormat
- format()
- formatToParts()
ListFormatOptions
Locale
LocaleOptions
NumberFormat
- format()
- resolvedOptions()
NumberFormat
- formatToParts()
NumberFormat
- format()
- resolvedOptions()
NumberFormat
- formatRange()
- formatRangeToParts()
NumberFormatOptions
NumberFormatOptions
NumberFormatPart
- type
- value
PluralRules
- resolvedOptions()
- select()
PluralRulesOptions
RelativeTimeFormat
RelativeTimeFormatOptions
RelativeTimeFormatPart
ResolvedCollatorOptions
ResolvedDateTimeFormatOptions
ResolvedDateTimeFormatOptions
ResolvedDisplayNamesOptions
ResolvedNumberFormatOptions
ResolvedNumberFormatOptions
ResolvedPluralRulesOptions
ResolvedRelativeTimeFormatOptions
ResolvedSegmenterOptions
- granularity
- locale
SegmentData
Segmenter
- resolvedOptions()
- segment()
SegmenterOptions
- granularity
- localeMatcher
Segments
- [Symbol.iterator]()
- containing()

Variables

variable Collator

var Collator: {
    (locales?: string | string[], options?: CollatorOptions): Collator;
    new (locales?: string | string[], options?: CollatorOptions): Collator;
    supportedLocalesOf(
        locales: string | string[],
        options?: CollatorOptions
    ): string[];
};

variable DateTimeFormat

var DateTimeFormat: {
    (locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
    new (
        locales?: string | string[],
        options?: DateTimeFormatOptions
    ): DateTimeFormat;
    supportedLocalesOf(
        locales: string | string[],
        options?: DateTimeFormatOptions
    ): string[];
    readonly prototype: DateTimeFormat;
};

variable DisplayNames

const DisplayNames: {
    new (locales: LocalesArgument, options: DisplayNamesOptions): DisplayNames;
    prototype: DisplayNames;
    supportedLocalesOf(
        locales?: LocalesArgument,
        options?: { localeMatcher?: RelativeTimeFormatLocaleMatcher }
    ): BCP47LanguageTag[];
};

variable ListFormat

const ListFormat: {
    new (
        locales?: BCP47LanguageTag | BCP47LanguageTag[],
        options?: ListFormatOptions
    ): ListFormat;
    prototype: ListFormat;
    supportedLocalesOf(
        locales: BCP47LanguageTag | BCP47LanguageTag[],
        options?: Pick<ListFormatOptions, 'localeMatcher'>
    ): BCP47LanguageTag[];
};

variable Locale

const Locale: new (
    tag: BCP47LanguageTag | Locale,
    options?: LocaleOptions
) => Locale;

variable NumberFormat

var NumberFormat: {
    (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
    new (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
    supportedLocalesOf(
        locales: string | string[],
        options?: NumberFormatOptions
    ): string[];
    readonly prototype: NumberFormat;
};

variable PluralRules

const PluralRules: {
    (locales?: string | string[], options?: PluralRulesOptions): PluralRules;
    new (locales?: string | string[], options?: PluralRulesOptions): PluralRules;
    supportedLocalesOf(
        locales: string | string[],
        options?: { localeMatcher?: 'lookup' | 'best fit' }
    ): string[];
};

variable RelativeTimeFormat

const RelativeTimeFormat: {
    new (
        locales?: UnicodeBCP47LocaleIdentifier | UnicodeBCP47LocaleIdentifier[],
        options?: RelativeTimeFormatOptions
    ): RelativeTimeFormat;
    supportedLocalesOf(
        locales?: UnicodeBCP47LocaleIdentifier | UnicodeBCP47LocaleIdentifier[],
        options?: RelativeTimeFormatOptions
    ): UnicodeBCP47LocaleIdentifier[];
};

variable Segmenter

const Segmenter: {
    new (
        locales?: BCP47LanguageTag | BCP47LanguageTag[],
        options?: SegmenterOptions
    ): Segmenter;
    prototype: Segmenter;
    supportedLocalesOf(
        locales: BCP47LanguageTag | BCP47LanguageTag[],
        options?: Pick<SegmenterOptions, 'localeMatcher'>
    ): BCP47LanguageTag[];
};

Interfaces

interface Collator

interface Collator {}

method compare

compare: (x: string, y: string) => number;

method resolvedOptions

resolvedOptions: () => ResolvedCollatorOptions;

interface CollatorOptions

interface CollatorOptions {}

property caseFirst

caseFirst?: string | undefined;

property ignorePunctuation

ignorePunctuation?: boolean | undefined;

property localeMatcher

localeMatcher?: string | undefined;

property numeric

numeric?: boolean | undefined;

property sensitivity

sensitivity?: string | undefined;

property usage

usage?: string | undefined;

interface DateTimeFormat

interface DateTimeFormat {}

method format

format: (date?: Date | number) => string;

method resolvedOptions

resolvedOptions: () => ResolvedDateTimeFormatOptions;

interface DateTimeFormat

interface DateTimeFormat {}

method formatToParts

formatToParts: (date?: Date | number) => DateTimeFormatPart[];

interface DateTimeFormat

interface DateTimeFormat {}

method formatRange

formatRange: (
    startDate: Date | number | bigint,
    endDate: Date | number | bigint
) => string;

method formatRangeToParts

formatRangeToParts: (
    startDate: Date | number | bigint,
    endDate: Date | number | bigint
) => DateTimeFormatPart[];

interface DateTimeFormatOptions

interface DateTimeFormatOptions {}

property day

day?: 'numeric' | '2-digit' | undefined;

property era

era?: 'long' | 'short' | 'narrow' | undefined;

property formatMatcher

formatMatcher?: 'best fit' | 'basic' | undefined;

property hour

hour?: 'numeric' | '2-digit' | undefined;

property hour12

hour12?: boolean | undefined;

property localeMatcher

localeMatcher?: 'best fit' | 'lookup' | undefined;

property minute

minute?: 'numeric' | '2-digit' | undefined;

property month

month?: 'numeric' | '2-digit' | 'long' | 'short' | 'narrow' | undefined;

property second

second?: 'numeric' | '2-digit' | undefined;

property timeZone

timeZone?: string | undefined;

property timeZoneName

timeZoneName?:
    | 'short'
    | 'long'
    | 'shortOffset'
    | 'longOffset'
    | 'shortGeneric'
    | 'longGeneric'
    | undefined;

property weekday

weekday?: 'long' | 'short' | 'narrow' | undefined;

property year

year?: 'numeric' | '2-digit' | undefined;

interface DateTimeFormatOptions

interface DateTimeFormatOptions {}

property calendar

calendar?: string | undefined;

property dateStyle

dateStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;

property dayPeriod

dayPeriod?: 'narrow' | 'short' | 'long' | undefined;

property hourCycle

hourCycle?: 'h11' | 'h12' | 'h23' | 'h24' | undefined;

property numberingSystem

numberingSystem?: string | undefined;

property timeStyle

timeStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;

interface DateTimeFormatOptions

interface DateTimeFormatOptions {}

property dateStyle

dateStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;

property dayPeriod

dayPeriod?: 'narrow' | 'short' | 'long' | undefined;

property formatMatcher

formatMatcher?: 'basic' | 'best fit' | 'best fit' | undefined;

property fractionalSecondDigits

fractionalSecondDigits?: 0 | 1 | 2 | 3 | undefined;

property timeStyle

timeStyle?: 'full' | 'long' | 'medium' | 'short' | undefined;

interface DateTimeFormatPart

interface DateTimeFormatPart {}

property type

type: DateTimeFormatPartTypes;

property value

value: string;

interface DisplayNames

interface DisplayNames {}

method of

of: (code: string) => string | undefined;

method resolvedOptions

resolvedOptions: () => ResolvedDisplayNamesOptions;

interface DisplayNamesOptions

interface DisplayNamesOptions {}

property fallback

fallback?: DisplayNamesFallback;

property languageDisplay

languageDisplay?: DisplayNamesLanguageDisplay;

property localeMatcher

localeMatcher?: RelativeTimeFormatLocaleMatcher;

property style

style?: RelativeTimeFormatStyle;

property type

type: DisplayNamesType;

interface ListFormat

interface ListFormat {}

method format

format: (list: Iterable<string>) => string;

method formatToParts

formatToParts: (
    list: Iterable<string>
) => { type: 'element' | 'literal'; value: string }[];

interface ListFormatOptions

interface ListFormatOptions {}

property localeMatcher

localeMatcher?: ListFormatLocaleMatcher | undefined;

property style

style?: ListFormatStyle | undefined;

property type

type?: ListFormatType | undefined;

interface Locale

interface Locale extends LocaleOptions {}

property baseName

baseName: string;

property language

language: string;

method maximize

maximize: () => Locale;

method minimize

minimize: () => Locale;

method toString

toString: () => BCP47LanguageTag;

interface LocaleOptions

interface LocaleOptions {}

property baseName

baseName?: string;

property calendar

calendar?: string;

property caseFirst

caseFirst?: LocaleCollationCaseFirst;

property collation

collation?: string;

property hourCycle

hourCycle?: LocaleHourCycleKey;

property language

language?: string;

property numberingSystem

numberingSystem?: string;

property numeric

numeric?: boolean;

property region

region?: string;

property script

script?: string;

interface NumberFormat

interface NumberFormat {}

method format

format: { (value: number): string; (value: number | bigint): string };

method resolvedOptions

resolvedOptions: {
    (): ResolvedNumberFormatOptions;
    (): ResolvedNumberFormatOptions;
};

interface NumberFormat

interface NumberFormat {}

method formatToParts

formatToParts: (number?: number | bigint) => NumberFormatPart[];

interface NumberFormat

interface NumberFormat {}

method format

format: { (value: number): string; (value: number | bigint): string };

method resolvedOptions

resolvedOptions: {
    (): ResolvedNumberFormatOptions;
    (): ResolvedNumberFormatOptions;
};

interface NumberFormat

interface NumberFormat {}

method formatRange

formatRange: (start: number | bigint, end: number | bigint) => string;

method formatRangeToParts

formatRangeToParts: (
    start: number | bigint,
    end: number | bigint
) => NumberFormatPart[];

interface NumberFormatOptions

interface NumberFormatOptions {}

property currency

currency?: string | undefined;

property currencySign

currencySign?: string | undefined;

property localeMatcher

localeMatcher?: string | undefined;

property maximumFractionDigits

maximumFractionDigits?: number | undefined;

property maximumSignificantDigits

maximumSignificantDigits?: number | undefined;

property minimumFractionDigits

minimumFractionDigits?: number | undefined;

property minimumIntegerDigits

minimumIntegerDigits?: number | undefined;

property minimumSignificantDigits

minimumSignificantDigits?: number | undefined;

property style

style?: string | undefined;

property useGrouping

useGrouping?: boolean | undefined;

interface NumberFormatOptions

interface NumberFormatOptions {}

property compactDisplay

compactDisplay?: 'short' | 'long' | undefined;

property currencyDisplay

currencyDisplay?: string | undefined;

property currencySign

currencySign?: string | undefined;

property notation

notation?: 'standard' | 'scientific' | 'engineering' | 'compact' | undefined;

property signDisplay

signDisplay?: 'auto' | 'never' | 'always' | 'exceptZero' | undefined;

property unit

unit?: string | undefined;

property unitDisplay

unitDisplay?: 'short' | 'long' | 'narrow' | undefined;

interface NumberFormatPart

interface NumberFormatPart {}

property type

type: NumberFormatPartTypes;

property value

value: string;

interface PluralRules

interface PluralRules {}

method resolvedOptions

resolvedOptions: () => ResolvedPluralRulesOptions;

method select

select: (n: number) => LDMLPluralRule;

interface PluralRulesOptions

interface PluralRulesOptions {}

property localeMatcher

localeMatcher?: 'lookup' | 'best fit' | undefined;

property maximumFractionDigits

maximumFractionDigits?: number | undefined;

property maximumSignificantDigits

maximumSignificantDigits?: number | undefined;

property minimumFractionDigits

minimumFractionDigits?: number | undefined;

property minimumIntegerDigits

minimumIntegerDigits?: number | undefined;

property minimumSignificantDigits

minimumSignificantDigits?: number | undefined;

property type

type?: PluralRuleType | undefined;

interface RelativeTimeFormat

interface RelativeTimeFormat {}

method format

format: (value: number, unit: RelativeTimeFormatUnit) => string;

method formatToParts

formatToParts: (
    value: number,
    unit: RelativeTimeFormatUnit
) => RelativeTimeFormatPart[];

method resolvedOptions

resolvedOptions: () => ResolvedRelativeTimeFormatOptions;

interface RelativeTimeFormatOptions

interface RelativeTimeFormatOptions {}

property localeMatcher

localeMatcher?: RelativeTimeFormatLocaleMatcher;

property numeric

numeric?: RelativeTimeFormatNumeric;

property style

style?: RelativeTimeFormatStyle;

interface RelativeTimeFormatPart

interface RelativeTimeFormatPart {}

property type

type: string;

property unit

unit?: RelativeTimeFormatUnit;

property value

value: string;

interface ResolvedCollatorOptions

interface ResolvedCollatorOptions {}

property caseFirst

caseFirst: string;

property collation

collation: string;

property ignorePunctuation

ignorePunctuation: boolean;

property locale

locale: string;

property numeric

numeric: boolean;

property sensitivity

sensitivity: string;

property usage

usage: string;

interface ResolvedDateTimeFormatOptions

interface ResolvedDateTimeFormatOptions {}

property calendar

calendar: string;

property day

day?: string;

property era

era?: string;

property hour

hour?: string;

property hour12

hour12?: boolean;

property locale

locale: string;

property minute

minute?: string;

property month

month?: string;

property numberingSystem

numberingSystem: string;

property second

second?: string;

property timeZone

timeZone: string;

property timeZoneName

timeZoneName?: string;

property weekday

weekday?: string;

property year

year?: string;

interface ResolvedDateTimeFormatOptions

interface ResolvedDateTimeFormatOptions {}

property dateStyle

dateStyle?: 'full' | 'long' | 'medium' | 'short';

property dayPeriod

dayPeriod?: 'narrow' | 'short' | 'long';

property formatMatcher

formatMatcher?: 'basic' | 'best fit' | 'best fit';

property fractionalSecondDigits

fractionalSecondDigits?: 0 | 1 | 2 | 3;

property hourCycle

hourCycle?: 'h11' | 'h12' | 'h23' | 'h24';

property timeStyle

timeStyle?: 'full' | 'long' | 'medium' | 'short';

interface ResolvedDisplayNamesOptions

interface ResolvedDisplayNamesOptions {}

property fallback

fallback: DisplayNamesFallback;

property languageDisplay

languageDisplay?: DisplayNamesLanguageDisplay;

property locale

locale: UnicodeBCP47LocaleIdentifier;

property style

style: RelativeTimeFormatStyle;

property type

type: DisplayNamesType;

interface ResolvedNumberFormatOptions

interface ResolvedNumberFormatOptions {}

property currency

currency?: string;

property locale

locale: string;

property maximumFractionDigits

maximumFractionDigits: number;

property maximumSignificantDigits

maximumSignificantDigits?: number;

property minimumFractionDigits

minimumFractionDigits: number;

property minimumIntegerDigits

minimumIntegerDigits: number;

property minimumSignificantDigits

minimumSignificantDigits?: number;

property numberingSystem

numberingSystem: string;

property style

style: string;

property useGrouping

useGrouping: boolean;

interface ResolvedNumberFormatOptions

interface ResolvedNumberFormatOptions {}

property compactDisplay

compactDisplay?: 'short' | 'long';

property currencyDisplay

currencyDisplay?: string;

property currencySign

currencySign?: string;

property notation

notation?: 'standard' | 'scientific' | 'engineering' | 'compact';

property signDisplay

signDisplay?: 'auto' | 'never' | 'always' | 'exceptZero';

property unit

unit?: string;

property unitDisplay

unitDisplay?: 'short' | 'long' | 'narrow';

interface ResolvedPluralRulesOptions

interface ResolvedPluralRulesOptions {}

property locale

locale: string;

property maximumFractionDigits

maximumFractionDigits: number;

property maximumSignificantDigits

maximumSignificantDigits?: number;

property minimumFractionDigits

minimumFractionDigits: number;

property minimumIntegerDigits

minimumIntegerDigits: number;

property minimumSignificantDigits

minimumSignificantDigits?: number;

property pluralCategories

pluralCategories: LDMLPluralRule[];

property type

type: PluralRuleType;

interface ResolvedRelativeTimeFormatOptions

interface ResolvedRelativeTimeFormatOptions {}

property locale

locale: UnicodeBCP47LocaleIdentifier;

property numberingSystem

numberingSystem: string;

property numeric

numeric: RelativeTimeFormatNumeric;

property style

style: RelativeTimeFormatStyle;

interface ResolvedSegmenterOptions

interface ResolvedSegmenterOptions {}

property granularity

granularity: 'grapheme' | 'word' | 'sentence';

property locale

locale: string;

interface SegmentData

interface SegmentData {}

property index

index: number;

property input

input: string;

property isWordLike

isWordLike?: boolean;

property segment

segment: string;

interface Segmenter

interface Segmenter {}

method resolvedOptions

resolvedOptions: () => ResolvedSegmenterOptions;

method segment

segment: (input: string) => Segments;

interface SegmenterOptions

interface SegmenterOptions {}

property granularity

granularity?: 'grapheme' | 'word' | 'sentence' | undefined;

property localeMatcher

localeMatcher?: 'best fit' | 'lookup' | undefined;

interface Segments

interface Segments {}

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<SegmentData>;

method containing

containing: (codeUnitIndex?: number) => SegmentData;

Type Aliases

type BCP47LanguageTag

type BCP47LanguageTag = string;

type DateTimeFormatPartTypes

type DateTimeFormatPartTypes =
    | 'day'
    | 'dayPeriod'
    | 'era'
    | 'hour'
    | 'literal'
    | 'minute'
    | 'month'
    | 'second'
    | 'timeZoneName'
    | 'weekday'
    | 'year';

type DisplayNamesFallback

type DisplayNamesFallback = 'code' | 'none';

type DisplayNamesLanguageDisplay

type DisplayNamesLanguageDisplay = 'dialect' | 'standard';

type DisplayNamesType

type DisplayNamesType =
    | 'language'
    | 'region'
    | 'script'
    | 'calendar'
    | 'dateTimeField'
    | 'currency';

type ES2018NumberFormatPartType

type ES2018NumberFormatPartType =
    | 'literal'
    | 'nan'
    | 'infinity'
    | 'percent'
    | 'integer'
    | 'group'
    | 'decimal'
    | 'fraction'
    | 'plusSign'
    | 'minusSign'
    | 'percentSign'
    | 'currency'
    | 'code'
    | 'symbol'
    | 'name';

type ES2020NumberFormatPartType

type ES2020NumberFormatPartType =
    | 'compact'
    | 'exponentInteger'
    | 'exponentMinusSign'
    | 'exponentSeparator'
    | 'unit'
    | 'unknown';

type LDMLPluralRule

type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';

type ListFormatLocaleMatcher

type ListFormatLocaleMatcher = 'lookup' | 'best fit';

type ListFormatStyle

type ListFormatStyle = 'long' | 'short' | 'narrow';

type ListFormatType

type ListFormatType = 'conjunction' | 'disjunction' | 'unit';

type LocaleCollationCaseFirst

type LocaleCollationCaseFirst = 'upper' | 'lower' | 'false';

type LocaleHourCycleKey

type LocaleHourCycleKey = 'h12' | 'h23' | 'h11' | 'h24';

type LocalesArgument

type LocalesArgument =
    | UnicodeBCP47LocaleIdentifier
    | Locale
    | (UnicodeBCP47LocaleIdentifier | Locale)[]
    | undefined;

type NumberFormatPartTypes

type NumberFormatPartTypes = ES2018NumberFormatPartType | ES2020NumberFormatPartType;

type PluralRuleType

type PluralRuleType = 'cardinal' | 'ordinal';

type RelativeTimeFormatLocaleMatcher

type RelativeTimeFormatLocaleMatcher = 'lookup' | 'best fit';

type RelativeTimeFormatNumeric

type RelativeTimeFormatNumeric = 'always' | 'auto';

type RelativeTimeFormatStyle

type RelativeTimeFormatStyle = 'long' | 'short' | 'narrow';

type RelativeTimeFormatUnit

type RelativeTimeFormatUnit =
    | 'year'
    | 'years'
    | 'quarter'
    | 'quarters'
    | 'month'
    | 'months'
    | 'week'
    | 'weeks'
    | 'day'
    | 'days'
    | 'hour'
    | 'hours'
    | 'minute'
    | 'minutes'
    | 'second'
    | 'seconds';

type UnicodeBCP47LocaleIdentifier

type UnicodeBCP47LocaleIdentifier = string;

Package Files (9)

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/intl.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/intl)

HTML

<a href="https://www.jsdocs.io/package/@types/intl"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 20 days ago.
Package analyzed in 3445 ms.
Missing or incorrect documentation? Open an issue for this package.