@flickfyi/flkr 0.0.141 → 0.0.146

package/node_modules/@formatjs/intl/index.d.ts

@@ -0,0 +1,499 @@
+import { FormatError, FormatXMLElementFn, Formats, FormattedText, FormattedText as FormattedText$1, Formatters as Formatters$1, IntlMessageFormat, MessageContract, MessageFormatArguments, MessageTag, MessageValue, MessageValues, MessageValues as MessageValues$1, MessageValuesOf, MessageValuesOf as MessageValuesOf$1, NoMessageValues, Options, PrimitiveType, TypedMessageValues, UntypedMessageContract } from "intl-messageformat";
+import { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+//#region packages/intl/typed-message.d.ts
+export type TypedMessageDescriptor<V extends MessageValues$1 = {}> = Readonly<MessageDescriptor> & MessageContract<V>;
+export type UntypedMessageDescriptor = MessageDescriptor & UntypedMessageContract;
+export type TypedMessageArguments<V extends MessageValues$1, T = string, TChunk = T> = MessageFormatArguments<V, T, TChunk, [options?: Options]>;
+export declare function defineMessage<V extends MessageValues$1 = {}, const D extends MessageDescriptor = never>(message: D, options?: {
+  typed: true;
+}): Readonly<D> & Omit<TypedMessageDescriptor<NoInfer<V>>, keyof D>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: string;
+}, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: string;
+}>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor & {
+  defaultMessage: string;
+}, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>> & Readonly<{
+  defaultMessage: string;
+}>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor & {
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>> & Readonly<{
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+}, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+}>;
+export declare function defineMessage<V extends MessageValues$1 = {}>(message: MessageDescriptor, options?: {
+  typed: true;
+}): TypedMessageDescriptor<NoInfer<V>>;
+export declare function defineMessage<T>(message: T): Readonly<T>;
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never, const D extends { [K in keyof NoInfer<V>]: MessageDescriptor; } = never>(messages: [NoInfer<V>] extends [never] ? never : D, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: Readonly<D[K]> & Omit<TypedMessageDescriptor<NoInfer<V[K]>>, keyof D[K]>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: string;
+}; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: string;
+}>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor & {
+  defaultMessage: string;
+}; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>> & Readonly<{
+  defaultMessage: string;
+}>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor & {
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>> & Readonly<{
+  defaultMessage: NonNullable<MessageDescriptor["defaultMessage"]>;
+}>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor & {
+  id: NonNullable<MessageDescriptor["id"]>;
+}; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>> & Readonly<{
+  id: NonNullable<MessageDescriptor["id"]>;
+}>; };
+export declare function defineMessages<V extends Record<string, MessageValues$1> = never>(messages: [NoInfer<V>] extends [never] ? never : { [K in keyof NoInfer<V>]: MessageDescriptor; }, options?: {
+  typed: true;
+}): { readonly [K in keyof NoInfer<V>]: TypedMessageDescriptor<NoInfer<V[K]>>; };
+export declare function defineMessages<const D extends Record<string, MessageDescriptor>>(messages: D, options?: {
+  typed: true;
+}): { readonly [K in keyof D]: Readonly<D[K]> & Omit<TypedMessageDescriptor, keyof D[K]>; };
+export declare function defineMessages<K extends keyof any, T = MessageDescriptor, U extends Record<K, T> = Record<K, T>>(messages: U): { readonly [P in keyof U]: Readonly<U[P]>; };
+/** Argument contracts keyed by application message IDs. */
+export type RegisteredMessageId = keyof FormatjsIntl.MessageArguments & string;
+export type RegisteredMessageValues<K extends RegisteredMessageId> = FormatjsIntl.MessageArguments[K] extends MessageValues$1 ? FormatjsIntl.MessageArguments[K] : never;
+/** Keep known IDs out of the permissive overload without rejecting dynamic IDs. */
+export type UnregisteredMessageDescriptor<D extends UntypedMessageDescriptor> = D & (D extends {
+  id: infer K;
+} ? Extract<K, RegisteredMessageId> extends never ? unknown : never : unknown);
+/** Derive a registry from typed catalog entries with literal IDs. */
+export type MessageArgumentsFromCatalog<C extends Record<string, TypedMessageDescriptor<MessageValues$1>>> = { readonly [K in keyof C as C[K] extends {
+  id: infer I extends string;
+} ? string extends I ? never : I : never]: MessageValuesOf$1<C[K]>; };
+//#endregion
+//#region packages/ecma402-abstract/types/duration.d.ts
+interface DurationInput {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+  milliseconds?: number;
+  microseconds?: number;
+  nanoseconds?: number;
+}
+type DurationFormatOptions = Partial<Omit<ResolvedDurationFormatOptions, "locale">> & {
+  localeMatcher?: "best fit" | "lookup";
+};
+interface ResolvedDurationFormatOptions {
+  locale: string;
+  style: "long" | "short" | "narrow" | "digital";
+  years: "long" | "short" | "narrow";
+  yearsDisplay: "always" | "auto";
+  months: "long" | "short" | "narrow";
+  monthsDisplay: "always" | "auto";
+  weeks: "long" | "short" | "narrow";
+  weeksDisplay: "always" | "auto";
+  days: "long" | "short" | "narrow";
+  daysDisplay: "always" | "auto";
+  hours: "long" | "short" | "narrow" | "numeric" | "2-digit";
+  hoursDisplay: "always" | "auto";
+  minutes: "long" | "short" | "narrow" | "numeric" | "2-digit";
+  minutesDisplay: "always" | "auto";
+  seconds: "long" | "short" | "narrow" | "numeric" | "2-digit";
+  secondsDisplay: "always" | "auto";
+  milliseconds: "long" | "short" | "narrow" | "numeric";
+  millisecondsDisplay: "always" | "auto";
+  microseconds: "long" | "short" | "narrow" | "numeric";
+  microsecondsDisplay: "always" | "auto";
+  nanoseconds: "long" | "short" | "narrow" | "numeric";
+  nanosecondsDisplay: "always" | "auto";
+  fractionalDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+  numberingSystem: string;
+}
+interface DurationFormatPart {
+  unit?: string;
+  type: unknown;
+  value: string;
+}
+interface DurationFormat {
+  resolvedOptions(): ResolvedDurationFormatOptions;
+  formatToParts(duration: DurationInput | string): DurationFormatPart[];
+  format(duration: DurationInput | string): string;
+}
+//#endregion
+//#region packages/ecma402-abstract/types/number.d.ts
+type NumberFormatNotation = "standard" | "scientific" | "engineering" | "compact";
+type RoundingPriorityType = "auto" | "morePrecision" | "lessPrecision";
+type RoundingModeType = "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven";
+type UseGroupingType = "min2" | "auto" | "always" | boolean;
+interface NumberFormatDigitOptions {
+  minimumIntegerDigits?: number;
+  minimumSignificantDigits?: number;
+  maximumSignificantDigits?: number;
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+}
+type NumberFormatOptionsLocaleMatcher = "lookup" | "best fit";
+type NumberFormatOptionsStyle = "decimal" | "percent" | "currency" | "unit";
+type NumberFormatOptionsCompactDisplay = "short" | "long";
+type NumberFormatOptionsCurrencyDisplay = "symbol" | "code" | "name" | "narrowSymbol";
+type NumberFormatOptionsCurrencySign = "standard" | "accounting";
+type NumberFormatOptionsNotation = NumberFormatNotation;
+type NumberFormatOptionsSignDisplay = "auto" | "always" | "never" | "exceptZero" | "negative";
+type NumberFormatOptionsUnitDisplay = "long" | "short" | "narrow";
+type TrailingZeroDisplay = "auto" | "stripIfInteger";
+type NumberFormatOptions = Omit<Intl.NumberFormatOptions, "signDisplay" | "useGrouping"> & NumberFormatDigitOptions & {
+  localeMatcher?: NumberFormatOptionsLocaleMatcher;
+  style?: NumberFormatOptionsStyle;
+  compactDisplay?: NumberFormatOptionsCompactDisplay;
+  currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
+  currencySign?: NumberFormatOptionsCurrencySign;
+  notation?: NumberFormatOptionsNotation;
+  signDisplay?: NumberFormatOptionsSignDisplay;
+  unit?: string;
+  unitDisplay?: NumberFormatOptionsUnitDisplay;
+  numberingSystem?: string;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  useGrouping?: UseGroupingType;
+};
+//#endregion
+//#region packages/intl/error.d.ts
+export declare enum IntlErrorCode {
+  FORMAT_ERROR = "FORMAT_ERROR",
+  UNSUPPORTED_FORMATTER = "UNSUPPORTED_FORMATTER",
+  INVALID_CONFIG = "INVALID_CONFIG",
+  MISSING_DATA = "MISSING_DATA",
+  MISSING_TRANSLATION = "MISSING_TRANSLATION"
+}
+export declare class IntlError<T extends IntlErrorCode = IntlErrorCode.FORMAT_ERROR> extends Error {
+  readonly code: T;
+  constructor(code: T, message: string, exception?: Error | unknown);
+}
+export declare class UnsupportedFormatterError extends IntlError<IntlErrorCode.UNSUPPORTED_FORMATTER> {
+  constructor(message: string, exception?: Error | unknown);
+}
+export declare class InvalidConfigError extends IntlError<IntlErrorCode.INVALID_CONFIG> {
+  constructor(message: string, exception?: Error | unknown);
+}
+export declare class MissingDataError extends IntlError<IntlErrorCode.MISSING_DATA> {
+  constructor(message: string, exception?: Error | unknown);
+}
+export declare class IntlFormatError extends IntlError<IntlErrorCode.FORMAT_ERROR> {
+  readonly descriptor?: MessageDescriptor;
+  readonly locale: string;
+  constructor(message: string, locale: string, exception?: Error | unknown);
+}
+export declare class MessageFormatError extends IntlFormatError {
+  readonly descriptor?: MessageDescriptor;
+  readonly locale: string;
+  constructor(message: string, locale: string, descriptor?: MessageDescriptor, exception?: Error | unknown);
+}
+export declare class MissingTranslationError extends IntlError<IntlErrorCode.MISSING_TRANSLATION> {
+  readonly descriptor?: MessageDescriptor;
+  constructor(descriptor: MessageDescriptor, locale: string);
+}
+//#endregion
+//#region packages/intl/utils.d.ts
+export declare function filterProps<T extends Record<string, any>, K extends string>(props: T, allowlist: Array<K>, defaults?: Partial<T>): Pick<T, K>;
+export declare const DEFAULT_INTL_CONFIG: Pick<ResolvedIntlConfig<any>, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "defaultLocale" | "defaultFormats" | "onError" | "onWarn">;
+export declare function createIntlCache(): IntlCache;
+/**
+ * Create intl formatters and populate cache
+ * @param cache explicit cache to prevent leaking memory
+ */
+export declare function createFormatters(cache?: IntlCache): Formatters;
+export declare function getNamedFormat<T extends keyof CustomFormats>(formats: CustomFormats, type: T, name: string, onError: OnErrorFn): NumberFormatOptions | Intl.DateTimeFormatOptions | Intl.RelativeTimeFormatOptions | DurationFormatOptions | undefined;
+//#endregion
+//#region packages/intl/types.d.ts
+export interface Part<T = string> {
+  type: "element" | "literal";
+  value: T;
+}
+declare global {
+  namespace FormatjsIntl {
+    interface Message {}
+    interface MessageFormatting {}
+    interface MessageArguments {}
+    interface IntlConfig {}
+    interface Formats {}
+  }
+}
+/** Applications can opt in to branded text across the TypeScript program. */
+export type MessageTextOutput = FormatjsIntl.MessageFormatting extends {
+  brandedText: true;
+} ? FormattedText$1 : string;
+type MessageIds = FormatjsIntl.Message extends {
+  ids: infer T;
+} ? T extends string ? T : string : string;
+type Locale = FormatjsIntl.IntlConfig extends {
+  locale: infer T;
+} ? T extends string ? T : string : string;
+export type OnErrorFn = (err: MissingTranslationError | MessageFormatError | MissingDataError | InvalidConfigError | UnsupportedFormatterError | FormatError) => void;
+export type OnWarnFn = (warning: string) => void;
+/**
+ * Config for intl object.
+ * Generic type T is the type of potential rich text element. For example:
+ * With React, T would be React.ReactNode
+ */
+export interface ResolvedIntlConfig<T = string> {
+  locale: Locale;
+  timeZone?: string;
+  fallbackOnEmptyString?: boolean;
+  formats: CustomFormats;
+  messages: Record<MessageIds, string> | Record<MessageIds, MessageFormatElement[]>;
+  defaultLocale: string;
+  defaultFormats: CustomFormats;
+  defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
+  onError: OnErrorFn;
+  onWarn?: OnWarnFn;
+}
+export interface CustomFormats extends Partial<Formats> {
+  duration?: Record<string, DurationFormatOptions>;
+  relative?: Record<string, Intl.RelativeTimeFormatOptions>;
+  dateTimeRange?: Record<string, Intl.DateTimeFormatOptions>;
+}
+export interface CustomFormatConfig<Source = string> {
+  format?: Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
+}
+export type FormatDateTimeRangeOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"dateTimeRange">;
+export type FormatDateOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"date">;
+export type FormatTimeOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"time">;
+export type FormatNumberOptions = Omit<NumberFormatOptions, "localeMatcher"> & CustomFormatConfig<"number">;
+export type FormatRelativeTimeOptions = Omit<Intl.RelativeTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"time">;
+export type FormatPluralOptions = Omit<Intl.PluralRulesOptions, "localeMatcher"> & CustomFormatConfig;
+export type FormatDurationOptions = Omit<DurationFormatOptions, "localeMatcher"> & CustomFormatConfig<"duration">;
+export type FormatListOptions = Omit<Intl.ListFormatOptions, "localeMatcher">;
+export type FormatDisplayNameOptions = Omit<Intl.DisplayNamesOptions, "localeMatcher">;
+/** A string-output formatter shared by core and framework integrations. */
+export interface TextMessageFormatter {
+  <V extends MessageValues = never>(this: void, descriptor: [V] extends [never] ? never : UntypedMessageDescriptor, ...args: TypedMessageArguments<NoInfer<V>>): MessageTextOutput;
+  <D extends TypedMessageDescriptor<MessageValues>>(this: void, descriptor: D, ...args: TypedMessageArguments<MessageValuesOf<NoInfer<D>>>): MessageTextOutput;
+  <const K extends RegisteredMessageId>(this: void, descriptor: UntypedMessageDescriptor & {
+    id: K;
+  }, ...args: TypedMessageArguments<RegisteredMessageValues<NoInfer<K>>>): MessageTextOutput;
+  <V = never, const D extends UntypedMessageDescriptor = UntypedMessageDescriptor>(this: void, descriptor: [V] extends [never] ? D & UnregisteredMessageDescriptor<NoInfer<D>> : never, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: Options): MessageTextOutput;
+}
+/**
+ * `TBase` is the type constraints of the rich text element in the formatted output.
+ * For example, with React, `TBase` should be `React.ReactNode`.
+ */
+export interface IntlFormatters<TBase = unknown> {
+  formatDateTimeRange(this: void, from: Parameters<Intl.DateTimeFormat["formatRange"]>[0] | string, to: Parameters<Intl.DateTimeFormat["formatRange"]>[1] | string, opts?: FormatDateTimeRangeOptions): string;
+  formatDate(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): string;
+  formatTime(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatTimeOptions): string;
+  formatDateToParts(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
+  formatTimeToParts(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
+  formatDuration(this: void, value: DurationInput, opts?: FormatDurationOptions): string;
+  formatDurationToParts(this: void, value: DurationInput, opts?: FormatDurationOptions): DurationFormatPart[];
+  formatRelativeTime(this: void, value: Parameters<Intl.RelativeTimeFormat["format"]>[0], unit?: Parameters<Intl.RelativeTimeFormat["format"]>[1], opts?: FormatRelativeTimeOptions): string;
+  formatNumber(this: void, value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions): string;
+  formatNumberToParts(this: void, value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions): Intl.NumberFormatPart[];
+  formatPlural(this: void, value: Parameters<Intl.PluralRules["select"]>[0], opts?: FormatPluralOptions): ReturnType<Intl.PluralRules["select"]>;
+  formatMessage<V extends MessageValues = never, T extends TBase = TBase>(this: void, descriptor: [V] extends [never] ? never : UntypedMessageDescriptor, ...args: TypedMessageArguments<NoInfer<V>, string, T>): MessageTextOutput;
+  formatMessage<V extends MessageValues = never, T extends TBase = TBase>(this: void, descriptor: [V] extends [never] ? never : UntypedMessageDescriptor, ...args: TypedMessageArguments<NoInfer<V>, T>): string | T | Array<string | T>;
+  formatMessage<D extends TypedMessageDescriptor<MessageValues>>(this: void, descriptor: D, ...args: TypedMessageArguments<MessageValuesOf<NoInfer<D>>, string, TBase>): MessageTextOutput;
+  formatMessage<D extends TypedMessageDescriptor<MessageValues>>(this: void, descriptor: D, ...args: TypedMessageArguments<MessageValuesOf<NoInfer<D>>, TBase>): string | TBase | Array<string | TBase>;
+  formatMessage<const K extends RegisteredMessageId>(this: void, descriptor: UntypedMessageDescriptor & {
+    id: K;
+  }, ...args: TypedMessageArguments<RegisteredMessageValues<NoInfer<K>>, string, TBase>): MessageTextOutput;
+  formatMessage<const K extends RegisteredMessageId>(this: void, descriptor: UntypedMessageDescriptor & {
+    id: K;
+  }, ...args: TypedMessageArguments<RegisteredMessageValues<NoInfer<K>>, TBase>): string | TBase | Array<string | TBase>;
+  formatMessage<V = never, const D extends UntypedMessageDescriptor = UntypedMessageDescriptor>(this: void, descriptor: [V] extends [never] ? D & UnregisteredMessageDescriptor<NoInfer<D>> : never, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: Options): MessageTextOutput;
+  formatMessage<V = never, const D extends UntypedMessageDescriptor = UntypedMessageDescriptor>(this: void, descriptor: [V] extends [never] ? D & UnregisteredMessageDescriptor<NoInfer<D>> : never, values?: Record<string, PrimitiveType | TBase | FormatXMLElementFn<TBase>>, opts?: Options): string | TBase | Array<string | TBase>;
+  $t<V extends MessageValues = never, T extends TBase = TBase>(this: void, descriptor: [V] extends [never] ? never : UntypedMessageDescriptor, ...args: TypedMessageArguments<NoInfer<V>, string, T>): MessageTextOutput;
+  $t<V extends MessageValues = never, T extends TBase = TBase>(this: void, descriptor: [V] extends [never] ? never : UntypedMessageDescriptor, ...args: TypedMessageArguments<NoInfer<V>, T>): string | T | Array<string | T>;
+  $t<D extends TypedMessageDescriptor<MessageValues>>(this: void, descriptor: D, ...args: TypedMessageArguments<MessageValuesOf<NoInfer<D>>, string, TBase>): MessageTextOutput;
+  $t<D extends TypedMessageDescriptor<MessageValues>>(this: void, descriptor: D, ...args: TypedMessageArguments<MessageValuesOf<NoInfer<D>>, TBase>): string | TBase | Array<string | TBase>;
+  $t<const K extends RegisteredMessageId>(this: void, descriptor: UntypedMessageDescriptor & {
+    id: K;
+  }, ...args: TypedMessageArguments<RegisteredMessageValues<NoInfer<K>>, string, TBase>): MessageTextOutput;
+  $t<const K extends RegisteredMessageId>(this: void, descriptor: UntypedMessageDescriptor & {
+    id: K;
+  }, ...args: TypedMessageArguments<RegisteredMessageValues<NoInfer<K>>, TBase>): string | TBase | Array<string | TBase>;
+  $t<V = never, const D extends UntypedMessageDescriptor = UntypedMessageDescriptor>(this: void, descriptor: [V] extends [never] ? D & UnregisteredMessageDescriptor<NoInfer<D>> : never, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: Options): MessageTextOutput;
+  $t<V = never, const D extends UntypedMessageDescriptor = UntypedMessageDescriptor>(this: void, descriptor: [V] extends [never] ? D & UnregisteredMessageDescriptor<NoInfer<D>> : never, values?: Record<string, PrimitiveType | TBase | FormatXMLElementFn<TBase>>, opts?: Options): string | TBase | (TBase | string)[];
+  formatList(this: void, values: Iterable<string>, opts?: FormatListOptions): string;
+  formatList<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): T | string | (string | T)[];
+  formatListToParts<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): Part[];
+  formatDisplayName(this: void, value: Parameters<Intl.DisplayNames["of"]>[0], opts: FormatDisplayNameOptions): string | undefined;
+}
+export interface Formatters {
+  getDateTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
+  getNumberFormat(this: void, locales?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
+  getMessageFormat(this: void, ...args: ConstructorParameters<typeof IntlMessageFormat>): IntlMessageFormat;
+  getDurationFormat(this: void, locales?: string | string[], opts?: DurationFormatOptions): DurationFormat;
+  getRelativeTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
+  getPluralRules(this: void, ...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
+  getListFormat(this: void, ...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
+  getDisplayNames(this: void, ...args: ConstructorParameters<typeof Intl.DisplayNames>): Intl.DisplayNames;
+}
+export interface IntlShape<T = string> extends ResolvedIntlConfig<T>, IntlFormatters<T> {
+  formatters: Formatters;
+}
+export interface IntlCache {
+  dateTime: Record<string, Intl.DateTimeFormat>;
+  number: Record<string, Intl.NumberFormat>;
+  message: Record<string, IntlMessageFormat>;
+  duration: Record<string, DurationFormat>;
+  relativeTime: Record<string, Intl.RelativeTimeFormat>;
+  pluralRules: Record<string, Intl.PluralRules>;
+  list: Record<string, Intl.ListFormat>;
+  displayNames: Record<string, Intl.DisplayNames>;
+}
+export interface MessageDescriptor {
+  id?: MessageIds;
+  description?: string | object;
+  defaultMessage?: string | MessageFormatElement[];
+}
+export type IntlConfig<T = string> = Omit<ResolvedIntlConfig<T>, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
+//#endregion
+//#region packages/intl/message.d.ts
+type FormatMessageFn<T> = ({ locale, formats, messages, defaultLocale, defaultFormats, fallbackOnEmptyString, onError, timeZone, defaultRichTextElements }: {
+  locale: string;
+  timeZone?: string;
+  formats: CustomFormats;
+  messages: Record<string, string> | Record<string, MessageFormatElement[]>;
+  defaultLocale: string;
+  defaultFormats: CustomFormats;
+  defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
+  fallbackOnEmptyString?: boolean;
+  onError: OnErrorFn;
+}, state: Formatters$1 & Pick<Formatters, "getMessageFormat">, messageDescriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: Options) => T extends string ? string : Array<T | string> | string | T;
+export declare const formatMessage: FormatMessageFn<any>;
+//#endregion
+//#region packages/intl/dateTime.d.ts
+export declare function formatDate(config: {
+  locale: string;
+  timeZone?: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getDateTimeFormat: Formatters["getDateTimeFormat"], value: Parameters<IntlFormatters["formatDate"]>[0], options?: Parameters<IntlFormatters["formatDate"]>[1]): string;
+export declare function formatTime(config: {
+  locale: string;
+  timeZone?: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getDateTimeFormat: Formatters["getDateTimeFormat"], value: Parameters<IntlFormatters["formatTime"]>[0], options?: Parameters<IntlFormatters["formatTime"]>[1]): string;
+export declare function formatDateToParts(config: {
+  locale: string;
+  timeZone?: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getDateTimeFormat: Formatters["getDateTimeFormat"], value: Parameters<IntlFormatters["formatDate"]>[0], options?: Parameters<IntlFormatters["formatDate"]>[1]): Intl.DateTimeFormatPart[];
+export declare function formatTimeToParts(config: {
+  locale: string;
+  timeZone?: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getDateTimeFormat: Formatters["getDateTimeFormat"], value: Parameters<IntlFormatters["formatTimeToParts"]>[0], options?: Parameters<IntlFormatters["formatTimeToParts"]>[1]): Intl.DateTimeFormatPart[];
+//#endregion
+//#region packages/intl/duration.d.ts
+type Config = {
+  locale: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+};
+export declare function formatDuration(config: Config, getDurationFormat: Formatters["getDurationFormat"], value: Parameters<IntlFormatters["formatDuration"]>[0], options?: FormatDurationOptions): string;
+export declare function formatDurationToParts(config: Config, getDurationFormat: Formatters["getDurationFormat"], value: Parameters<IntlFormatters["formatDuration"]>[0], options?: FormatDurationOptions): ReturnType<IntlFormatters["formatDurationToParts"]>;
+//#endregion
+//#region packages/intl/displayName.d.ts
+export declare function formatDisplayName({ locale, onError }: {
+  locale: string;
+  onError: OnErrorFn;
+}, getDisplayNames: Formatters["getDisplayNames"], value: Parameters<IntlFormatters["formatDisplayName"]>[0], options: Parameters<IntlFormatters["formatDisplayName"]>[1]): string | undefined;
+//#endregion
+//#region packages/intl/list.d.ts
+export declare function formatList(opts: {
+  locale: string;
+  onError: OnErrorFn;
+}, getListFormat: Formatters["getListFormat"], values: Iterable<string>, options: Parameters<IntlFormatters["formatList"]>[1]): string;
+//#endregion
+//#region packages/intl/plural.d.ts
+export declare function formatPlural({ locale, onError }: {
+  locale: string;
+  onError: OnErrorFn;
+}, getPluralRules: Formatters["getPluralRules"], value: Parameters<IntlFormatters["formatPlural"]>[0], options?: Parameters<IntlFormatters["formatPlural"]>[1]): Intl.LDMLPluralRule;
+//#endregion
+//#region packages/intl/relativeTime.d.ts
+export declare function formatRelativeTime(config: {
+  locale: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getRelativeTimeFormat: Formatters["getRelativeTimeFormat"], value: Parameters<IntlFormatters["formatRelativeTime"]>[0], unit?: Parameters<IntlFormatters["formatRelativeTime"]>[1], options?: Parameters<IntlFormatters["formatRelativeTime"]>[2]): string;
+//#endregion
+//#region packages/intl/number.d.ts
+export declare function formatNumber(config: {
+  locale: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getNumberFormat: Formatters["getNumberFormat"], value: Parameters<IntlFormatters["formatNumber"]>[0], options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
+export declare function formatNumberToParts(config: {
+  locale: string;
+  formats: CustomFormats;
+  onError: OnErrorFn;
+}, getNumberFormat: Formatters["getNumberFormat"], value: Parameters<IntlFormatters["formatNumber"]>[0], options?: Parameters<IntlFormatters["formatNumber"]>[1]): Intl.NumberFormatPart[];
+//#endregion
+//#region packages/intl/create-intl.d.ts
+interface CreateIntlFn<T = string, C extends IntlConfig<T> = IntlConfig<T>, S extends IntlShape<T> = IntlShape<T>> {
+  (config: C, cache?: IntlCache): S;
+}
+/**
+ * Create intl object
+ * @param config intl config
+ * @param cache cache for formatter instances to prevent memory leak
+ */
+export declare function createIntl<T = string>(config: IntlConfig<T>, cache?: IntlCache): IntlShape<T>;
+//#endregion
+export type { CreateIntlFn, FormatMessageFn, FormattedText, MessageTag, MessageValue, MessageValues, MessageValuesOf, NoMessageValues, TypedMessageValues };
+//# sourceMappingURL=index.d.ts.map