@chatsdk-dev/elements 0.0.1 → 0.1.2

package/dist/i18n/i18next.d.ts

@@ -1,11 +1,1383 @@
-declare module "i18next" {
-  interface CustomTypeOptions {
-    formality?: "formal" | "informal";
-  }
-  interface InitOptions {
-    formality?: "formal" | "informal";
-  }
-  interface CustomInstanceExtensions {
-    formality?: "formal" | "informal";
-  }
+//#region ../../node_modules/.pnpm/i18next@25.10.3_typescript@5.9.3/node_modules/i18next/typescript/helpers.d.ts
+// Types
+type $Dictionary<T = unknown> = {
+  [key: string]: T;
+};
+type $SpecialObject = object | Array<string | object>;
+// Types Operators
+type $Prune<T> = never | { [K in keyof T as [keyof T[K]] extends [never] ? never : K]: T[K] };
+/** All the way down. */
+interface $Turtles {
+  [x: string]: $Turtles;
 }
+type $MergeBy<T, K> = Omit<T, keyof K> & K;
+type $OmitArrayKeys<Arr> = Arr extends readonly any[] ? Omit<Arr, keyof any[]> : Arr;
+type $PreservedValue<Value, Fallback> = [Value] extends [never] ? Fallback : Value;
+type $NormalizeIntoArray<T extends unknown | readonly unknown[]> = T extends readonly unknown[] ? T : [T];
+/**
+ * @typeParam T
+ * @example
+ * ```
+ * $UnionToIntersection<{foo: {bar: string} | {asd: boolean}}> = {foo: {bar: string} & {asd: boolean}}
+ * ```
+ *
+ * @see https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type
+ */
+type $UnionToIntersection<T> = (T extends unknown ? (k: T) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * @typeParam TPath union of strings
+ * @typeParam TValue value of the record
+ * @example
+ * ```
+ * $StringKeyPathToRecord<'foo.bar' | 'asd'> = {foo: {bar: string} | {asd: boolean}}
+ * ```
+ */
+type $StringKeyPathToRecordUnion<TPath extends string, TValue> = TPath extends `${infer TKey}.${infer Rest}` ? { [Key in TKey]: $StringKeyPathToRecord<Rest, TValue> } : { [Key in TPath]: TValue };
+/**
+ * Used to intersect output of {@link $StringKeyPathToRecordUnion}
+ *
+ * @typeParam TPath union of strings
+ * @typeParam TValue value of the record
+ * @example
+ * ```
+ * $StringKeyPathToRecord<'foo.bar' | 'asd'> = {foo: {bar: string} & {asd: boolean}}
+ * ```
+ */
+type $StringKeyPathToRecord<TPath extends string, TValue> = $UnionToIntersection<$StringKeyPathToRecordUnion<TPath, TValue>>;
+/**
+ * We could use NoInfer typescript build-in utility,
+ * however this project still supports ts < 5.4.
+ *
+ * @see https://github.com/millsp/ts-toolbelt/blob/master/sources/Function/NoInfer.ts
+ */
+type $NoInfer<A> = [A][A extends any ? 0 : never];
+//#endregion
+//#region ../../node_modules/.pnpm/i18next@25.10.3_typescript@5.9.3/node_modules/i18next/typescript/options.d.ts
+/**
+ * This interface can be augmented by users to add types to `i18next` default TypeOptions.
+ *
+ * Usage:
+ * ```ts
+ * // i18next.d.ts
+ * import 'i18next';
+ * declare module 'i18next' {
+ *   interface CustomTypeOptions {
+ *     defaultNS: 'custom';
+ *     returnNull: false;
+ *     returnObjects: false;
+ *     nsSeparator: ':';
+ *     keySeparator: '.';
+ *     compatibilityJSON: 'v4';
+ *     allowObjectInHTMLChildren: false;
+ *     resources: {
+ *       custom: {
+ *         foo: 'foo';
+ *       };
+ *     };
+ *   }
+ * }
+ * ```
+ */
+interface CustomTypeOptions {}
+/**
+ * This interface can be augmented by users to add types to `i18next` default PluginOptions.
+ */
+interface CustomPluginOptions {}
+type TypeOptions = $MergeBy<{
+  /** @see {InitOptions.returnNull} */returnNull: false; /** @see {InitOptions.returnEmptyString} */
+  returnEmptyString: true; /** @see {InitOptions.returnObjects} */
+  returnObjects: false; /** @see {InitOptions.keySeparator} */
+  keySeparator: '.'; /** @see {InitOptions.nsSeparator} */
+  nsSeparator: ':'; /** @see {InitOptions.pluralSeparator} */
+  pluralSeparator: '_'; /** @see {InitOptions.contextSeparator} */
+  contextSeparator: '_'; /** @see {InitOptions.defaultNS} */
+  defaultNS: 'translation'; /** @see {InitOptions.fallbackNS} */
+  fallbackNS: false; /** @see {InitOptions.compatibilityJSON} */
+  compatibilityJSON: 'v4'; /** @see {InitOptions.resources} */
+  resources: object;
+  /**
+   * Flag that allows HTML elements to receive objects. This is only useful for React applications
+   * where you pass objects to HTML elements so they can be replaced to their respective interpolation
+   * values (mostly with Trans component)
+   */
+  allowObjectInHTMLChildren: false;
+  /**
+   * Flag that enables strict key checking even if a `defaultValue` has been provided.
+   * This ensures all calls of `t` function don't accidentally use implicitly missing keys.
+   */
+  strictKeyChecks: false;
+  /**
+   * Prefix for interpolation
+   */
+  interpolationPrefix: '{{';
+  /**
+   * Suffix for interpolation
+   */
+  interpolationSuffix: '}}'; /** @see {InterpolationOptions.unescapePrefix} */
+  unescapePrefix: '-'; /** @see {InterpolationOptions.unescapeSuffix} */
+  unescapeSuffix: '';
+  /**
+   * Use a proxy-based selector to select a translation.
+   *
+   * Enables features like go-to definition, and better DX/faster autocompletion
+   * for TypeScript developers.
+   *
+   * If you're working with an especially large set of translations and aren't
+   * using context, you set `enableSelector` to `"optimize"` and i18next won't do
+   * any type-level processing of your translations at all.
+   *
+   * With `enableSelector` set to `"optimize"`, i18next is capable of supporting
+   * arbitrarily large/deep translation sets without causing any IDE slowdown
+   * whatsoever.
+   *
+   * @default false
+   */
+  enableSelector: false;
+  /**
+   * Maps interpolation format specifiers to their expected value types.
+   *
+   * By default, i18next infers types from built-in formatter names:
+   * - `number`, `currency` → `number`
+   * - `datetime` → `Date`
+   * - `relativetime` → `number`
+   * - `list` → `readonly string[]`
+   * - No format specifier → `string`
+   *
+   * Use this option to add mappings for custom formatters or to override
+   * the built-in defaults.
+   *
+   * @default {} (empty — built-in defaults apply)
+   *
+   * @example
+   * ```ts
+   * interface CustomTypeOptions {
+   *   interpolationFormatTypeMap: {
+   *     // custom formatter
+   *     uppercase: string;
+   *     // override built-in
+   *     currency: string;
+   *   };
+   * }
+   * ```
+   */
+  interpolationFormatTypeMap: {};
+}, CustomTypeOptions>;
+type PluginOptions<T> = $MergeBy<{
+  /**
+   * Options for language detection - check documentation of plugin
+   * @default undefined
+   */
+  detection?: object;
+  /**
+   * Options for backend - check documentation of plugin
+   * @default undefined
+   */
+  backend?: T;
+  /**
+   * 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;
+}, CustomPluginOptions>;
+type FormatFunction = (value: any, format?: string, lng?: string, options?: InterpolationOptions & $Dictionary<any>) => string;
+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;
+  /**
+   * Always format interpolated values.
+   * @default false
+   */
+  alwaysFormat?: boolean;
+  /**
+   * 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;
+  /**
+   * If true, it will skip to interpolate the variables
+   * @default true
+   */
+  skipOnVariables?: boolean;
+}
+interface FallbackLngObjList {
+  [language: string]: readonly string[];
+}
+type FallbackLng = string | readonly string[] | FallbackLngObjList | ((code: string) => string | readonly string[] | FallbackLngObjList);
+interface ReactOptions {
+  /**
+   * 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'
+   */
+  bindI18n?: string | false;
+  /**
+   * Set which events on store trigger a re-render, can be set to false or string of events
+   * @default ''
+   */
+  bindI18nStore?: 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?: readonly string[];
+  /**
+   * Wrap text nodes in a user-specified element.
+   * @default ''
+   */
+  transWrapTextNodes?: string;
+  /**
+   * Default props to apply to all Trans components.
+   * Component-level props will override these defaults.
+   */
+  transDefaultProps?: {
+    tOptions?: TOptions;
+    values?: object;
+    shouldUnescape?: boolean;
+    components?: readonly unknown[] | {
+      readonly [tagName: string]: unknown;
+    }; // Use `unknown` (or `any`) to be permissive without importing React.
+  };
+  /**
+   * 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`).
+   * @default undefined
+   */
+  keyPrefix?: string | (($: any) => any);
+  /**
+   * Unescape function
+   * by default it unescapes some basic html entities
+   */
+  unescape?(str: string): string;
+}
+type ResourceKey = string | {
+  [key: string]: any;
+};
+interface ResourceLanguage {
+  [namespace: string]: ResourceKey;
+}
+interface Resource {
+  [language: string]: ResourceLanguage;
+}
+interface InitOptions<T = object> extends PluginOptions<T> {
+  /**
+   * Logs info level to console output. Helps finding issues with loading not working.
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * Show support notice in console during initialization.
+   * @default true
+   */
+  showSupportNotice?: 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;
+  /**
+   * Array of allowed languages
+   * @default false
+   */
+  supportedLngs?: false | readonly 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 | readonly 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 | readonly string[];
+  /**
+   * Default namespace used if not passed to translation function
+   * @default 'translation'
+   */
+  defaultNS?: string | false | readonly string[];
+  /**
+   * String or array of namespaces to lookup key if not found in given namespace.
+   * @default false
+   */
+  fallbackNS?: false | string | readonly string[];
+  /**
+   * Calls save missing key function on backend if key not found.
+   * @default false
+   */
+  saveMissing?: boolean;
+  /**
+   * Calls save missing key function on backend if key not found also for plural forms.
+   * @default false
+   */
+  saveMissingPlurals?: 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 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.
+   * @default false
+   */
+  missingKeyNoValueFallbackToKey?: boolean;
+  /**
+   * Used for custom missing key handling (needs saveMissing set to true!)
+   * @default false
+   */
+  missingKeyHandler?: false | ((lngs: readonly string[], ns: string, key: string, fallbackValue: string, updateMissing: boolean, options: any) => 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, defaultValue?: string, options?: any): 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 | readonly 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 false
+   */
+  returnNull?: boolean;
+  /**
+   * Allows empty string as valid translation
+   * @default true
+   */
+  returnEmptyString?: boolean;
+  /**
+   * Allows objects as valid translation result
+   * @default false
+   */
+  returnObjects?: boolean;
+  /**
+   * Returns an object that includes information about the used language, namespace, key and value
+   * @default false
+   */
+  returnDetails?: 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/translation-function/interpolation
+   */
+  interpolation?: InterpolationOptions;
+  /**
+   * 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
+   */
+  initAsync?: boolean;
+  /**
+   * @deprecated Use initAsync instead.
+   */
+  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
+   * @warning only `v4` is available and supported by typescript
+   * @default 'v4'
+   */
+  compatibilityJSON?: 'v4';
+  /**
+   * 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?: readonly string[];
+  };
+  /**
+   * Automatically lookup for a flat key if a nested key is not found an vice-versa
+   * @default true
+   */
+  ignoreJSONStructure?: boolean;
+  /**
+   * 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.
+   * @default 10
+   */
+  maxParallelReads?: 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.
+   * @default 5
+   */
+  maxRetries?: 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.
+   * @default 350
+   */
+  retryTimeout?: number;
+  /**
+   * 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
+   * @default true
+   */
+  cacheInBuiltFormats?: boolean;
+}
+interface TOptionsBase {
+  /**
+   * Default value to return if a translation was not found
+   */
+  defaultValue?: unknown;
+  /**
+   * Count value used for plurals
+   */
+  count?: number;
+  /**
+   * Ordinal flag for ordinal plurals
+   */
+  ordinal?: boolean;
+  /**
+   * Used for contexts (eg. male\female)
+   */
+  context?: unknown;
+  /**
+   * Object with vars for interpolation - or put them directly in options
+   */
+  replace?: any;
+  /**
+   * Override language to use
+   */
+  lng?: string;
+  /**
+   * Override languages to use
+   */
+  lngs?: readonly string[];
+  /**
+   * Override language to lookup key if not found see fallbacks for details
+   */
+  fallbackLng?: false | FallbackLng;
+  /**
+   * Override namespaces (string or array)
+   */
+  ns?: Namespace;
+  /**
+   * 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;
+  /**
+   * Returns an object that includes information about the used language, namespace, key and value
+   */
+  returnDetails?: 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 | readonly string[];
+  /**
+   * Override interpolation options
+   */
+  interpolation?: InterpolationOptions;
+  /**
+   * Optional keyPrefix that will be applied to the key before resolving.
+   * Accepts a string or a selector function (e.g. `$ => $.deeply.nested`).
+   * Only supported on the TFunction returned by getFixedT().
+   */
+  keyPrefix?: string | (($: any) => any);
+}
+type TOptions<TInterpolationMap extends object = $Dictionary> = TOptionsBase & TInterpolationMap;
+type FlatNamespace = $PreservedValue<keyof TypeOptions['resources'], string>;
+type Namespace<T = FlatNamespace> = T | readonly T[];
+type DefaultNamespace = TypeOptions['defaultNS'];
+//#endregion
+//#region ../../node_modules/.pnpm/i18next@25.10.3_typescript@5.9.3/node_modules/i18next/typescript/t.d.ts
+/** @todo consider to replace {} with Record<string, never> */
+// Type Options
+type _ReturnObjects = TypeOptions['returnObjects'];
+type _ReturnEmptyString = TypeOptions['returnEmptyString'];
+type _ReturnNull = TypeOptions['returnNull'];
+type _KeySeparator = TypeOptions['keySeparator'];
+type _NsSeparator = TypeOptions['nsSeparator'];
+type _PluralSeparator = TypeOptions['pluralSeparator'];
+type _ContextSeparator = TypeOptions['contextSeparator'];
+type _FallbackNamespace = TypeOptions['fallbackNS'];
+type _Resources = TypeOptions['resources'];
+type _CompatibilityJSON = TypeOptions['compatibilityJSON'];
+type _InterpolationPrefix = TypeOptions['interpolationPrefix'];
+type _InterpolationSuffix = TypeOptions['interpolationSuffix'];
+type _UnescapePrefix = TypeOptions['unescapePrefix'];
+type _UnescapeSuffix = TypeOptions['unescapeSuffix'];
+type _StrictKeyChecks = TypeOptions['strictKeyChecks'];
+type _EnableSelector = TypeOptions['enableSelector'];
+type _InterpolationFormatTypeMap = TypeOptions['interpolationFormatTypeMap'];
+type $IsResourcesDefined = [keyof _Resources] extends [never] ? false : true;
+type $ValueIfResourcesDefined<Value, Fallback> = $IsResourcesDefined extends true ? Value : Fallback;
+type $FirstNamespace<Ns extends Namespace> = Ns extends readonly any[] ? Ns[0] : Ns;
+type Resources = $ValueIfResourcesDefined<_Resources, $Dictionary<string>>;
+type PluralSuffix = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+type WithOrWithoutPlural<Key> = _CompatibilityJSON extends 'v4' ? Key extends `${infer KeyWithoutOrdinalPlural}${_PluralSeparator}ordinal${_PluralSeparator}${PluralSuffix}` ? KeyWithoutOrdinalPlural | Key : Key extends `${infer KeyWithoutPlural}${_PluralSeparator}${PluralSuffix}` ? KeyWithoutPlural | Key : Key : Key;
+type JoinKeys<K1, K2> = `${K1 & string}${_KeySeparator}${K2 & string}`;
+type AppendNamespace<Ns, Keys> = `${Ns & string}${_NsSeparator}${Keys & string}`;
+type TrimSpaces<T extends string, Acc extends string = ''> = T extends `${infer Char}${infer Rest}` ? Char extends ' ' ? TrimSpaces<Rest, Acc> : TrimSpaces<Rest, `${Acc}${Char}`> : T extends '' ? Acc : never;
+interface Branded<Ns extends Namespace> {
+  $TFunctionBrand: $IsResourcesDefined extends true ? `${Ns extends readonly any[] ? Ns[0] : Ns}` : never;
+}
+/** ****************************************************
+ * Build all keys and key prefixes based on Resources *
+ ***************************************************** */
+type KeysBuilderWithReturnObjects<Res, Key = keyof Res> = Key extends keyof Res ? Res[Key] extends $Dictionary | readonly unknown[] ? JoinKeys<Key, WithOrWithoutPlural<keyof $OmitArrayKeys<Res[Key]>>> | JoinKeys<Key, KeysBuilderWithReturnObjects<Res[Key]>> : never : never;
+type KeysBuilderWithoutReturnObjects<Res, Key = keyof $OmitArrayKeys<Res>> = Key extends keyof Res ? Res[Key] extends $Dictionary | readonly unknown[] ? JoinKeys<Key, KeysBuilderWithoutReturnObjects<Res[Key]>> : Key : never;
+type KeysBuilder<Res, WithReturnObjects> = $IsResourcesDefined extends true ? WithReturnObjects extends true ? keyof Res | KeysBuilderWithReturnObjects<Res> : KeysBuilderWithoutReturnObjects<Res> : string;
+type KeysWithReturnObjects = { [Ns in FlatNamespace]: WithOrWithoutPlural<KeysBuilder<Resources[Ns], true>> };
+type KeysWithoutReturnObjects = { [Ns in FlatNamespace]: WithOrWithoutPlural<KeysBuilder<Resources[Ns], false>> };
+type ResourceKeys<WithReturnObjects = _ReturnObjects> = WithReturnObjects extends true ? KeysWithReturnObjects : KeysWithoutReturnObjects;
+/** **********************************************************************
+ * Parse t function keys based on the namespace, options and key prefix *
+ *********************************************************************** */
+type KeysByTOptions<TOpt extends TOptions> = TOpt['returnObjects'] extends true ? ResourceKeys<true> : ResourceKeys;
+type NsByTOptions<Ns extends Namespace, TOpt extends TOptions> = TOpt['ns'] extends Namespace ? TOpt['ns'] : Ns;
+type ParseKeysByKeyPrefix<Keys, KPrefix> = KPrefix extends string ? Keys extends `${KPrefix}${_KeySeparator}${infer Key}` ? Key : never : Keys;
+type ParseKeysByNamespaces<Ns extends Namespace, Keys> = Ns extends readonly (infer UnionNsps)[] ? UnionNsps extends keyof Keys ? AppendNamespace<UnionNsps, Keys[UnionNsps]> : never : never;
+type ParseKeysByFallbackNs<Keys extends $Dictionary> = _FallbackNamespace extends false ? never : _FallbackNamespace extends (infer UnionFallbackNs extends string)[] ? Keys[UnionFallbackNs] : Keys[_FallbackNamespace & string];
+type FilterKeysByContext<Keys, Context> = Context extends string ? Keys extends `${infer Prefix}${_ContextSeparator}${Context}${_PluralSeparator}${PluralSuffix}` | `${infer Prefix}${_ContextSeparator}${Context}` ? Prefix : never : Keys;
+type ParseKeys<Ns extends Namespace = DefaultNamespace, TOpt extends TOptions = {}, KPrefix = undefined, Keys extends $Dictionary = KeysByTOptions<TOpt>, ActualNS extends Namespace = NsByTOptions<Ns, TOpt>, Context extends TOpt['context'] = TOpt['context']> = $IsResourcesDefined extends true ? FilterKeysByContext<ParseKeysByKeyPrefix<Keys[$FirstNamespace<ActualNS>], KPrefix> | ParseKeysByNamespaces<ActualNS, Keys> | ParseKeysByFallbackNs<Keys>, Context> : string;
+/** *******************************************************
+ * Parse t function return type and interpolation values *
+ ******************************************************** */
+type ParseActualValue<Ret> = Ret extends `${_UnescapePrefix}${infer ActualValue}${_UnescapeSuffix}` ? TrimSpaces<ActualValue> : Ret;
+/** Parses interpolation entries as `[variableName, formatSpecifier | never]` tuples. */
+type ParseInterpolationEntries<Ret> = Ret extends `${string}${_InterpolationPrefix}${infer Value}${_InterpolationSuffix}${infer Rest}` ? (Value extends `${infer ActualValue},${infer Format}` ? [ParseActualValue<ActualValue>, TrimSpaces<Format>] : [ParseActualValue<Value>, never]) | ParseInterpolationEntries<Rest> : never;
+/** Extracts just the variable names (kept for backward compat with ParseInterpolationValues usage). */
+/** Built-in i18next formatter name → value type mapping. */
+type _BuiltInFormatTypeMap = {
+  number: number;
+  currency: number;
+  datetime: Date;
+  relativetime: number;
+  list: readonly string[];
+};
+/** Resolves the type for a single interpolation entry based on name and format. */
+type _ResolveEntryType<Name extends string, Format> = [Format] extends [never] ? Name extends 'count' ? number : string : Format extends keyof _InterpolationFormatTypeMap ? _InterpolationFormatTypeMap[Format] : Format extends keyof _BuiltInFormatTypeMap ? _BuiltInFormatTypeMap[Format] : string;
+/** Local union-to-intersection (not exported from helpers). */
+type _UnionToIntersection<T> = (T extends unknown ? (k: T) => void : never) extends ((k: infer I) => void) ? I : never;
+/** Builds a per-entry typed record from parsed interpolation entries and intersects them. */
+type _InterpolationMapFromEntries<E> = _UnionToIntersection<E extends [infer Name extends string, infer Format] ? $StringKeyPathToRecord<Name, _ResolveEntryType<Name, Format>> : never>;
+type InterpolationMap<Ret> = $PreservedValue<_InterpolationMapFromEntries<ParseInterpolationEntries<Ret>>, Record<string, unknown>>;
+type ParseTReturnPlural<Res, Key, KeyWithPlural = `${Key & string}${_PluralSeparator}${PluralSuffix}`> = Res[(KeyWithPlural | Key) & keyof Res];
+type ParseTReturnPluralOrdinal<Res, Key, KeyWithOrdinalPlural = `${Key & string}${_PluralSeparator}ordinal${_PluralSeparator}${PluralSuffix}`> = Res[(KeyWithOrdinalPlural | Key) & keyof Res];
+type ParseTReturnWithFallback<Key, Val> = Val extends '' ? _ReturnEmptyString extends true ? '' : Key : Val extends null ? _ReturnNull extends true ? null : Key : Val;
+type ParseTReturn<Key, Res, TOpt extends TOptions = {}> = ParseTReturnWithFallback<Key, Key extends `${infer K1}${_KeySeparator}${infer RestKey}` ? ParseTReturn<RestKey, Res[K1 & keyof Res], TOpt> : // Process plurals only if count is provided inside options
+TOpt['count'] extends number ? TOpt['ordinal'] extends boolean ? ParseTReturnPluralOrdinal<Res, Key> : ParseTReturnPlural<Res, Key> : // otherwise access plain key without adding plural and ordinal suffixes
+Res extends readonly unknown[] ? Key extends `${infer NKey extends number}` ? Res[NKey] : never : Res[Key & keyof Res]>;
+type TReturnOptionalNull = _ReturnNull extends true ? null : never;
+type TReturnOptionalObjects<TOpt extends {
+  returnObjects?: unknown;
+}> = _ReturnObjects extends true ? $SpecialObject | string : TOpt['returnObjects'] extends true ? $SpecialObject : string;
+type DefaultTReturn<TOpt extends {
+  returnObjects?: unknown;
+}> = TReturnOptionalObjects<TOpt> | TReturnOptionalNull;
+type KeyWithContext<Key, TOpt extends TOptions> = TOpt['context'] extends string ? `${Key & string}${_ContextSeparator}${TOpt['context']}` : Key;
+type ContextOfKey<Key extends string, Ns extends Namespace = DefaultNamespace, TOpt extends TOptions = {}, KPrefix = undefined, Keys extends $Dictionary = KeysByTOptions<TOpt>, ActualNS extends Namespace = NsByTOptions<Ns, TOpt>, ActualKeys = ParseKeysByKeyPrefix<Keys[$FirstNamespace<ActualNS>], KPrefix> | ParseKeysByNamespaces<ActualNS, Keys> | ParseKeysByFallbackNs<Keys>> = $IsResourcesDefined extends true ? Key extends ActualKeys ? string : ActualKeys extends `${Key}${_ContextSeparator}${infer Context}${_PluralSeparator}${PluralSuffix}` | `${Key}${_ContextSeparator}${infer Context}` ? Context : never : string;
+// helper that maps the configured fallbackNS value to the matching resources slice
+type FallbackResourcesOf<FallbackNS, R> = FallbackNS extends readonly (infer FN)[] ? R[FN & keyof R] : [FallbackNS] extends [false] ? never : R[Extract<FallbackNS, keyof R> & keyof R];
+/* reuse the parse helpers as top-level aliases (no nested type declarations) */
+type _PrimaryParse<ActualKey, PrimaryNS extends keyof Resources, TOpt extends TOptions> = ParseTReturn<ActualKey, Resources[PrimaryNS], TOpt>;
+type _FallbackParse<ActualKey, FallbackNS, TOpt extends TOptions> = [FallbackResourcesOf<FallbackNS, Resources>] extends [never] ? never : ParseTReturn<ActualKey, FallbackResourcesOf<FallbackNS, Resources>, TOpt>;
+type TFunctionReturn<Ns extends Namespace, Key, TOpt extends TOptions, ActualNS extends Namespace = NsByTOptions<Ns, TOpt>, ActualKey = KeyWithContext<Key, TOpt>> = $IsResourcesDefined extends true ? ActualKey extends `${infer Nsp}${_NsSeparator}${infer RestKey}` ? ParseTReturn<RestKey, Resources[Nsp & keyof Resources], TOpt> : $FirstNamespace<ActualNS> extends infer PrimaryNS ? [PrimaryNS] extends [keyof Resources] ? [_PrimaryParse<ActualKey, PrimaryNS & keyof Resources, TOpt>] extends [never] ? [_FallbackParse<ActualKey, _FallbackNamespace, TOpt>] extends [never] ? DefaultTReturn<TOpt> : _FallbackParse<ActualKey, _FallbackNamespace, TOpt> : _PrimaryParse<ActualKey, PrimaryNS & keyof Resources, TOpt> : never : never : DefaultTReturn<TOpt>;
+type TFunctionDetailedResult<T = string, TOpt extends TOptions = {}> = {
+  /**
+   * The plain used key
+   */
+  usedKey: string;
+  /**
+   * The translation result.
+   */
+  res: T;
+  /**
+   * The key with context / plural
+   */
+  exactUsedKey: string;
+  /**
+   * The used language for this translation.
+   */
+  usedLng: string;
+  /**
+   * The used namespace for this translation.
+   */
+  usedNS: string;
+  /**
+   * The parameters used for interpolation.
+   */
+  usedParams: InterpolationMap<T> & {
+    count?: TOpt['count'];
+  };
+};
+type TFunctionProcessReturnValue<Ret, DefaultValue> = Ret extends string | $SpecialObject | null ? Ret : [DefaultValue] extends [never] ? Ret : DefaultValue;
+type TFunctionReturnOptionalDetails<Ret, TOpt extends TOptions> = TOpt['returnDetails'] extends true ? TFunctionDetailedResult<Ret, TOpt> : Ret;
+type AppendKeyPrefix<Key, KPrefix> = KPrefix extends string ? `${KPrefix}${_KeySeparator}${Key & string}` : Key;
+/**
+ * Resolves the effective key prefix by preferring a per-call `keyPrefix` from
+ * options over the interface-level `KPrefix` (set via getFixedT's 3rd argument).
+ */
+type EffectiveKPrefix<KPrefix, TOpt> = TOpt extends {
+  keyPrefix: infer OptKP extends string;
+} ? OptKP : KPrefix;
+/** ************************
+ * T function declaration *
+ ************************* */
+interface TFunctionStrict<Ns extends Namespace = DefaultNamespace, KPrefix = undefined> extends Branded<Ns> {
+  <const Key extends ParseKeys<Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> | TemplateStringsArray, const TOpt extends TOptions, Ret extends TFunctionReturn<Ns, AppendKeyPrefix<Key, EffectiveKPrefix<KPrefix, TOpt>>, TOpt>>(key: Key | Key[], options?: TOpt & InterpolationMap<Ret> & {
+    context?: Key extends string ? ContextOfKey<Key, Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> : never;
+  }): TFunctionReturnOptionalDetails<TFunctionProcessReturnValue<$NoInfer<Ret>, never>, TOpt>;
+  <const Key extends ParseKeys<Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> | TemplateStringsArray, const TOpt extends TOptions, Ret extends TFunctionReturn<Ns, AppendKeyPrefix<Key, EffectiveKPrefix<KPrefix, TOpt>>, TOpt>>(key: Key | Key[], defaultValue: string, options?: TOpt & InterpolationMap<Ret> & {
+    context?: Key extends string ? ContextOfKey<Key, Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> : never;
+  }): TFunctionReturnOptionalDetails<TFunctionProcessReturnValue<$NoInfer<Ret>, never>, TOpt>;
+}
+interface TFunctionNonStrict<Ns extends Namespace = DefaultNamespace, KPrefix = undefined> extends Branded<Ns> {
+  <const Key extends ParseKeys<Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> | TemplateStringsArray, const TOpt extends TOptions, Ret extends TFunctionReturn<Ns, AppendKeyPrefix<Key, EffectiveKPrefix<KPrefix, TOpt>>, TOpt>, const ActualOptions extends Omit<TOpt, 'context'> & InterpolationMap<Ret> & {
+    context?: Key extends string ? ContextOfKey<Key, Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> : never;
+  } = TOpt & InterpolationMap<Ret> & {
+    context?: Key extends string ? ContextOfKey<Key, Ns, TOpt, EffectiveKPrefix<KPrefix, TOpt>> : never;
+  }, DefaultValue extends string = never>(...args: [key: Key | Key[], options?: ActualOptions] | [key: string | string[], options: TOpt & $Dictionary & {
+    defaultValue: DefaultValue;
+  }] | [key: string | string[], defaultValue: DefaultValue, options?: TOpt & $Dictionary]): TFunctionReturnOptionalDetails<TFunctionProcessReturnValue<$NoInfer<Ret>, DefaultValue>, TOpt>;
+}
+type TFunctionSignature<Ns extends Namespace = DefaultNamespace, KPrefix = undefined> = _EnableSelector extends true | 'optimize' ? TFunctionSelector<Ns, KPrefix, GetSource<Ns, KPrefix>> : _StrictKeyChecks extends true ? TFunctionStrict<Ns, KPrefix> : TFunctionNonStrict<Ns, KPrefix>;
+interface TFunction<Ns extends Namespace = DefaultNamespace, KPrefix = undefined> extends TFunctionSignature<Ns, KPrefix> {}
+type KeyPrefix<Ns extends Namespace> = ResourceKeys<true>[$FirstNamespace<Ns>] | undefined;
+/// ////////////// ///
+///  ↆ selector ↆ  ///
+/// ////////////// ///
+declare const $PluralBrand: unique symbol;
+/** Marks a value as coming from a plural-form key, requiring `count` in the selector options. */
+type PluralValue<T extends string> = T & {
+  readonly [$PluralBrand]: typeof $PluralBrand;
+};
+declare const $SelectorKeyBrand: unique symbol;
+/**
+ * A branded string produced by {@link keyFromSelector}.
+ * Can be passed directly to `t()` when the selector API is enabled.
+ */
+type SelectorKey = string & {
+  readonly [$SelectorKeyBrand]: typeof $SelectorKeyBrand;
+};
+/** Recursively strips the {@link PluralValue} brand from a type (handles nested objects for `returnObjects`). */
+type DeepUnwrapPlural<T> = T extends PluralValue<infer U> ? U : T extends readonly any[] ? { [I in keyof T]: DeepUnwrapPlural<T[I]> } : T extends object ? { [K in keyof T]: DeepUnwrapPlural<T[K]> } : T;
+type NsArg<Ns extends Namespace> = Ns[number] | readonly Ns[number][];
+interface TFunctionSelector<Ns extends Namespace, KPrefix, Source> extends Branded<Ns> {
+  // ── Selector(s) with explicit `ns` ───────────────────────────────────────────
+  <Target extends ConstrainTarget<Opts>, const NewNs extends NsArg<Ns> & Namespace, const Opts extends SelectorOptions<NewNs>, NewSrc extends GetSource<NewNs, KPrefix>>(selector: SelectorFn<NewSrc, ApplyTarget<Target, Opts>, Opts> | readonly SelectorFn<NewSrc, ApplyTarget<Target, Opts>, Opts>[], options: Opts & InterpolationMap<Target> & {
+    ns: NewNs;
+  }): SelectorReturn<Target, Opts>; // ── Array of selectors with default `ns` ─────────────────────────────────────
+  // Captures the selector tuple as `const Fns` so TypeScript preserves each
+  // element's exact return type.  The union of return types is then extracted
+  // via a distributive `infer`, which correctly handles mixed PluralValue<T> and
+  // plain-string callbacks that would otherwise cause TypeScript to "lock in" the
+  // type from the first element.
+  <const Fns extends readonly ((src: Select<Source, Opts['context']>) => string | object)[], const Opts extends SelectorOptions<Ns[number]> = SelectorOptions<Ns[number]>>(selectors: Fns, options?: Opts & InterpolationMap<DeepUnwrapPlural<Fns[number] extends ((...args: any[]) => infer R) ? R : never>>): SelectorReturn<Fns[number] extends ((...args: any[]) => infer R) ? R : never, Opts>; // ── Single selector with context — bypasses count enforcement ────────────────
+  // When `context` is present in options, `Target` is derived from the
+  // context-filtered source (third mapped type of FilterKeys), which does NOT
+  // apply the PluralValue brand.  A separate overload avoids the circular
+  // inference that would otherwise occur when `Opts['context']` sits inside the
+  // conditional rest tuple of the overload below.
+  <Target extends ConstrainTarget<Opts>, const NewNs extends NsArg<Ns> = Ns[number], const Opts extends SelectorOptions<NewNs> & {
+    context: string;
+  } = SelectorOptions<NewNs> & {
+    context: string;
+  }>(selector: SelectorFn<Source, ApplyTarget<Target, Opts>, Opts>, options: Opts & InterpolationMap<Target>): SelectorReturn<Target, Opts>; // ── Single selector with defaultValue — preserves literal type of DV ────────
+  // `const Opts` loses literal precision for `defaultValue` when inferred
+  // through a conditional rest tuple (TypeScript limitation).  This dedicated
+  // overload captures `DV` from a regular (non-conditional) parameter position,
+  // preserving its literal type.  Count enforcement for plural keys is achieved
+  // via a conditional intersection on the options parameter.
+  <const Fn extends (src: Select<Source, undefined>) => ConstrainTarget<Opts>, const DV extends string, const Opts extends SelectorOptions<Ns[number]> = SelectorOptions<Ns[number]>>(selector: Fn, options: Opts & {
+    defaultValue: DV;
+  } & (ReturnType<Fn> extends PluralValue<string> ? {
+    count: number;
+  } : {}) & InterpolationMap<DeepUnwrapPlural<ReturnType<Fn>>>): SelectorReturn<ReturnType<Fn>, Opts, DV>; // ── Single selector without context — enforces count for plural keys ──────────
+  // Uses `const Fn` to capture the selector's exact return type independently of
+  // `Opts`, breaking the circular dependency between `Target` inference and the
+  // conditional rest tuple.  `ReturnType<Fn>` drives both the plural check and
+  // the return type; `Opts` is inferred later from the resolved rest args.
+  <const Fn extends (src: Select<Source, undefined>) => ConstrainTarget<Opts>, const Opts extends SelectorOptions<Ns[number]> = SelectorOptions<Ns[number]>>(selector: Fn, ...args: ReturnType<Fn> extends PluralValue<string> ? [options: Opts & {
+    count: number;
+  } & InterpolationMap<DeepUnwrapPlural<ReturnType<Fn>>>] : [options?: Opts & InterpolationMap<ReturnType<Fn>>]): SelectorReturn<ReturnType<Fn>, Opts>; // ── Pre-computed key(s) from keyFromSelector ────────────────────────────────
+  // Accepts a branded `SelectorKey` (or array of them) produced by `keyFromSelector`.
+  // Return-type precision is traded for the flexibility of decoupled key creation.
+  <const Opts extends SelectorOptions<Ns[number]> = SelectorOptions<Ns[number]>>(key: SelectorKey | SelectorKey[], ...args: [options?: Opts & $Dictionary]): DefaultTReturn<Opts>;
+}
+interface SelectorOptions<Ns = Namespace> extends Omit<TOptionsBase, 'ns' | 'nsSeparator'>, $Dictionary {
+  ns?: Ns;
+}
+type SelectorReturn<Target, Opts extends {
+  defaultValue?: unknown;
+  returnObjects?: boolean;
+}, DV = Opts['defaultValue']> = $IsResourcesDefined extends true ? TFunctionReturnOptionalDetails<ProcessReturnValue<DeepUnwrapPlural<Target>, DV>, Opts> : DefaultTReturn<Opts>;
+interface SelectorFn<Source, Target, Opts extends SelectorOptions<unknown>> {
+  (translations: Select<Source, Opts['context']>): Target;
+}
+type ApplyKeyPrefix<T extends [any], KPrefix> = KPrefix extends `${infer Head}${_KeySeparator}${infer Tail}` ? ApplyKeyPrefix<[T[0][Head]], Tail> : T[0][KPrefix & string];
+type ApplyTarget<Target, Opts extends {
+  returnObjects?: unknown;
+}> = Opts['returnObjects'] extends true ? unknown : Target;
+type ConstrainTarget<Opts extends SelectorOptions<any>> = _ReturnObjects extends true ? unknown : Opts['returnObjects'] extends true ? unknown : $IsResourcesDefined extends false ? unknown : string;
+type ProcessReturnValue<Target, DefaultValue> = $Turtles extends Target ? string : [DefaultValue] extends [never] ? Target : unknown extends DefaultValue ? Target : Target | DefaultValue;
+type PickNamespaces<T, K extends keyof any> = { [P in K as P extends keyof T ? P : never]: T[P & keyof T] };
+type GetSource<Ns extends Namespace, KPrefix, Res = (Ns extends readonly [keyof Resources, any, ...any] ? Resources[Ns[0]] & PickNamespaces<Resources, Ns[number]> : Resources[$FirstNamespace<Ns>])> = KPrefix extends keyof Res ? Res[KPrefix] : undefined extends KPrefix ? Res : ApplyKeyPrefix<[Res], KPrefix>;
+type Select<T, Context> = $IsResourcesDefined extends false ? $Turtles : [_EnableSelector] extends ['optimize'] ? T : FilterKeys<T, Context>;
+type _HasContextVariant<T, K extends string, Context> = [keyof T & (`${K}${_ContextSeparator}${Context & string}` | `${K}${_ContextSeparator}${Context & string}${_PluralSeparator}${PluralSuffix}`)] extends [never] ? false : true;
+/** Checks whether key K has **any** context variant in T (excluding pure plural suffixes). */
+type _IsContextualKey<T, K extends string> = [Exclude<keyof T & `${K}${_ContextSeparator}${string}`, `${K}${_PluralSeparator}${PluralSuffix}` | `${K}${_PluralSeparator}ordinal${_PluralSeparator}${PluralSuffix}`>] extends [never] ? false : true;
+type FilterKeys<T, Context> = never | T extends readonly any[] ? { [I in keyof T]: FilterKeys<T[I], Context> } : $Prune<{ // Mapped type 1: object-valued keys (recurse) + plain leaf keys (non-plural, non-context)
+[K in keyof T as T[K] extends object ? K : [Context] extends [string] ? K extends `${string}${_ContextSeparator}${Context}` | `${string}${_ContextSeparator}${Context}${_PluralSeparator}${PluralSuffix}` ? never // context keys handled by mapped type 3
+: K extends `${string}${_PluralSeparator}${PluralSuffix}` ? never // plural keys handled by mapped type 2
+: K extends string ? _HasContextVariant<T, K, Context> extends true ? never // context variant exists, drop base key (type 3 handles it)
+: _IsContextualKey<T, K> extends true ? never // key has context variants but not for this context
+: K // no context variants at all, keep base key
+: K : K extends `${string}${_PluralSeparator}${PluralSuffix}` ? never : K]: T[K] extends object ? FilterKeys<T[K], Context> : T[K] } & { // Mapped type 2: plural collapsing (active regardless of context)
+[K in keyof T as T[K] extends object ? never : [Context] extends [string] ? K extends `${string}${_ContextSeparator}${Context}` | `${string}${_ContextSeparator}${Context}${_PluralSeparator}${PluralSuffix}` ? never // context keys handled by mapped type 3
+: K extends `${infer Prefix}${_PluralSeparator}${PluralSuffix}` | `${infer Prefix}${_PluralSeparator}ordinal${_PluralSeparator}${PluralSuffix}` ? Prefix : never : K extends `${infer Prefix}${_PluralSeparator}${PluralSuffix}` | `${infer Prefix}${_PluralSeparator}ordinal${_PluralSeparator}${PluralSuffix}` ? Prefix : never]: T[K] extends object ? FilterKeys<T[K], Context> : PluralValue<T[K] & string> } & { // Mapped type 3: context key collapsing
+[K in keyof T as T[K] extends object ? never : [Context] extends [string] ? K extends `${infer Prefix}${_ContextSeparator}${Context}` | `${infer Prefix}${_ContextSeparator}${Context}${_PluralSeparator}${PluralSuffix}` ? Prefix : never : never]: T[K] extends object ? FilterKeys<T[K], Context> : T[K] }>;
+//#endregion
+//#region ../../node_modules/.pnpm/i18next@25.10.3_typescript@5.9.3/node_modules/i18next/index.d.ts
+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;
+}
+declare 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;
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: 'added' | 'removed', callback?: (lng: string, ns: string) => void): void;
+}
+interface Formatter {
+  init(services: Services, i18nextOptions: InitOptions): void;
+  add(name: string, fc: (value: any, lng: string | undefined, options: any) => string): void;
+  addCached(name: string, fc: (lng: string | undefined, options: any) => (value: any) => string): void;
+  format: FormatFunction;
+}
+interface Services {
+  backendConnector: any;
+  i18nFormat: any;
+  interpolator: Interpolator;
+  languageDetector: any;
+  languageUtils: any;
+  logger: any;
+  pluralResolver: any;
+  resourceStore: ResourceStore;
+  formatter?: Formatter;
+}
+type ModuleType = 'backend' | 'logger' | 'languageDetector' | 'postProcessor' | 'i18nFormat' | 'formatter' | '3rdParty';
+interface Module {
+  type: ModuleType;
+}
+type CallbackError = Error | string | null | undefined;
+type ReadCallback = (err: CallbackError, data: ResourceKey | boolean | null | undefined) => void;
+type MultiReadCallback = (err: CallbackError, data: Resource | null | undefined) => 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.
+ */
+interface BackendModule<Options = object> extends Module {
+  type: 'backend';
+  init(services: Services, backendOptions: Options, i18nextOptions: InitOptions): void;
+  read(language: string, namespace: string, callback: ReadCallback): void;
+  /** Save the missing translation */
+  create?(languages: readonly string[], namespace: string, key: string, fallbackValue: string): void;
+  /** Load multiple languages and namespaces. For backends supporting multiple resources loading */
+  readMulti?(languages: readonly string[], namespaces: readonly string[], callback: MultiReadCallback): 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.
+ */
+interface LanguageDetectorModule extends Module {
+  type: 'languageDetector';
+  init?(services: Services, detectorOptions: object, i18nextOptions: InitOptions): void;
+  /** Must return detected language */
+  detect(): string | readonly 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.
+ */
+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 or return a Promise */
+  detect(callback: (lng: string | readonly string[] | undefined) => void | undefined): void | Promise<string | readonly string[] | undefined>;
+  cacheUserLanguage?(lng: string): void | Promise<void>;
+}
+/**
+ * Override the built-in console logger.
+ * Do not need to be a prototype function.
+ */
+interface LoggerModule extends Module {
+  type: 'logger';
+  log(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+}
+interface I18nFormatModule extends Module {
+  type: 'i18nFormat';
+}
+interface FormatterModule extends Module, Formatter {
+  type: 'formatter';
+}
+interface ThirdPartyModule extends Module {
+  type: '3rdParty';
+  init(i18next: i18n$1): void;
+}
+interface Modules {
+  backend?: BackendModule;
+  logger?: LoggerModule;
+  languageDetector?: LanguageDetectorModule | LanguageDetectorAsyncModule;
+  i18nFormat?: I18nFormatModule;
+  formatter?: FormatterModule;
+  external: ThirdPartyModule[];
+}
+// helper to identify class https://stackoverflow.com/a/45983481/2363935
+interface Newable<T> {
+  new (...args: any[]): T;
+}
+interface NewableModule<T extends Module> extends Newable<T> {
+  type: T['type'];
+}
+type Callback = (error: any, t: TFunction) => void;
+/**
+ * Uses similar args as the t function and returns true if a key exists.
+ */
+interface ExistsFunction<TKeys extends string = string, TInterpolationMap extends object = $Dictionary> {
+  (key: TKeys | TKeys[], options?: TOptions<TInterpolationMap>): boolean;
+}
+interface CloneOptions extends InitOptions {
+  /**
+   * 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.
+   * @default false
+   */
+  forkResourceStore?: boolean;
+}
+interface CustomInstanceExtensions {}
+// Used just here to exclude `DefaultNamespace` which can be both string or array from `FlatNamespace`
+// in TFunction declaration below.
+// Due to this only very special usage I'm not moving this inside helpers.
+type InferArrayValuesElseReturnType<T> = T extends (infer A)[] ? A : T; // eslint-disable-next-line @typescript-eslint/naming-convention
+interface i18n$1 extends CustomInstanceExtensions {
+  // Expose parameterized t in the i18next interface hierarchy
+  t: TFunction<[...$NormalizeIntoArray<DefaultNamespace>, ...Exclude<FlatNamespace, InferArrayValuesElseReturnType<DefaultNamespace>>[]]>;
+  /**
+   * 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<T>(options: InitOptions<T>, 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.
+   *
+   * @param module Accepts a class or object
+   */
+  use<T extends Module>(module: T | NewableModule<T> | Newable<T>): this;
+  /**
+   * 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): {
+    [key: string]: {
+      [key: string]: string;
+    };
+  } | undefined;
+  /**
+   * 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.
+   */
+  getFixedT<Ns extends Namespace | null = DefaultNamespace, TKPrefix extends KeyPrefix<ActualNs> = undefined, ActualNs extends Namespace = (Ns extends null ? DefaultNamespace : Ns)>(...args: [lng: string | readonly string[], ns?: Ns, keyPrefix?: TKPrefix | (($: any) => any)] | [lng: null, ns: Ns, keyPrefix?: TKPrefix | (($: any) => any)]): TFunction<ActualNs, TKPrefix>;
+  /**
+   * 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: readonly string[];
+  /**
+   * Is set to the current resolved language.
+   * It can be used as primary used language, for example in a language switcher.
+   */
+  resolvedLanguage?: string;
+  /**
+   * Checks if namespace has loaded yet.
+   * i.e. used by react-i18next
+   */
+  hasLoadedNamespace(ns: string | readonly string[], options?: {
+    lng?: string | readonly string[];
+    fallbackLng?: InitOptions['fallbackLng'];
+    /**
+     * if `undefined` is returned default checks are performed.
+     */
+    precheck?: (i18n: i18n$1,
+    /**
+     * Check if the language namespace provided are not in loading status:
+     * returns `true` if load is completed successfully or with an error.
+     */
+
+    loadNotPending: (lng: string | readonly string[], ns: string | readonly string[]) => boolean) => boolean | undefined;
+  }): boolean;
+  /**
+   * Loads additional namespaces not defined in init options.
+   */
+  loadNamespaces(ns: string | readonly string[], callback?: Callback): Promise<void>;
+  /**
+   * Loads additional languages not defined in init options (preload).
+   */
+  loadLanguages(lngs: string | readonly 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 | readonly string[], ns?: string | readonly string[], callback?: () => void): Promise<void>;
+  reloadResources(lngs: null, ns: string | readonly string[], callback?: () => void): Promise<void>;
+  /**
+   * Changes the default namespace.
+   */
+  setDefaultNamespace(ns: string | readonly 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$1;
+  /**
+   * 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?: CloneOptions, callback?: Callback): i18n$1;
+  /**
+   * Returns a JSON representation of the i18next instance for serialization.
+   */
+  toJSON(): {
+    options: InitOptions;
+    store: ResourceStore;
+    language: string;
+    languages: readonly string[];
+    resolvedLanguage?: string;
+  };
+  /**
+   * Gets fired after initialization.
+   */
+  on(event: 'initialized', callback: (options: InitOptions) => void): this;
+  /**
+   * Gets fired on loaded resources.
+   */
+  on(event: 'loaded', callback: (loaded: {
+    [language: string]: {
+      [namespace: string]: boolean;
+    };
+  }) => void): this;
+  /**
+   * Gets fired if loading resources failed.
+   */
+  on(event: 'failedLoading', callback: (lng: string, ns: string, msg: string) => void): this;
+  /**
+   * Gets fired on accessing a key not existing.
+   */
+  on(event: 'missingKey', callback: (lngs: readonly string[], namespace: string, key: string, res: string) => void): this;
+  /**
+   * Gets fired when changeLanguage got called.
+   */
+  on(event: 'languageChanged', callback: (lng: string) => void): this;
+  /**
+   * Event listener
+   */
+  on(event: string, listener: (...args: any[]) => void): this;
+  /**
+   * Remove event listener
+   * removes all callback when callback not specified
+   */
+  off(event: string, listener?: (...args: any[]) => void): void;
+  /**
+   * Gets one value by given key.
+   */
+  getResource(lng: string, ns: string, key: string, options?: Pick<InitOptions, 'keySeparator' | 'ignoreJSONStructure'>): any;
+  /**
+   * Adds one key/value.
+   */
+  addResource(lng: string, ns: string, key: string, value: string, options?: {
+    keySeparator?: string;
+    silent?: boolean;
+  }): i18n$1;
+  /**
+   * Adds multiple key/values.
+   */
+  addResources(lng: string, ns: string, resources: any): i18n$1;
+  /**
+   * 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): i18n$1;
+  /**
+   * 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): i18n$1;
+  /**
+   * Current options
+   */
+  options: InitOptions;
+  /**
+   * Is initialized
+   */
+  isInitialized: boolean;
+  /**
+   * Is initializing
+   */
+  isInitializing: boolean;
+  /**
+   * Store was initialized
+   */
+  initializedStoreOnce: boolean;
+  /**
+   * Language was initialized
+   */
+  initializedLanguageOnce: boolean;
+  /**
+   * Emit event
+   */
+  emit(eventName: string, ...args: any[]): void;
+}
+//#endregion
+//#region src/i18n/i18next.d.ts
+declare const i18n: i18n$1;
+//#endregion
+export { i18n };
+//# sourceMappingURL=i18next.d.ts.map