react-localization.tsx

declare module 'react-localization' {
    import react from "react";
    type Formatted = number | string | react.JSX.Element;
    type FormatObject<U extends Formatted> = { [key: string]: U };

    export interface GlobalStrings<T> {
        [language: string]: T;
    }

    export interface LocalizedStringsMethods {
        /**
         * Can be used from ouside the class to force a particular language
         * independently from the interface one
         * @param language 
         */
        setLanguage(language: string): void;

        /**
         *  The current language displayed (could differ from the interface language
         *  if it has been forced manually and a matching translation has been found)
         */
        getLanguage(): string;

        /**
         * The current interface language (could differ from the language displayed)
         */
        getInterfaceLanguage(): string;

        /**
         * Format the passed string replacing the numbered placeholders
         * i.e. I'd like some {0} and {1}, or just {0}
         * Use example:
         *   strings.formatString(strings.question, strings.bread, strings.butter)
         */
        formatString<T extends Formatted>(str: string, ...values: Array<T | FormatObject<T>>): Array<string | T> | string;

        /**
         * Return an array containing the available languages passed as props in the constructor
         */
        getAvailableLanguages(): string[];

        /**
         * Return a string with the passed key in a different language
         * @param key 
         * @param language 
         */
        getString(key: string, language?: string, omitWarning?: boolean): string;

        /**
         * Replace the NamedLocalization object without reinstantiating the object
         * @param props 
         */
        setContent(props: any): void;
    }

    export type LocalizedStrings<T> = LocalizedStringsMethods & T;

    type GetInterfaceLanguageCallback = () => string;

    interface Options {
        customLanguageInterface?: GetInterfaceLanguageCallback;
        logsEnabled?: boolean;
        pseudo?: boolean;
        pseudoMultipleLanguages?: boolean;
    }

    interface LocalizedStringsFactory {
        new <T>(props: GlobalStrings<T>, options?: Options): LocalizedStrings<T>;
    }
    var LocalizedStrings: LocalizedStringsFactory;
    export default LocalizedStrings;
}