@types/intl

  • Version 1.2.0
  • Published
  • No dependencies
  • MIT license

Install

npm i @types/intl
yarn add @types/intl
pnpm add @types/intl

Overview

TypeScript definitions for intl

Index

Variables

Interfaces

Type Aliases

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[];
    };

      variable DisplayNames

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

        variable Locale

        const Locale: new (tag?: BCP47LanguageTag, 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[];
          };

            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[];
              };

                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 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?: 'long' | 'short' | 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;

                                                                                                              method resolvedOptions

                                                                                                              resolvedOptions: () => DisplayNamesOptions;

                                                                                                                interface DisplayNamesOptions

                                                                                                                interface DisplayNamesOptions {}

                                                                                                                  property fallback

                                                                                                                  fallback: 'code' | 'none';

                                                                                                                    property localeMatcher

                                                                                                                    localeMatcher: RelativeTimeFormatLocaleMatcher;

                                                                                                                      property style

                                                                                                                      style: RelativeTimeFormatStyle;

                                                                                                                        property type

                                                                                                                        type: 'language' | 'region' | 'script' | 'currency';

                                                                                                                          interface Locale

                                                                                                                          interface Locale extends LocaleOptions {}

                                                                                                                            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: (startDate: number | bigint, endDate: number | bigint) => string;

                                                                                                                                                                            method formatRangeToParts

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

                                                                                                                                                                              interface NumberFormatOptions

                                                                                                                                                                              interface NumberFormatOptions {}

                                                                                                                                                                                property currency

                                                                                                                                                                                currency?: string | undefined;

                                                                                                                                                                                  property currencyDisplay

                                                                                                                                                                                  currencyDisplay?: 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 notation

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

                                                                                                                                                                                                            property signDisplay

                                                                                                                                                                                                            signDisplay?: 'auto' | 'never' | 'always' | 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 ResolvedNumberFormatOptions

                                                                                                                                                                                                                                                                                                                                  interface ResolvedNumberFormatOptions {}

                                                                                                                                                                                                                                                                                                                                    property currency

                                                                                                                                                                                                                                                                                                                                    currency?: string;

                                                                                                                                                                                                                                                                                                                                      property currencyDisplay

                                                                                                                                                                                                                                                                                                                                      currencyDisplay?: 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 notation

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

                                                                                                                                                                                                                                                                                                                                                                property signDisplay

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

                                                                                                                                                                                                                                                                                                                                                                  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;

                                                                                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                  type BCP47LanguageTag

                                                                                                                                                                                                                                                                                                                                                                                                  type BCP47LanguageTag = string;

                                                                                                                                                                                                                                                                                                                                                                                                    type DateTimeFormatPartTypes

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

                                                                                                                                                                                                                                                                                                                                                                                                      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 LocaleCollationCaseFirst

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

                                                                                                                                                                                                                                                                                                                                                                                                              type LocaleHourCycleKey

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

                                                                                                                                                                                                                                                                                                                                                                                                                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 (7)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto 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>