import { MessageFormatElement, ParserOptions, parse } from "@formatjs/icu-messageformat-parser";
//#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-messageformat/formatters.d.ts
declare global {
  namespace FormatjsIntl {
    interface Message {}
    interface IntlConfig {}
    interface Formats {}
  }
}
type Format<Source = string> = Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
export interface Formats {
  number: Record<Format<"number">, NumberFormatOptions>;
  date: Record<Format<"date">, Intl.DateTimeFormatOptions>;
  time: Record<Format<"time">, Intl.DateTimeFormatOptions>;
}
export interface FormatterCache {
  number: Record<string, NumberFormatOptions>;
  dateTime: Record<string, Intl.DateTimeFormat>;
  pluralRules: Record<string, Intl.PluralRules>;
}
export interface Formatters {
  getNumberFormat(locals?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
  getDateTimeFormat(...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
  getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
}
export declare enum PART_TYPE {
  literal = 0,
  object = 1
}
export interface LiteralPart {
  type: PART_TYPE.literal;
  value: string;
}
export interface ObjectPart<T = any> {
  type: PART_TYPE.object;
  value: T;
}
export type MessageFormatPart<T> = LiteralPart | ObjectPart<T>;
export type PrimitiveType = string | number | bigint | boolean | null | undefined | Date;
export declare function isFormatXMLElementFn<T>(el: PrimitiveType | T | FormatXMLElementFn<T>): el is FormatXMLElementFn<T>;
export declare function formatToParts<T>(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart<T>[];
export type FormatXMLElementFn<T, R = string | T | (string | T)[]> = (parts: Array<string | T>) => R;
//#endregion
//#region packages/intl-messageformat/message-types.d.ts
declare const formattedTextBrand: unique symbol;
/** Formatter-produced text, including fallbacks; not a translation or safety guarantee. */
type FormattedText = string & {
  readonly [formattedTextBrand]: true;
};
declare const messageValues: unique symbol;
declare const messageTag: unique symbol;
/** An unformatted ICU argument, before framework-specific rich values are added. */
type MessageValue = PrimitiveType;
/** A tag placeholder whose callback type is supplied by the formatter. */
interface MessageTag {
  readonly [messageTag]: true;
}
/** A message contract with no arguments. */
type NoMessageValues = Record<never, never>;
type MessageValues = Record<string, MessageValue | MessageTag>;
/** Type-only argument metadata shared by formatter integrations. */
interface MessageContract<V extends MessageValues> {
  readonly [messageValues]: V;
}
type MessageValuesOf<D extends MessageContract<MessageValues>> = D[typeof messageValues];
interface UntypedMessageContract {
  readonly [messageValues]?: never;
}
type ResolveMessageValues<V extends MessageValues, T, TChunk> = { [K in keyof V]: [V[K]] extends [undefined] ? V[K] : Exclude<V[K], undefined> extends MessageTag ? FormatXMLElementFn<string | TChunk, string | T | Array<string | T>> : MessageValue extends V[K] ? V[K] | T : Extract<V[K], MessageValue>; };
type MessageKeys<V> = V extends unknown ? keyof V : never;
type TypedMessageValues<V extends MessageValues, T = string, TChunk = T> = (V extends unknown ? (values: ResolveMessageValues<V, T, TChunk>) => void : never) extends ((values: infer Values) => void) ? Values : never;
type MessageFormatArguments<V extends MessageValues, T = string, TChunk = T, Extra extends unknown[] = []> = MessageKeys<V> extends never ? [values?: Record<string, never>, ...extra: Extra] : {} extends TypedMessageValues<V, T, TChunk> ? [values?: TypedMessageValues<V, T, TChunk>, ...extra: Extra] : [values: TypedMessageValues<V, T, TChunk>, ...extra: Extra];
type UntypedMessageFormat = <T = void>(values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>) => string | T | (string | T)[];
type UntypedMessageFormatToParts = <T>(values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>) => MessageFormatPart<T>[];
type MessageFormatFunction<V extends MessageValues | undefined> = [V] extends [MessageValues] ? <T = string>(...args: MessageFormatArguments<Extract<V, MessageValues>, T>) => string | T | (string | T)[] : UntypedMessageFormat;
type MessageFormatToPartsFunction<V extends MessageValues | undefined> = [V] extends [MessageValues] ? <T = string>(...args: MessageFormatArguments<Extract<V, MessageValues>, T>) => MessageFormatPart<T>[] : UntypedMessageFormatToParts;
//#endregion
//#region packages/intl-messageformat/core.d.ts
export interface Options extends Omit<ParserOptions, "locale"> {
  formatters?: Formatters;
}
export declare class IntlMessageFormat<V extends MessageValues | undefined = undefined> {
  private readonly ast;
  private readonly locales;
  private readonly resolvedLocale?;
  private readonly formatters;
  private readonly formats;
  private readonly message;
  private readonly formatterCache;
  constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
  format: MessageFormatFunction<V>;
  formatToParts: MessageFormatToPartsFunction<V>;
  resolvedOptions: () => {
    locale: string;
  };
  getAst: () => MessageFormatElement[];
  private static memoizedDefaultLocale;
  static get defaultLocale(): string;
  static resolveLocale: (locales: string | string[]) => Intl.Locale | undefined;
  static __parse: typeof parse | undefined;
  static formats: Formats;
}
//#endregion
//#region packages/intl-messageformat/error.d.ts
export declare enum ErrorCode {
  MISSING_VALUE = "MISSING_VALUE",
  INVALID_VALUE = "INVALID_VALUE",
  MISSING_INTL_API = "MISSING_INTL_API"
}
export declare class FormatError extends Error {
  readonly code: ErrorCode;
  /**
   * Original message we're trying to format
   * `undefined` if we're only dealing w/ AST
   *
   * @type {(string | undefined)}
   * @memberof FormatError
   */
  readonly originalMessage: string | undefined;
  constructor(msg: string, code: ErrorCode, originalMessage?: string);
  toString(): string;
}
export declare class InvalidValueError extends FormatError {
  constructor(variableId: string, value: any, options: string[], originalMessage?: string);
}
export declare class InvalidValueTypeError extends FormatError {
  constructor(value: any, type: string, originalMessage?: string);
}
export declare class MissingValueError extends FormatError {
  constructor(variableId: string, originalMessage?: string);
}
//#endregion
export { type FormattedText, IntlMessageFormat as default, type MessageContract, type MessageFormatArguments, type MessageFormatFunction, type MessageFormatToPartsFunction, type MessageTag, type MessageValue, type MessageValues, type MessageValuesOf, type NoMessageValues, type TypedMessageValues, type UntypedMessageContract };
//# sourceMappingURL=index.d.ts.map