Current File : /home/tjamichg/cursos.tjamich.gob.mx/web/assets/i18next/index.d.ts
export interface FallbackLngObjList {
[language: string]: string[];
}
export type FallbackLng = string | string[] | FallbackLngObjList;
export type FormatFunction = (value: any, format?: string, lng?: string) => string;
export interface InterpolationOptions {
/**
* Format function see formatting for details
* @default noop
*/
format?: FormatFunction;
/**
* Used to separate format from interpolation value
* @default ','
*/
formatSeparator?: string;
/**
* Escape function
* @default str => str
*/
escape?(str: string): string;
/**
* Escape passed in values to avoid xss injection
* @default true
*/
escapeValue?: 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
* @default false
*/
useRawValueToEscape?: boolean;
/**
* Prefix for interpolation
* @default '{{'
*/
prefix?: string;
/**
* Suffix for interpolation
* @default '}}'
*/
suffix?: string;
/**
* Escaped prefix for interpolation (regexSafe)
* @default undefined
*/
prefixEscaped?: string;
/**
* Escaped suffix for interpolation (regexSafe)
* @default undefined
*/
suffixEscaped?: string;
/**
* Suffix to unescaped mode
* @default undefined
*/
unescapeSuffix?: string;
/**
* Prefix to unescaped mode
* @default '-'
*/
unescapePrefix?: string;
/**
* Prefix for nesting
* @default '$t('
*/
nestingPrefix?: string;
/**
* Suffix for nesting
* @default ')'
*/
nestingSuffix?: string;
/**
* Escaped prefix for nesting (regexSafe)
* @default undefined
*/
nestingPrefixEscaped?: string;
/**
* Escaped suffix for nesting (regexSafe)
* @default undefined
*/
nestingSuffixEscaped?: string;
/**
* Separates options from key
* @default ','
*/
nestingOptionsSeparator?: string;
/**
* Global variables to use in interpolation replacements
* @default undefined
*/
defaultVariables?: { [index: string]: any };
/**
* After how many interpolation runs to break out before throwing a stack overflow
* @default 1000
*/
maxReplaces?: number;
}
export interface ReactOptions {
/**
* Set to true if you like to wait for loaded in every translated hoc
* @default false
*/
wait?: boolean;
/**
* Set it to fallback to let passed namespaces to translated hoc act as fallbacks
* @default 'default'
*/
nsMode?: 'default' | 'fallback';
/**
* Set it to the default parent element created by the Trans component.
* @default 'div'
*/
defaultTransParent?: string;
/**
* Set which events trigger a re-render, can be set to false or string of events
* @default 'languageChanged loaded'
*/
bindI18n?: string | false;
/**
* Set which events on store trigger a re-render, can be set to false or string of events
* @default 'added removed'
*/
bindStore?: string | false;
/**
* Set fallback value for Trans components without children
* @default undefined
*/
transEmptyNodeValue?: string;
/**
* Set it to false if you do not want to use Suspense
* @default true
*/
useSuspense?: boolean;
/**
* 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.
* @default undefined
*/
hashTransKey?(defaultValue: TOptionsBase['defaultValue']): TOptionsBase['defaultValue'];
/**
* Convert eg. <br/> found in translations to a react component of type br
* @default true
*/
transSupportBasicHtmlNodes?: boolean;
/**
* Which nodes not to convert in defaultValue generation in the Trans component.
* @default ['br', 'strong', 'i', 'p']
*/
transKeepBasicHtmlNodesFor?: string[];
}
export interface InitOptions {
/**
* Logs info level to console output. Helps finding issues with loading not working.
* @default false
*/
debug?: boolean;
/**
* Resources to initialize with (if not using loading or not appending using addResourceBundle)
* @default undefined
*/
resources?: Resource;
/**
* Allow initializing with bundled resources while using a backend to load non bundled ones.
* @default false
*/
partialBundledLanguages?: boolean;
/**
* Language to use (overrides language detection)
* @default undefined
*/
lng?: string;
/**
* Language to use if translations in user language are not available.
* @default 'dev'
*/
fallbackLng?: false | FallbackLng;
/**
* DEPRECATED use supportedLngs
* @default false
*/
whitelist?: false | string[];
/**
* DEPRECTADED use nonExplicitSupportedLngs
* @default false
*/
nonExplicitWhiteliest?: boolean;
/**
* Array of allowed languages
* @default false
*/
supportedLngs?: false | string[];
/**
* If true will pass eg. en-US if finding en in supportedLngs
* @default false
*/
nonExplicitSupportedLngs?: boolean;
/**
* Language codes to lookup, given set language is
* 'en-US': 'all' --> ['en-US', 'en', 'dev'],
* 'currentOnly' --> 'en-US',
* 'languageOnly' --> 'en'
* @default 'all'
*/
load?: 'all' | 'currentOnly' | 'languageOnly';
/**
* Array of languages to preload. Important on server-side to assert translations are loaded before rendering views.
* @default false
*/
preload?: false | string[];
/**
* Language will be lowercased eg. en-US --> en-us
* @default false
*/
lowerCaseLng?: boolean;
/**
* Language will be lowercased EN --> en while leaving full locales like en-US
* @default false
*/
cleanCode?: boolean;
/**
* String or array of namespaces to load
* @default 'translation'
*/
ns?: string | string[];
/**
* Default namespace used if not passed to translation function
* @default 'translation'
*/
defaultNS?: string;
/**
* String or array of namespaces to lookup key if not found in given namespace.
* @default false
*/
fallbackNS?: false | string | string[];
/**
* Calls save missing key function on backend if key not found
* @default false
*/
saveMissing?: 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)
* @default false
*/
updateMissing?: boolean;
/**
* @default 'fallback'
*/
saveMissingTo?: 'current' | 'all' | 'fallback';
/**
* Used for custom missing key handling (needs saveMissing set to true!)
* @default false
*/
missingKeyHandler?:
| false
| ((lngs: string[], ns: string, key: string, fallbackValue: string) => void);
/**
* Receives a key that was not found in `t()` and returns a value, that will be returned by `t()`
* @default noop
*/
parseMissingKeyHandler?(key: string): any;
/**
* Appends namespace to missing key
* @default false
*/
appendNamespaceToMissingKey?: boolean;
/**
* Gets called in case a interpolation value is undefined. This method will not be called if the value is empty string or null
* @default noop
*/
missingInterpolationHandler?: (text: string, value: any, options: InitOptions) => any;
/**
* Will use 'plural' as suffix for languages only having 1 plural form, setting it to false will suffix all with numbers
* @default true
*/
simplifyPluralSuffix?: boolean;
/**
* String or array of postProcessors to apply per default
* @default false
*/
postProcess?: false | string | string[];
/**
* passthrough the resolved object including 'usedNS', 'usedLang' etc into options object of postprocessors as 'i18nResolved' property
* @default false
*/
postProcessPassResolved?: boolean;
/**
* Allows null values as valid translation
* @default true
*/
returnNull?: boolean;
/**
* Allows empty string as valid translation
* @default true
*/
returnEmptyString?: boolean;
/**
* Allows objects as valid translation result
* @default false
*/
returnObjects?: boolean;
/**
* Gets called if object was passed in as key but returnObjects was set to false
* @default noop
*/
returnedObjectHandler?(key: string, value: string, options: any): void;
/**
* Char, eg. '\n' that arrays will be joined by
* @default false
*/
joinArrays?: false | string;
/**
* Sets defaultValue
* @default args => ({ defaultValue: args[1] })
*/
overloadTranslationOptionHandler?(args: string[]): TOptions;
/**
* @see https://www.i18next.com/interpolation.html
*/
interpolation?: InterpolationOptions;
/**
* Options for language detection - check documentation of plugin
* @default undefined
*/
detection?: object;
/**
* Options for backend - check documentation of plugin
* @default undefined
*/
backend?: object;
/**
* Options for cache layer - check documentation of plugin
* @default undefined
*/
cache?: object;
/**
* Options for i18n message format - check documentation of plugin
* @default undefined
*/
i18nFormat?: object;
/**
* Options for react - check documentation of plugin
* @default undefined
*/
react?: ReactOptions;
/**
* 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.
* @default true
*/
initImmediate?: boolean;
/**
* Char to separate keys
* @default '.'
*/
keySeparator?: false | string;
/**
* Char to split namespace from key
* @default ':'
*/
nsSeparator?: false | string;
/**
* Char to split plural from key
* @default '_'
*/
pluralSeparator?: string;
/**
* Char to split context from key
* @default '_'
*/
contextSeparator?: string;
/**
* Prefixes the namespace to the returned key when using `cimode`
* @default false
*/
appendNamespaceToCIMode?: boolean;
/**
* Compatibility JSON version
* @default 'v3'
*/
compatibilityJSON?: 'v1' | 'v2' | 'v3';
/**
* Options for https://github.com/locize/locize-editor
* @default undefined
*/
editor?: {
/**
* Enable on init without the need of adding querystring locize=true
* @default false
*/
enabled?: boolean;
/**
* If set to false you will need to open the editor via API
* @default true
*/
autoOpen?: boolean;
/**
* Enable by adding querystring locize=true; can be set to another value or turned off by setting to false
* @default 'locize'
*/
enableByQS?: string | false;
/**
* Turn on/off by pressing key combination. Combine this with `toggleKeyCode`
* @default 'ctrlKey'
*/
toggleKeyModifier?: 'ctrlKey' | 'metaKey' | 'altKey' | 'shiftKey';
/**
* Turn on/off by pressing key combination. Combine this with `toggleKeyModifier`
* @default 24 (x)
*/
toggleKeyCode?: number;
/**
* Use lng in editor taken from query string, eg. if running with lng=cimode (i18next, locize)
* @default 'useLng'
*/
lngOverrideQS?: string;
/**
* Use lng in editor, eg. if running with lng=cimode (i18next, locize)
* @default null
*/
lngOverride?: string | null;
/**
* How the editor will open.
* Setting to window will open a new window/tab instead
* @default 'iframe'
*/
mode?: 'iframe' | 'window';
/**
* Styles to adapt layout in iframe mode to your website layout.
* This will add a style to the `<iframe>`
* @default 'z-index: 2000; position: fixed; top: 0; right: 0; bottom: 0; width: 600px; box-shadow: -3px 0 5px 0 rgba(0,0,0,0.5);'
*/
iframeContainerStyle?: string;
/**
* Styles to adapt layout in iframe mode to your website layout.
* This will add a style to the parent of `<iframe>`
* @default 'height: 100%; width: 600px; border: none;'
*/
iframeStyle?: string;
/**
* Styles to adapt layout in iframe mode to your website layout.
* This will add a style to `<body>`
* @default 'margin-right: 605px;'
*/
bodyStyle?: string;
/**
* Handle when locize saved the edited translations, eg. reload website
* @default noop
*/
onEditorSaved?: (lng: null, ns: string | string[]) => void;
};
/**
* Options for https://github.com/locize/locize-lastused
* @default undefined
*/
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?: string[];
};
}
export interface TOptionsBase {
/**
* Default value to return if a translation was not found
*/
defaultValue?: any;
/**
* Count value used for plurals
*/
count?: number;
/**
* Used for contexts (eg. male\female)
*/
context?: any;
/**
* Object with vars for interpolation - or put them directly in options
*/
replace?: any;
/**
* Override language to use
*/
lng?: string;
/**
* Override languages to use
*/
lngs?: string[];
/**
* Override language to lookup key if not found see fallbacks for details
*/
fallbackLng?: FallbackLng;
/**
* Override namespaces (string or array)
*/
ns?: string | string[];
/**
* Override char to separate keys
*/
keySeparator?: false | string;
/**
* Override char to split namespace from key
*/
nsSeparator?: false | string;
/**
* Accessing an object not a translation string (can be set globally too)
*/
returnObjects?: boolean;
/**
* Char, eg. '\n' that arrays will be joined by (can be set globally too)
*/
joinArrays?: string;
/**
* String or array of postProcessors to apply see interval plurals as a sample
*/
postProcess?: string | string[];
/**
* Override interpolation options
*/
interpolation?: InterpolationOptions;
}
/**
* indexer that is open to any value
*/
export type StringMap = { [key: string]: any };
/**
* Options that allow open ended values for interpolation unless type is provided.
*/
export type TOptions<TInterpolationMap extends object = StringMap> = TOptionsBase &
TInterpolationMap;
export type Callback = (error: any, t: TFunction) => void;
/**
* Uses similar args as the t function and returns true if a key exists.
*/
export interface ExistsFunction<
TKeys extends string = string,
TInterpolationMap extends object = StringMap
> {
(key: TKeys | TKeys[], options?: TOptions<TInterpolationMap>): boolean;
}
export interface WithT {
// Expose parameterized t in the i18next interface hierarchy
t: TFunction;
}
export type TFunctionResult = string | object | Array<string | object> | undefined | null;
export type TFunctionKeys = string | TemplateStringsArray;
export interface TFunction {
// basic usage
<
TResult extends TFunctionResult = string,
TKeys extends TFunctionKeys = string,
TInterpolationMap extends object = StringMap
>(
key: TKeys | TKeys[],
options?: TOptions<TInterpolationMap> | string,
): TResult;
// overloaded usage
<
TResult extends TFunctionResult = string,
TKeys extends TFunctionKeys = string,
TInterpolationMap extends object = StringMap
>(
key: TKeys | TKeys[],
defaultValue?: string,
options?: TOptions<TInterpolationMap> | string,
): TResult;
}
export interface Resource {
[language: string]: ResourceLanguage;
}
export interface ResourceLanguage {
[namespace: string]: ResourceKey;
}
export type ResourceKey =
| string
| {
[key: string]: any;
};
export interface Interpolator {
init(options: InterpolationOptions, reset: boolean): undefined;
reset(): undefined;
resetRegExp(): undefined;
interpolate(str: string, data: object, lng: string, options: InterpolationOptions): string;
nest(str: string, fc: (...args: any[]) => any, options: InterpolationOptions): string;
}
export class ResourceStore {
constructor(data: Resource, options: InitOptions);
public data: Resource;
public options: InitOptions;
/**
* Gets fired when resources got added or removed
*/
on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
}
export interface Services {
backendConnector: any;
i18nFormat: any;
interpolator: Interpolator;
languageDetector: any;
languageUtils: any;
logger: any;
pluralResolver: any;
resourceStore: ResourceStore;
}
export interface Module {
type: 'backend' | 'logger' | 'languageDetector' | 'postProcessor' | 'i18nFormat' | '3rdParty';
}
export type CallbackError = Error | null | undefined;
export type ReadCallback = (err: CallbackError, data: ResourceKey | boolean) => void;
export type MultiReadCallback = (err: CallbackError, data: Resource) => void;
/**
* Used to load data for i18next.
* Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
* For singleton set property `type` to `'backend'` For a prototype constructor set static property.
*/
export interface BackendModule<TOptions = object> extends Module {
type: 'backend';
init(services: Services, backendOptions: TOptions, i18nextOptions: InitOptions): void;
read(language: string, namespace: string, callback: ReadCallback): void;
/** Save the missing translation */
create(languages: string[], namespace: string, key: string, fallbackValue: string): void;
/** Load multiple languages and namespaces. For backends supporting multiple resources loading */
readMulti?(languages: string[], namespaces: string[], callback: ReadCallback): void;
/** Store the translation. For backends acting as cache layer */
save?(language: string, namespace: string, data: ResourceLanguage): void;
}
/**
* Used to detect language in user land.
* Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
* For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
*/
export interface LanguageDetectorModule extends Module {
type: 'languageDetector';
init(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
/** Must return detected language */
detect(): string | undefined;
cacheUserLanguage(lng: string): void;
}
/**
* Used to detect language in user land.
* Can be provided as a singleton or as a prototype constructor (preferred for supporting multiple instances of i18next).
* For singleton set property `type` to `'languageDetector'` For a prototype constructor set static property.
*/
export interface LanguageDetectorAsyncModule extends Module {
type: 'languageDetector';
/** Set to true to enable async detection */
async: true;
init(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
/** Must call callback passing detected language */
detect(callback: (lng: string) => void): void;
cacheUserLanguage(lng: string): void;
}
/**
* Used to extend or manipulate the translated values before returning them in `t` function.
* Need to be a singleton object.
*/
export interface PostProcessorModule extends Module {
/** Unique name */
name: string;
type: 'postProcessor';
process(value: string, key: string, options: TOptions, translator: any): string;
}
/**
* Override the built-in console logger.
* Do not need to be a prototype function.
*/
export interface LoggerModule extends Module {
type: 'logger';
log(...args: any[]): void;
warn(...args: any[]): void;
error(...args: any[]): void;
}
export interface I18nFormatModule extends Module {
type: 'i18nFormat';
}
export interface ThirdPartyModule extends Module {
type: '3rdParty';
init(i18next: i18n): void;
}
export interface Modules {
backend?: BackendModule;
logger?: LoggerModule;
languageDetector?: LanguageDetectorModule | LanguageDetectorAsyncModule;
i18nFormat?: I18nFormatModule;
external: ThirdPartyModule[];
}
// helper to identify class https://stackoverflow.com/a/45983481/2363935
export type Newable<T> = { new (...args: any[]): T };
export interface i18n {
// Expose parameterized t in the i18next interface hierarchy
t: TFunction;
/**
* 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.
*
* @param options - Initial options.
* @param callback - will be called after all translations were loaded or with an error when failed (in case of using a backend).
*/
init(callback?: Callback): Promise<TFunction>;
init(options: InitOptions, callback?: Callback): Promise<TFunction>;
loadResources(callback?: (err: any) => void): void;
/**
* 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.
*
* Accepts a class or object
*/
use<T extends Module>(
module: T | Newable<T> | ThirdPartyModule[] | Newable<ThirdPartyModule>[],
): i18n;
/**
* List of modules used
*/
modules: Modules;
/**
* Internal container for all used plugins and implementation details like languageUtils, pluralResolvers, etc.
*/
services: Services;
/**
* Internal container for translation resources
*/
store: ResourceStore;
/**
* Uses similar args as the t function and returns true if a key exists.
*/
exists: ExistsFunction;
/**
* Returns a resource data by language.
*/
getDataByLanguage(lng: string): { translation: { [key: string]: string } };
/**
* 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.
*/
getFixedT(lng: string | string[], ns?: string | string[]): TFunction;
getFixedT(lng: null, ns: string | string[]): TFunction;
/**
* Changes the language. The callback will be called as soon translations were loaded or an error occurs while loading.
* HINT: For easy testing - setting lng to 'cimode' will set t function to always return the key.
*/
changeLanguage(lng: string, callback?: Callback): Promise<TFunction>;
/**
* Is set to the current detected or set language.
* If you need the primary used language depending on your configuration (supportedLngs, load) you will prefer using i18next.languages[0].
*/
language: string;
/**
* Is set to an array of language-codes that will be used it order to lookup the translation value.
*/
languages: string[];
/**
* Loads additional namespaces not defined in init options.
*/
loadNamespaces(ns: string | string[], callback?: Callback): Promise<void>;
/**
* Loads additional languages not defined in init options (preload).
*/
loadLanguages(lngs: string | string[], callback?: Callback): Promise<void>;
/**
* Reloads resources on given state. Optionally you can pass an array of languages and namespaces as params if you don't want to reload all.
*/
reloadResources(
lngs?: string | string[],
ns?: string | string[],
callback?: () => void,
): Promise<void>;
reloadResources(lngs: null, ns: string | string[], callback?: () => void): Promise<void>;
/**
* Changes the default namespace.
*/
setDefaultNamespace(ns: string): void;
/**
* Returns rtl or ltr depending on languages read direction.
*/
dir(lng?: string): 'ltr' | 'rtl';
/**
* Exposes interpolation.format function added on init.
*/
format: FormatFunction;
/**
* Will return a new i18next instance.
* Please read the options page for details on configuration options.
* Providing a callback will automatically call init.
* The callback will be called after all translations were loaded or with an error when failed (in case of using a backend).
*/
createInstance(options?: InitOptions, callback?: Callback): i18n;
/**
* Creates a clone of the current instance. Shares store, plugins and initial configuration.
* Can be used to create an instance sharing storage but being independent on set language or namespaces.
*/
cloneInstance(options?: InitOptions, callback?: Callback): i18n;
/**
* Gets fired after initialization.
*/
on(event: 'initialized', callback: (options: InitOptions) => void): void;
/**
* Gets fired on loaded resources.
*/
on(event: 'loaded', callback: (loaded: boolean) => void): void;
/**
* Gets fired if loading resources failed.
*/
on(event: 'failedLoading', callback: (lng: string, ns: string, msg: string) => void): void;
/**
* Gets fired on accessing a key not existing.
*/
on(
event: 'missingKey',
callback: (lngs: string[], namespace: string, key: string, res: string) => void,
): void;
/**
* Gets fired when resources got added or removed.
*/
on(event: 'added' | 'removed', callback: (lng: string, ns: string) => void): void;
/**
* Gets fired when changeLanguage got called.
*/
on(event: 'languageChanged', callback: (lng: string) => void): void;
/**
* Event listener
*/
on(event: string, listener: (...args: any[]) => void): void;
/**
* Remove event listener
*/
off(event: string, listener: (...args: any[]) => void): void;
/**
* Gets one value by given key.
*/
getResource(lng: string, ns: string, key: string, options?: { keySeparator?: string }): any;
/**
* Adds one key/value.
*/
addResource(
lng: string,
ns: string,
key: string,
value: string,
options?: { keySeparator?: string; silent?: boolean },
): void;
/**
* Adds multiple key/values.
*/
addResources(lng: string, ns: string, resources: any): void;
/**
* Adds a complete bundle.
* Setting deep param to true will extend existing translations in that file.
* Setting overwrite to true it will overwrite existing translations in that file.
*/
addResourceBundle(
lng: string,
ns: string,
resources: any,
deep?: boolean,
overwrite?: boolean,
): void;
/**
* Checks if a resource bundle exists.
*/
hasResourceBundle(lng: string, ns: string): boolean;
/**
* Returns a resource bundle.
*/
getResourceBundle(lng: string, ns: string): any;
/**
* Removes an existing bundle.
*/
removeResourceBundle(lng: string, ns: string): void;
/**
* Current options
*/
options: InitOptions;
/**
* Is initialized
*/
isInitialized: boolean;
/**
* Emit event
*/
emit(eventName: string): void;
}
declare const i18next: i18n;
export default i18next;
Mini Shell