import '../../../babel/localeData.js';
import '../../../assert/js/assert.js';
import '../../../globals.js';
import TProperty from '../../../axon/js/TProperty.js';
import { Locale } from '../../../joist/js/i18n/localeProperty.js';
import { PhetioID } from '../../../tandem/js/phet-io-types.js';
import Tandem from '../../../tandem/js/Tandem.js';
import LocalizedStringProperty from './LocalizedStringProperty.js';
type TranslationString = string;
export type LocalizedStringStateDelta = Partial<Record<Locale, TranslationString>>;
export type StringsStateStateObject = {
    data: Record<PhetioID, LocalizedStringStateDelta>;
};
export type StringMapEntry = string | {
    [key: string]: StringMapEntry;
};
export type StringMap = Partial<Record<Locale, StringMapEntry>>;
type WithKey<T extends StringMap, Key extends string | number | symbol> = {
    [Locale in keyof T]: T[Locale] extends Record<Key, StringMapEntry> ? T[Locale][Key] : never;
};
type ToKeys<T extends StringMap> = {
    [Locale in keyof T]: keyof T[Locale];
};
type GetKeys<T extends StringMap> = ToKeys<T>[keyof ToKeys<T>];
type StringPropertyName<T> = T extends string ? `${T}StringProperty` : 'foundNotAString';
type KeyValue<T extends StringMap, Key extends string | number | symbol> = WithKey<T, Key>[keyof WithKey<T, Key>];
type ToStringPropertyMap<T extends StringMap> = {
    [Key in GetKeys<T> as ([KeyValue<T, Key>] extends [string] ? StringPropertyName<Key> : Key)]: [
        KeyValue<T, Key>
    ] extends [string] ? LocalizedStringProperty : ToStringPropertyMap<WithKey<T, Key>>;
};
declare class LocalizedString {
    readonly stringKey: string;
    private readonly localeToTranslationMap;
    readonly property: LocalizedStringProperty;
    private readonly localePropertyMap;
    private readonly initialValues;
    constructor(stringKey: string, localeToTranslationMap: LocalizedStringStateDelta, tandem: Tandem, metadata?: Record<string, unknown>);
    /**
     * Returns an object that shows the changes of strings from their initial values. This includes whether strings are
     * marked as "overridden"
     */
    getStateDelta(): LocalizedStringStateDelta;
    /**
     * Take a state from getStateDelta, and apply it.
     */
    setStateDelta(state: LocalizedStringStateDelta): void;
    private get usedLocales();
    /**
     * Returns the locale-specific Property for any locale (lazily creating it if necessary)
     */
    getLocaleSpecificProperty(locale: Locale): TProperty<string>;
    dispose(): void;
    /**
     * Reset to the initial value for the specified locale, used for testing.
     */
    restoreInitialValue(locale: Locale): void;
    static getLocaleFallbacks(locale?: Locale): Locale[];
    /**
     * Computes a nested map of LocalizedStringProperties from a nested input structure of strings.
     * The string Properties will change values based on the current locale
     * (stored in localeProperty).
     *
     * For instance, if we have an example StringMap:
     *
     * const stringMap = {
     *   en: {
     *     a: 'a',
     *     nest: {
     *       x: 'x',
     *       y: 'y'
     *     }
     *   },
     *   hi: {
     *     'a': 'ए',
     *     'b': 'ब',
     *     nest: {
     *       x: 'एक्स',
     *     }
     *   }
     * }
     *
     * Then the resulting LocalizedString.getNestedStringProperties( stringMap ) would
     * have the structure:
     *
     * {
     *   aStringProperty: LocalizedStringProperty,
     *   bStringProperty: LocalizedStringProperty,
     *   nest: {
     *     xStringProperty: LocalizedStringProperty,
     *     yStringProperty: LocalizedStringProperty
     *   }
     * }
     *
     * It is recommended to put each translation file into a separate JSON file,
     * and import them into a single file that will be passed to this function.
     *
     * @param stringData
     */
    static getNestedStringProperties<StringData extends StringMap>(stringData: StringData): ToStringPropertyMap<StringData>;
}
export default LocalizedString;
//# sourceMappingURL=LocalizedString.d.ts.map