i18next

constructor

constructor(data: Resource, options: InitOptions<object>);

property data

data: Resource;

property options

options: InitOptions<object>;

method off

off: (
    event: 'added' | 'removed',
    callback?: (lng: string, ns: string) => void
) => void;

• Remove event listener removes all callback when callback not specified

method on

on: (
    event: 'added' | 'removed',
    callback: (lng: string, ns: string) => void
) => void;

• Gets fired when resources got added or removed

method once

once: (
    event: 'added' | 'removed',
    callback: (lng: string, ns: string) => void
) => this;

• Subscribe to an event, but only once. The listener is removed after the first call.

property type

type: 'backend';

method create

create: (
    languages: readonly string[],
    namespace: string,
    key: string,
    fallbackValue: string
) => void;

• Save the missing translation

method init

init: (
    services: Services,
    backendOptions: Options,
    i18nextOptions: InitOptions
) => void;

method read

read: (language: string, namespace: string, callback: ReadCallback) => void;

method readMulti

readMulti: (
    languages: readonly string[],
    namespaces: readonly string[],
    callback: MultiReadCallback
) => void;

• Load multiple languages and namespaces. For backends supporting multiple resources loading

method save

save: (language: string, namespace: string, data: ResourceLanguage) => void;

• Store the translation. For backends acting as cache layer

property $TFunctionBrand

$TFunctionBrand: $IsResourcesDefined extends true
    ? `${Ns extends readonly any[] ? Ns[0] : Ns}`
    : never;

property forkResourceStore

forkResourceStore?: boolean;

• Will create a new instance of the resource store and import the existing translation resources. This way it will not shared the resource store instance. false

call signature

(key: TKeys | TKeys[], options?: TOptions<TInterpolationMap>): boolean;

index signature

[language: string]: readonly string[];

property format

format: FormatFunction;

method add

add: (
    name: string,
    fc: (value: any, lng: string | undefined, options: any) => string
) => void;

method addCached

addCached: (
    name: string,
    fc: (lng: string | undefined, options: any) => (value: any) => string
) => void;

method init

init: (services: Services, i18nextOptions: InitOptions) => void;

property type

type: 'formatter';

property exists

exists: {
    <K extends string>(key: K, options?: TOptions): key is K & SelectorKey;
    (key: string | string[], options?: TOptions): boolean;
};

• Uses similar args as the t function and returns true if a key exists. Acts as a type guard on single-key calls, narrowing the key to SelectorKey so it can be passed to t().

property modules

modules: Modules;

• List of modules used

property services

services: Services;

• Internal container for all used plugins and implementation details like languageUtils, pluralResolvers, etc.

property store

store: ResourceStore;

• Internal container for translation resources

property t

t: TFunction<
    [
        ...$NormalizeIntoArray<DefaultNamespace>,
        ...Exclude<
            FlatNamespace,
            InferArrayValuesElseReturnType<DefaultNamespace>
        >[]
    ]
>;

method getDataByLanguage

getDataByLanguage: (lng: string) => { [key: string]: { [key: string]: string } };

• Returns a resource data by language.

method getFixedT

getFixedT: <Ns extends Namespace<string>>() => any;

• Returns a t function that defaults to given language or namespace. Both params could be arrays of languages or namespaces and will be treated as fallbacks in that case. On the returned function you can like in the t function override the languages or namespaces by passing them in options or by prepending namespace.

  Accepts optional keyPrefix that will be automatically applied to returned t function.

method init

init: {
    (callback?: Callback): Promise<TFunction>;
    <T>(options: InitOptions<T>, callback?: Callback): Promise<
        TFunction<'translation', undefined>
    >;
};

• The default of the i18next module is an i18next instance ready to be initialized by calling init. You can create additional instances using the createInstance function.

  Parameter options

  Initial options.

  Parameter callback

  will be called after all translations were loaded or with an error when failed (in case of using a backend).

method loadResources

loadResources: (callback?: (err: any) => void) => void;

method use

use: <T extends Module>(module: T | NewableModule<T> | Newable<T>) => this;

• The use function is there to load additional plugins to i18next. For available module see the plugins page and don't forget to read the documentation of the plugin.

  Parameter module

  Accepts a class or object

property type

type: 'i18nFormat';

property appendNamespaceToCIMode

appendNamespaceToCIMode?: boolean;

• Prefixes the namespace to the returned key when using cimode false

property appendNamespaceToMissingKey

appendNamespaceToMissingKey?: boolean;

• Appends namespace to missing key false

property cacheInBuiltFormats

cacheInBuiltFormats?: boolean;

• Initializes the internal formatter for the in-built formats as cached version. Can be set to false for this type of issues: https://github.com/i18next/i18next/issues/2227 true

property cleanCode

cleanCode?: boolean;

• Language will be lowercased EN --> en while leaving full locales like en-US false

property compatibilityJSON

compatibilityJSON?: 'v4';

• Compatibility JSON version only v4 is available and supported by typescript 'v4'

property contextSeparator

contextSeparator?: string;

• Char to split context from key '_'

property debug

debug?: boolean;

• Logs info level to console output. Helps finding issues with loading not working. false

property defaultNS

defaultNS?: string | false | readonly string[];

• Default namespace used if not passed to translation function 'translation'

property enableSelector

enableSelector?: false | true | 'optimize' | 'strict';

• Selector-API mode. Mirrors CustomTypeOptions['enableSelector'].

  - false (default): selector API disabled. - true / 'optimize': selector resolution enabled. - 'strict': require an explicit namespace as the first selector path segment in every call. The resolver always rewrites a leading namespace-matching segment as a namespace prefix.

  false

property fallbackLng

fallbackLng?: false | FallbackLng;

• Language to use if translations in user language are not available. 'dev'

property fallbackNS

fallbackNS?: false | string | readonly string[];

• String or array of namespaces to lookup key if not found in given namespace. false

property ignoreJSONStructure

ignoreJSONStructure?: boolean;

• Automatically lookup for a flat key if a nested key is not found an vice-versa true

property initAsync

initAsync?: boolean;

• Triggers resource loading in init function inside a setTimeout (default async behaviour). Set it to false if your backend loads resources sync - that way calling i18next.t after init is possible without relaying on the init callback. true

property interpolation

interpolation?: InterpolationOptions;

• See Also

  • https://www.i18next.com/translation-function/interpolation

property joinArrays

joinArrays?: false | string;

• Char, eg. '\n' that arrays will be joined by false

property keySeparator

keySeparator?: false | string;

• Char to separate keys '.'

property lng

lng?: string;

• Language to use (overrides language detection) undefined

property load

load?: 'all' | 'currentOnly' | 'languageOnly';

• Language codes to lookup, given set language is 'en-US': 'all' --> ['en-US', 'en', 'dev'], 'currentOnly' --> 'en-US', 'languageOnly' --> 'en' 'all'

property locizeLastUsed

locizeLastUsed?: {
    /**
     * The id of your locize project
     */
    projectId: string;

    /**
     * An api key if you want to send missing keys
     */
    apiKey?: string;

    /**
     * The reference language of your project
     * @default 'en'
     */
    referenceLng?: string;

    /**
     * Version
     * @default 'latest'
     */
    version?: string;

    /**
     * Debounce interval to send data in milliseconds
     * @default 90000
     */
    debounceSubmit?: number;

    /**
     * Hostnames that are allowed to send last used data.
     * Please keep those to your local system, staging, test servers (not production)
     * @default ['localhost']
     */
    allowedHosts?: readonly string[];
};

• Options for https://github.com/locize/locize-lastused undefined

property lowerCaseLng

lowerCaseLng?: boolean;

• Language will be lowercased eg. en-US --> en-us false

property maxParallelReads

maxParallelReads?: number;

• Limit parallelism of calls to backend This is needed to prevent trying to open thousands of sockets or file descriptors, which can cause failures and actually make the entire process take longer. 10

property maxRetries

maxRetries?: number;

• The maximum number of retries to perform. Note that retries are only performed when a request has no response and throws an error. The default value is used if value is set below 0. 5

property missingInterpolationHandler

missingInterpolationHandler?: (
    text: string,
    value: any,
    options: InitOptions
) => any;

• Gets called in case a interpolation value is undefined. This method will not be called if the value is empty string or null noop

property missingKeyHandler

missingKeyHandler?:
    | false
    | ((
          lngs: readonly string[],
          ns: string,
          key: string,
          fallbackValue: string,
          updateMissing: boolean,
          options: any
      ) => void);

• Used for custom missing key handling (needs saveMissing set to true!) false

property missingKeyNoValueFallbackToKey

missingKeyNoValueFallbackToKey?: boolean;

• Used to not fallback to the key as default value, when using saveMissing functionality. i.e. when using with i18next-http-backend this will result in having a key with an empty string value. false

property nonExplicitSupportedLngs

nonExplicitSupportedLngs?: boolean;

• If true will pass eg. en-US if finding en in supportedLngs false

property ns

ns?: string | readonly string[];

• String or array of namespaces to load 'translation'

property nsSeparator

nsSeparator?: false | string;

• Char to split namespace from key ':'

property partialBundledLanguages

partialBundledLanguages?: boolean;

• Allow initializing with bundled resources while using a backend to load non bundled ones. false

property pluralSeparator

pluralSeparator?: string;

• Char to split plural from key '_'

property postProcess

postProcess?: false | string | readonly string[];

• String or array of postProcessors to apply per default false

property postProcessPassResolved

postProcessPassResolved?: boolean;

• passthrough the resolved object including 'usedNS', 'usedLang' etc into options object of postprocessors as 'i18nResolved' property false

property preload

preload?: false | readonly string[];

• Array of languages to preload. Important on server-side to assert translations are loaded before rendering views. false

property react

react?: ReactOptions;

• Options for react - check documentation of plugin undefined

property resources

resources?: Resource;

• Resources to initialize with (if not using loading or not appending using addResourceBundle) undefined

property retryTimeout

retryTimeout?: number;

• Set how long to wait, in milliseconds, between retries of failed requests. This number is compounded by a factor of 2 for subsequent retry. The default value is used if value is set below 1ms. 350

property returnDetails

returnDetails?: boolean;

• Returns an object that includes information about the used language, namespace, key and value false

property returnEmptyString

returnEmptyString?: boolean;

• Allows empty string as valid translation true

property returnNull

returnNull?: boolean;

• Allows null values as valid translation false

property returnObjects

returnObjects?: boolean;

• Allows objects as valid translation result false

property saveMissing

saveMissing?: boolean;

• Calls save missing key function on backend if key not found. false

property saveMissingPlurals

saveMissingPlurals?: boolean;

• Calls save missing key function on backend if key not found also for plural forms. false

property saveMissingTo

saveMissingTo?: 'current' | 'all' | 'fallback';

• 'fallback'

property supportedLngs

supportedLngs?: false | readonly string[];

• Array of allowed languages false

property updateMissing

updateMissing?: boolean;

• Experimental: enable to update default values using the saveMissing (Works only if defaultValue different from translated value. Only useful on initial development or when keeping code as source of truth not changing values outside of code. Only supported if backend supports it already) false

method overloadTranslationOptionHandler

overloadTranslationOptionHandler: (args: string[]) => TOptions;

• Sets defaultValue args => ({ defaultValue: args[1] })

method parseMissingKeyHandler

parseMissingKeyHandler: (
    key: string,
    defaultValue?: string,
    options?: any
) => any;

• Receives a key that was not found in t() and returns a value, that will be returned by t() noop

method returnedObjectHandler

returnedObjectHandler: (key: string, value: string, options: any) => void;

• Gets called if object was passed in as key but returnObjects was set to false noop

property alwaysFormat

alwaysFormat?: boolean;

• Always format interpolated values. false

property defaultVariables

defaultVariables?: { [index: string]: any };

• Global variables to use in interpolation replacements undefined

property escapeValue

escapeValue?: boolean;

• Escape passed in values to avoid xss injection true

property formatSeparator

formatSeparator?: string;

• Used to separate format from interpolation value ','

property maxReplaces

maxReplaces?: number;

• After how many interpolation runs to break out before throwing a stack overflow 1000

property nestingOptionsSeparator

nestingOptionsSeparator?: string;

• Separates options from key ','

property nestingPrefix

nestingPrefix?: string;

• Prefix for nesting '$t('

property nestingPrefixEscaped

nestingPrefixEscaped?: string;

• Escaped prefix for nesting (regexSafe) undefined

property nestingSuffix

nestingSuffix?: string;

• Suffix for nesting ')'

property nestingSuffixEscaped

nestingSuffixEscaped?: string;

• Escaped suffix for nesting (regexSafe) undefined

property prefix

prefix?: string;

• Prefix for interpolation '{{'

property prefixEscaped

prefixEscaped?: string;

• Escaped prefix for interpolation (regexSafe) undefined

property skipOnVariables

skipOnVariables?: boolean;

• If true, it will skip to interpolate the variables true

property suffix

suffix?: string;

• Suffix for interpolation '}}'

property suffixEscaped

suffixEscaped?: string;

• Escaped suffix for interpolation (regexSafe) undefined

property unescapePrefix

unescapePrefix?: string;

• Prefix to unescaped mode '-'

property unescapeSuffix

unescapeSuffix?: string;

• Suffix to unescaped mode undefined

property useRawValueToEscape

useRawValueToEscape?: boolean;

• If true, then value passed into escape function is not casted to string, use with custom escape function that does its own type check false

method escape

escape: (str: string) => string;

• Escape function str => str

method init

init: (options: InterpolationOptions, reset: boolean) => undefined;

method interpolate

interpolate: (
    str: string,
    data: object,
    lng: string,
    options: InterpolationOptions
) => string;

method nest

nest: (
    str: string,
    fc: (...args: any[]) => any,
    options: InterpolationOptions
) => string;

method reset

reset: () => undefined;

method resetRegExp

resetRegExp: () => undefined;

property async

async: true;

• Set to true to enable async detection

property type

type: 'languageDetector';

method cacheUserLanguage

cacheUserLanguage: (lng: string) => void | Promise<void>;

method detect

detect: (
    callback: (lng: string | readonly string[] | undefined) => void | undefined
) => void | Promise<string | readonly string[] | undefined>;

• Must call callback passing detected language or return a Promise

method init

init: (
    services: Services,
    detectorOptions: object,
    i18nextOptions: InitOptions
) => void;

property type

type: 'languageDetector';

method cacheUserLanguage

cacheUserLanguage: (lng: string) => void;

method detect

detect: () => string | readonly string[] | undefined;

• Must return detected language

method init

init: (
    services: Services,
    detectorOptions: object,
    i18nextOptions: InitOptions
) => void;

property type

type: 'logger';

method error

error: (...args: any[]) => void;

method log

log: (...args: any[]) => void;

method warn

warn: (...args: any[]) => void;

property type

type: ModuleType;

property backend

backend?: BackendModule;

property external

external: ThirdPartyModule[];

property formatter

formatter?: FormatterModule;

property i18nFormat

i18nFormat?: I18nFormatModule;

property languageDetector

languageDetector?: LanguageDetectorModule | LanguageDetectorAsyncModule;

property logger

logger?: LoggerModule;

construct signature

new (...args: any[]): T;

property type

type: T['type'];

property name

name: string;

• Unique name

property type

type: 'postProcessor';

method process

process: (
    value: string,
    key: string | string[],
    options: TOptions,
    translator: any
) => string;

property bindI18n

bindI18n?: string | false;

• Set which events trigger a re-render, can be set to false or string of events 'languageChanged'

property bindI18nStore

bindI18nStore?: string | false;

• Set which events on store trigger a re-render, can be set to false or string of events ''

property defaultTransParent

defaultTransParent?: string;

• Set it to the default parent element created by the Trans component. 'div'

property keyPrefix

keyPrefix?: string | (($: any) => any);

• Optional keyPrefix that will be automatically applied to returned t function in useTranslation for example. Accepts a string or a selector function (e.g. $ => $.deeply.nested). undefined

property nsMode

nsMode?: 'default' | 'fallback';

• Set it to fallback to let passed namespaces to translated hoc act as fallbacks 'default'

property transDefaultProps

transDefaultProps?: {
    tOptions?: TOptions;
    values?: object;
    shouldUnescape?: boolean;
    components?: readonly unknown[] | { readonly [tagName: string]: unknown }; // Use `unknown` (or `any`) to be permissive without importing React.
};

• Default props to apply to all Trans components. Component-level props will override these defaults.

property transEmptyNodeValue

transEmptyNodeValue?: string;

• Set fallback value for Trans components without children undefined

property transKeepBasicHtmlNodesFor

transKeepBasicHtmlNodesFor?: readonly string[];

• Which nodes not to convert in defaultValue generation in the Trans component. ['br', 'strong', 'i', 'p']

property transSupportBasicHtmlNodes

transSupportBasicHtmlNodes?: boolean;

• Convert eg. found in translations to a react component of type br true

property transWrapTextNodes

transWrapTextNodes?: string;

• Wrap text nodes in a user-specified element. ''

property useSuspense

useSuspense?: boolean;

• Set it to false if you do not want to use Suspense true

method hashTransKey

hashTransKey: (
    defaultValue: TOptionsBase['defaultValue']
) => TOptionsBase['defaultValue'];

• Function to generate an i18nKey from the defaultValue (or Trans children) when no key is provided. By default, the defaultValue (Trans text) itself is used as the key. If you want to require keys for all translations, supply a function that always throws an error. undefined

method unescape

unescape: (str: string) => string;

• Unescape function by default it unescapes some basic html entities

index signature

[language: string]: ResourceLanguage;

index signature

[namespace: string]: ResourceKey;

call signature

(translations: Select<Source, Opts['context']>): Target;

property ns

ns?: Ns;

property backendConnector

backendConnector: any;

property formatter

formatter?: Formatter;

property i18nFormat

i18nFormat: any;

property interpolator

interpolator: Interpolator;

property languageDetector

languageDetector: any;

property languageUtils

languageUtils: any;

property logger

logger: any;

property pluralResolver

pluralResolver: any;

property resourceStore

resourceStore: ResourceStore;

call signature

call signature

call signature

property type

type: '3rdParty';

method init

init: (i18next: i18n) => void;

property context

context?: unknown;

• Used for contexts (eg. male\female)

property count

count?: number;

• Count value used for plurals

property defaultValue

defaultValue?: unknown;

• Default value to return if a translation was not found

property fallbackLng

fallbackLng?: false | FallbackLng;

• Override language to lookup key if not found see fallbacks for details

property interpolation

interpolation?: InterpolationOptions;

• Override interpolation options