index.js.flow

// @flow

export type Options = {
  locale?: string,
  fallbackLocale?: string,
  separator?: string,
  fallback?: string,
  scope?: string | string[],
  interpolate?: boolean,
  format?: 'default' | string,
  type?: 'datetime' | string,
  // @TODO: check if other types than number are really allowed.
  count?: number | string | null,
  ...
};

export type NotFoundHandler = (evt: {
  ...CustomEvent,
  detail: { locale: string, key: string, fallback: string, scope: string },
  ...
}) => void;

export type LocaleChangeHandler = (evt: {
  ...CustomEvent,
  detail: {
    locale: string,
    previous: string,
  },
  ...
}) => void;

export type ErrorHandler = (evt: {
  ...CustomEvent,
  detail: {
    error: Error,
    entry: string,
    values: Options,
  },
  ...
}) => void;

declare function translate(key: string | string[], options?: Options): string;

declare class Counterpart {
  constructor(): this;

  translate: typeof translate;
  localize(date: Date, options: { ... }): string;
  setSeparator(value: string): string;
  setMissingEntryGenerator(callback: (value: string) => void): void;
  getLocale(): string;
  setLocale(value: string): string;
  setFallbackLocale(value: string | string[]): void;
  registerTranslations(locale: string, data: { ... }): void;
  registerInterpolations(data: { ... }): void;
  setKeyTransformer(
    callback: (value: string, options: { ... }) => string,
  ): string;
  onLocaleChange(callback: LocaleChangeHandler): void;
  offLocaleChange(callback: LocaleChangeHandler): void;
  onTranslationNotFound(callback: NotFoundHandler): void;
  offTranslationNotFound(callback: NotFoundHandler): void;
  onError(callback: ErrorHandler): void;
  offError(callback: ErrorHandler): void;
}

declare module.exports: {
  Instance: Class<Counterpart>,
  Translator: Class<Counterpart>,
} & Counterpart &
  typeof translate;