@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

package/dist/types/runtime/contextHelpers.d.ts

@@ -0,0 +1,29 @@
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+type Navigate = (url: string, options?: {
+    replace?: boolean;
+}) => Promise<void> | void;
+type LocationLike = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare function getPathLanguage(pathname: string | undefined, languages: string[] | undefined, localePathRedirect: boolean | undefined): string | undefined;
+export declare function cacheI18nLanguage(i18nInstance: I18nInstance, language: string): void;
+export declare function changeI18nInstanceLanguage(i18nInstance: I18nInstance, language: string): Promise<void>;
+interface ChangeModernI18nLanguageOptions {
+    i18nInstance: I18nInstance;
+    updateLanguage?: (newLang: string) => void;
+    localePathRedirect?: boolean;
+    ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    localisedUrls?: LocalisedUrlsOption;
+    languages?: string[];
+    hasRouter: boolean;
+    navigate?: Navigate | null;
+    location?: LocationLike | null;
+}
+export declare function changeModernI18nLanguage(newLang: string, options: ChangeModernI18nLanguageOptions): Promise<void>;
+export declare function translateI18n(i18nInstance: I18nInstance, key: string | string[], ...args: unknown[]): string;
+export declare function isI18nLanguageSupported(languages: string[] | undefined, lang: string): boolean;
+export declare function isI18nResourcesReady(i18nInstance: I18nInstance, currentLanguage: string): boolean;
+export {};

package/dist/types/runtime/core.d.ts

@@ -1,10 +1,11 @@
-import { type RuntimePlugin } from '@modern-js/runtime';
-import type React from 'react';
+import type { RuntimePlugin } from '@modern-js/runtime';
 import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
 import type { I18nInitOptions, I18nInstance } from './i18n';
+import { type LoadReactI18nextIntegration } from './reactI18next';
 import './types';
 export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
 export type { Resources } from './i18n/instance';
+export type { LoadReactI18nextIntegration, ReactI18nextIntegration, } from './reactI18next';
 export interface I18nPluginOptions {
     entryName?: string;
     localeDetection?: BaseLocaleDetectionOptions;
@@ -16,14 +17,9 @@ export interface I18nPluginOptions {
     reactI18next?: boolean;
     [key: string]: any;
 }
-export interface ReactI18nextIntegration {
-    I18nextProvider: React.ComponentType<any> | null;
-    initReactI18next: any | null;
-}
-export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
 export declare const createI18nPlugin: (loadReactI18nextIntegration?: LoadReactI18nextIntegration) => ((options: I18nPluginOptions) => RuntimePlugin);
 export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
-export { useModernI18n } from './context';
+export { FederatedI18nBoundary, type FederatedI18nBoundaryProps, useModernI18n, } from './context';
 export { I18nLink, type I18nLinkProps } from './I18nLink';
 export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link';
 export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths';

package/dist/types/runtime/hooks.d.ts

@@ -1,11 +1,7 @@
-import type { TRuntimeContext } from '@modern-js/runtime';
 import type React from 'react';
 import type { LocalisedUrlsOption } from '../shared/localisedUrls';
 import type { I18nInstance } from './i18n';
-interface RuntimeContextWithI18n extends TRuntimeContext {
-    i18nInstance?: I18nInstance;
-}
-export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, localisedUrls: LocalisedUrlsOption | undefined, setLang: (lang: string) => void): {
+export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, localisedUrls: LocalisedUrlsOption | undefined, setLang: (lang: string) => void, synchronizeLanguage: (lang: string) => void): {
     language: string;
     i18nInstance: I18nInstance;
     entryName: string | undefined;
@@ -14,6 +10,7 @@ export declare function createContextValue(lang: string, i18nInstance: I18nInsta
     ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
     localisedUrls: LocalisedUrlsOption | undefined;
     updateLanguage: (lang: string) => void;
+    synchronizeLanguage: (lang: string) => void;
 };
 export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
 /**
@@ -26,5 +23,4 @@ export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undef
  * We use process.env.MODERN_TARGET to ensure this code is only included in browser bundles.
  */
 export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), localisedUrls?: LocalisedUrlsOption): void;
-export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], runtimeContextRef: React.MutableRefObject<RuntimeContextWithI18n>, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): void;
-export {};
+export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], pathname: string | undefined, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): (currentLang: string) => void;

package/dist/types/runtime/i18n/backend/middleware.common.d.ts

@@ -1,6 +1,7 @@
 import type { BaseBackendOptions, ChainedBackendConfig } from '../../../shared/type';
 import type { I18nInstance } from '../instance';
 type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfig>;
+type BackendConstructor = new (...args: never[]) => unknown;
 /**
  * Common logic for using i18next backend
  * This function handles the backend selection and chained backend configuration
@@ -10,5 +11,5 @@ type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfi
  * @param BackendBase - The base backend class (for non-chained use)
  * @param backend - Optional backend configuration
  */
-export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: new (...args: any[]) => any, BackendBase: new (...args: any[]) => any, backend?: BackendConfigWithChained): void;
+export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: BackendConstructor, BackendBase: BackendConstructor, backend?: BackendConfigWithChained): void;
 export {};

package/dist/types/runtime/i18n/detection/cache.d.ts

@@ -0,0 +1,14 @@
+import type { I18nInitOptions, I18nInstance, LanguageDetectorOptions } from '../instance';
+interface DetectorCacheEntry {
+    instance: I18nInstance;
+    isTemporary: boolean;
+    configKey: string;
+}
+export declare const detectorInstanceCache: WeakMap<I18nInstance, DetectorCacheEntry>;
+export declare const buildDetectorConfigKey: (languages: string[], fallbackLanguage: string, mergedDetection: LanguageDetectorOptions) => string;
+export declare const pickSafeDetectionOptions: (userInitOptions?: I18nInitOptions) => Partial<I18nInitOptions> & Record<string, unknown>;
+export declare const createDetectorInstance: (baseInstance: I18nInstance, configKey: string) => {
+    instance: I18nInstance;
+    isTemporary: boolean;
+};
+export {};

package/dist/types/runtime/i18n/detection/detector.d.ts

@@ -0,0 +1,8 @@
+import type { I18nInstance } from '../instance';
+import type { BaseLanguageDetectionOptions, LanguageDetectionSsrContext } from './types';
+/**
+ * Priority 3: Detect language using i18next detector
+ */
+export declare const detectLanguageFromI18nextDetector: (i18nInstance: I18nInstance, options: BaseLanguageDetectionOptions & {
+    ssrContext?: LanguageDetectionSsrContext;
+}) => Promise<string | undefined>;

package/dist/types/runtime/i18n/detection/index.d.ts

@@ -1,50 +1,5 @@
-import { type TRuntimeContext } from '@modern-js/runtime';
-import type { I18nInitOptions, I18nInstance, LanguageDetectorOptions } from '../instance';
-import { cacheUserLanguage } from './middleware';
-export { cacheUserLanguage };
-export declare function exportServerLngToWindow(context: TRuntimeContext, lng: string): void;
-export declare const getLanguageFromSSRData: (window: Window) => string | undefined;
-export interface BaseLanguageDetectionOptions {
-    languages: string[];
-    fallbackLanguage: string;
-    localePathRedirect: boolean;
-    i18nextDetector: boolean;
-    detection?: LanguageDetectorOptions;
-    userInitOptions?: I18nInitOptions;
-    mergedBackend?: any;
-}
-export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
-    pathname: string;
-    ssrContext?: any;
-}
-export interface LanguageDetectionResult {
-    detectedLanguage?: string;
-    finalLanguage: string;
-}
-/**
- * Detect language with priority:
- * Priority 1: SSR data (try window._SSR_DATA first, works for both SSR and CSR)
- * Priority 2: Path detection
- * Priority 3: i18next detector (reads from cookie/localStorage)
- * Priority 4: User config language or fallback
- */
-export declare const detectLanguageWithPriority: (i18nInstance: I18nInstance, options: LanguageDetectionOptions) => Promise<LanguageDetectionResult>;
-/**
- * Options for building i18n init options
- */
-export interface BuildInitOptionsParams {
-    finalLanguage: string;
-    fallbackLanguage: string;
-    languages: string[];
-    userInitOptions?: I18nInitOptions;
-    mergedDetection?: any;
-    mergeBackend?: any;
-}
-/**
- * Build i18n initialization options
- */
-export declare const buildInitOptions: (params: BuildInitOptionsParams) => I18nInitOptions;
-/**
- * Merge detection and backend options
- */
-export declare const mergeDetectionOptions: (i18nextDetector: boolean, detection?: LanguageDetectorOptions, localePathRedirect?: boolean, userInitOptions?: I18nInitOptions) => LanguageDetectorOptions;
+export { buildInitOptions, mergeDetectionOptions } from './initOptions';
+export { cacheUserLanguage } from './middleware';
+export { detectLanguageWithPriority } from './priority';
+export { exportServerLngToWindow, getLanguageFromSSRData } from './ssr';
+export type { BaseLanguageDetectionOptions, BuildInitOptionsParams, LanguageDetectionOptions, LanguageDetectionResult, } from './types';

package/dist/types/runtime/i18n/detection/initOptions.d.ts

@@ -0,0 +1,10 @@
+import type { I18nInitOptions, LanguageDetectorOptions } from '../instance';
+import type { BuildInitOptionsParams } from './types';
+/**
+ * Build i18n initialization options
+ */
+export declare const buildInitOptions: (params: BuildInitOptionsParams) => I18nInitOptions;
+/**
+ * Merge detection and backend options
+ */
+export declare const mergeDetectionOptions: (i18nextDetector: boolean, detection?: LanguageDetectorOptions, localePathRedirect?: boolean, userInitOptions?: I18nInitOptions) => LanguageDetectorOptions;

package/dist/types/runtime/i18n/detection/language.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a language is supported
+ * Also checks the base language code (e.g., 'zh-CN' matches 'zh')
+ */
+export declare const isLanguageSupported: (language: string | undefined, supportedLanguages: string[]) => boolean;
+/**
+ * Get the supported language that matches the given language
+ * Returns the exact match if available, otherwise returns the base language code match
+ * Returns undefined if no match is found
+ */
+export declare const getSupportedLanguage: (language: string | undefined, supportedLanguages: string[]) => string | undefined;

package/dist/types/runtime/i18n/detection/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { I18nInstance } from '../instance';
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -9,16 +9,16 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Read language directly from localStorage/cookie
  * Fallback when detector is not available in services
  */
-export declare const readLanguageFromStorage: (detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Detect language using i18next-browser-languagedetector
  * For initialized instances without detector in services, manually create a detector instance
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: unknown, detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Cache user language to localStorage/cookie
  * Uses LanguageDetector's cacheUserLanguage method when available
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: any) => void;
+export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: unknown) => void;

package/dist/types/runtime/i18n/detection/middleware.node.d.ts

@@ -1,10 +1,10 @@
-import type { I18nInstance } from '../instance';
-export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: any) => void;
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
+export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: unknown) => void;
 /**
  * Read language directly from storage (localStorage/cookie)
  * Not available in Node.js environment, returns undefined
  */
-export declare const readLanguageFromStorage: (_detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (_detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -14,4 +14,4 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Detect language using i18next-http-middleware LanguageDetector
  * For initialized instances without detector in services, manually create a detector instance
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, request?: unknown, detectionOptions?: LanguageDetectorOptions) => string | undefined;

package/dist/types/runtime/i18n/detection/path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Priority 2: Detect language from URL path
+ * Only returns a language if the path explicitly contains a language prefix
+ */
+export declare const detectLanguageFromPathPriority: (pathname: string, languages: string[], localePathRedirect: boolean) => string | undefined;

package/dist/types/runtime/i18n/detection/priority.d.ts

@@ -0,0 +1,10 @@
+import { type I18nInstance } from '../instance';
+import type { LanguageDetectionOptions, LanguageDetectionResult } from './types';
+/**
+ * Detect language with priority:
+ * Priority 1: Path detection
+ * Priority 2: SSR data (try window._SSR_DATA first, works for both SSR and CSR)
+ * Priority 3: i18next detector (reads from cookie/localStorage)
+ * Priority 4: User config language or fallback
+ */
+export declare const detectLanguageWithPriority: (i18nInstance: I18nInstance, options: LanguageDetectionOptions) => Promise<LanguageDetectionResult>;

package/dist/types/runtime/i18n/detection/ssr.d.ts

@@ -0,0 +1,9 @@
+import { type TRuntimeContext } from '@modern-js/runtime';
+export declare function exportServerLngToWindow(context: TRuntimeContext, lng: string): void;
+export declare const getLanguageFromSSRData: (window: Window) => string | undefined;
+/**
+ * Priority 1: Detect language from SSR data
+ * Try to get language from window._SSR_DATA first (both SSR and CSR projects)
+ * Returns undefined if SSR data is not available or invalid
+ */
+export declare const detectLanguageFromSSR: (languages: string[]) => string | undefined;

package/dist/types/runtime/i18n/detection/types.d.ts

@@ -0,0 +1,32 @@
+import type { BackendOptions, I18nInitOptions, LanguageDetectorOptions } from '../instance';
+export interface LanguageDetectionSsrContext {
+    request?: unknown;
+}
+export interface BaseLanguageDetectionOptions {
+    languages: string[];
+    fallbackLanguage: string;
+    localePathRedirect: boolean;
+    i18nextDetector: boolean;
+    detection?: LanguageDetectorOptions;
+    userInitOptions?: I18nInitOptions;
+    mergedBackend?: BackendOptions;
+}
+export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
+    pathname: string;
+    ssrContext?: LanguageDetectionSsrContext;
+}
+export interface LanguageDetectionResult {
+    detectedLanguage?: string;
+    finalLanguage: string;
+}
+/**
+ * Options for building i18n init options
+ */
+export interface BuildInitOptionsParams {
+    finalLanguage: string;
+    fallbackLanguage: string;
+    languages: string[];
+    userInitOptions?: I18nInitOptions;
+    mergedDetection?: LanguageDetectorOptions;
+    mergeBackend?: BackendOptions;
+}

package/dist/types/runtime/i18n/instance.d.ts

@@ -1,46 +1,49 @@
 import type { BaseBackendOptions } from '../../shared/type';
-export interface I18nResourceStore {
+interface I18nResourceStore {
     data?: {
         [language: string]: {
-            [namespace: string]: string | {
-                [key: string]: any;
-            };
+            [namespace: string]: ResourceValue;
         };
     };
     addResourceBundle?: (language: string, namespace: string, resources: Record<string, string>, deep?: boolean, overwrite?: boolean) => void;
 }
-export declare function isI18nWrapperInstance(obj: any): boolean;
-export declare function getI18nWrapperI18nextInstance(wrapperInstance: any): any;
-export declare function getActualI18nextInstance(instance: I18nInstance | any): any;
+type I18nWrapperInstance = I18nInstance & {
+    i18nInstance: {
+        instance: I18nInstance;
+    };
+};
+export declare function isI18nWrapperInstance(obj: unknown): obj is I18nWrapperInstance;
+export declare function getActualI18nextInstance(instance: I18nInstance): I18nInstance;
 export interface I18nInstance {
     language: string;
     isInitialized?: boolean;
     init: {
-        (callback?: (error: any, t: any) => void): Promise<any>;
-        (options: I18nInitOptions, callback?: (error: any, t: any) => void): Promise<any>;
+        (callback?: (error: unknown, t: unknown) => void): Promise<unknown>;
+        (options: I18nInitOptions, callback?: (error: unknown, t: unknown) => void): Promise<unknown>;
     };
-    changeLanguage?: (lng?: string, callback?: (error: any, t: any) => void) => Promise<any>;
+    changeLanguage?: (lng?: string, callback?: (error: unknown, t: unknown) => void) => Promise<unknown>;
     setLang?: (lang: string) => void | Promise<void>;
-    use: (plugin: any) => void;
+    use: (plugin: unknown) => void;
     createInstance?: (options?: I18nInitOptions) => I18nInstance;
-    cloneInstance?: () => I18nInstance;
+    cloneInstance?: (options?: I18nInitOptions) => I18nInstance;
     store?: I18nResourceStore;
-    emit?: (event: string, ...args: any[]) => void;
+    emit?: (event: string, ...args: unknown[]) => void;
     reloadResources?: (language?: string, namespace?: string) => Promise<void>;
+    removeResourceBundle?: (language: string, namespace: string) => I18nInstance;
     services?: {
         languageDetector?: {
-            detect: (request?: any, options?: any) => string | string[] | undefined;
-            [key: string]: any;
+            detect: (request?: unknown, options?: unknown) => string | string[] | undefined;
+            [key: string]: unknown;
         };
         resourceStore?: I18nResourceStore;
-        backend?: any;
-        [key: string]: any;
+        backend?: unknown;
+        [key: string]: unknown;
     };
     options?: {
         backend?: BackendOptions;
-        [key: string]: any;
+        [key: string]: unknown;
     };
-    [key: string]: any;
+    [key: string]: unknown;
 }
 type LanguageDetectorOrder = string[];
 type LanguageDetectorCaches = boolean | string[];
@@ -57,11 +60,11 @@ export interface LanguageDetectorOptions {
     lookupHeader?: string;
 }
 export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
-    parse?: (data: string) => any;
-    stringify?: (data: any) => string;
+    parse?: (data: string) => unknown;
+    stringify?: (data: unknown) => string;
     [key: string]: any;
 }
-export type ResourceValue = string | {
+type ResourceValue = string | {
     [key: string]: ResourceValue;
 };
 export interface Resources {
@@ -81,14 +84,15 @@ export type I18nInitOptions = {
     defaultNS?: string | string[];
     interpolation?: {
         escapeValue?: boolean;
-        [key: string]: any;
+        [key: string]: unknown;
     };
     react?: {
         useSuspense?: boolean;
-        [key: string]: any;
+        [key: string]: unknown;
     };
+    forkResourceStore?: boolean;
 };
-export declare function isI18nInstance(obj: any): obj is I18nInstance;
-export declare function getI18nextInstanceForProvider(instance: I18nInstance | any): any;
-export declare function getI18nInstance(userInstance?: I18nInstance | any): Promise<I18nInstance>;
+export declare function isI18nInstance(obj: unknown): obj is I18nInstance;
+export declare function getI18nextInstanceForProvider(instance: I18nInstance, language?: string): I18nInstance;
+export declare function getI18nInstance(userInstance?: unknown): Promise<I18nInstance>;
 export {};

package/dist/types/runtime/i18n/react-i18next.d.ts

@@ -1,7 +1,2 @@
-import type React from 'react';
-interface ReactI18nextIntegration {
-    I18nextProvider: React.ComponentType<any> | null;
-    initReactI18next: any | null;
-}
+import type { ReactI18nextIntegration } from '../reactI18next';
 export declare function getReactI18nextIntegration(): Promise<ReactI18nextIntegration>;
-export {};

package/dist/types/runtime/i18n/utils.d.ts

@@ -1,10 +1,18 @@
 import type { BaseBackendOptions } from '../../shared/type';
 import type { I18nInitOptions, I18nInstance } from './instance';
-export declare function assertI18nInstance(obj: any): asserts obj is I18nInstance;
+type MergedBackendOptions = NonNullable<I18nInitOptions['backend']> & {
+    _useChainedBackend?: boolean;
+    _chainedBackendConfig?: {
+        backendOptions: Array<Record<string, unknown>>;
+    };
+    backends?: unknown[];
+    backendOptions?: unknown;
+};
+export declare function assertI18nInstance(obj: unknown): asserts obj is I18nInstance;
 /**
  * Build initialization options for i18n instance
  */
-export declare const buildInitOptions: (finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean, i18nInstance?: I18nInstance) => Promise<I18nInitOptions>;
+export declare const buildInitOptions: (finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: I18nInitOptions['detection'], mergedBackend: MergedBackendOptions | undefined, userInitOptions?: I18nInitOptions, useSuspense?: boolean, i18nInstance?: I18nInstance) => Promise<I18nInitOptions>;
 /**
  * Ensure i18n instance language matches the final detected language
  */
@@ -17,13 +25,14 @@ export declare const ensureLanguageMatch: (i18nInstance: I18nInstance, finalLang
  * @param options - Optional configuration
  */
 export declare const changeI18nLanguage: (i18nInstance: I18nInstance, newLang: string, options?: {
-    detectionOptions?: any;
+    detectionOptions?: I18nInitOptions['detection'];
 }) => Promise<void>;
 /**
  * Initialize i18n instance if not already initialized
  */
-export declare const initializeI18nInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean) => Promise<void>;
+export declare const initializeI18nInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: I18nInitOptions['detection'], mergedBackend: MergedBackendOptions | undefined, userInitOptions?: I18nInitOptions, useSuspense?: boolean) => Promise<void>;
 /**
  * Setup cloned instance for SSR with backend support
  */
-export declare const setupClonedInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], backendEnabled: boolean, backend: BaseBackendOptions | undefined, i18nextDetector: boolean, detection: any, localePathRedirect: boolean, userInitOptions: I18nInitOptions | undefined) => Promise<void>;
+export declare const setupClonedInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], backendEnabled: boolean, backend: BaseBackendOptions | undefined, i18nextDetector: boolean, detection: I18nInitOptions['detection'], localePathRedirect: boolean, userInitOptions: I18nInitOptions | undefined) => Promise<void>;
+export {};

package/dist/types/runtime/linkHelpers.d.ts

@@ -0,0 +1,17 @@
+export declare const warnOnce: (key: string, message: string) => void;
+export type LinkParams = Record<string, string | number | undefined>;
+type NormalizedSearchValue = string | string[];
+/**
+ * Interpolate `$param`, `:param`, optional (`{-$param}` / `:param?`) and splat
+ * (`$` / `*`) segments with concrete values before localization, so
+ * pattern-mapped slugs localize correctly.
+ */
+export declare const interpolateRouteParams: (pathname: string, params?: LinkParams) => string;
+export declare const normalizeSearch: (search: string | Record<string, unknown> | undefined, searchFromTo: string) => {
+    searchString: string;
+    searchObject: Record<string, NormalizedSearchValue> | undefined;
+};
+type ActivePropsResult<TActiveProps extends Record<string, unknown>> = Record<string, unknown> & Partial<TActiveProps>;
+export declare const splitActiveProps: <TActiveProps extends Record<string, unknown>>(active: boolean, activeProps?: TActiveProps) => ActivePropsResult<TActiveProps>;
+export declare const mergeClassNames: (...values: Array<unknown>) => string | undefined;
+export {};

package/dist/types/runtime/pluginSetup.d.ts

@@ -0,0 +1,32 @@
+import type { TInternalRuntimeContext } from '@modern-js/runtime/internal';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import type { ReactI18nextIntegration } from './reactI18next';
+interface RuntimeConfigWithI18n {
+    i18n?: {
+        initOptions?: I18nInitOptions;
+    };
+}
+interface I18nRuntimeApi {
+    getRuntimeConfig: () => RuntimeConfigWithI18n;
+}
+export interface RuntimeContextWithI18n extends TInternalRuntimeContext {
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => Promise<void>;
+}
+interface SetupI18nBeforeRenderOptions {
+    api: I18nRuntimeApi;
+    userI18nInstance?: I18nInstance;
+    initOptions?: I18nInitOptions;
+    backend?: BaseBackendOptions;
+    backendEnabled: boolean;
+    i18nextDetector: boolean;
+    detection?: BaseLocaleDetectionOptions['detection'];
+    localePathRedirect: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    resolveReactI18nextIntegration: () => Promise<ReactI18nextIntegration | null>;
+    setI18nextProvider: (provider: ReactI18nextIntegration['I18nextProvider']) => void;
+}
+export declare function setupI18nBeforeRender(context: RuntimeContextWithI18n, options: SetupI18nBeforeRenderOptions): Promise<I18nInstance>;
+export {};

package/dist/types/runtime/providerComposition.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type { BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInstance } from './i18n';
+interface I18nRootWrapperOptions {
+    entryName?: string;
+    htmlLangAttr: boolean;
+    localePathRedirect: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    ignoreRedirectRoutes?: BaseLocaleDetectionOptions['ignoreRedirectRoutes'];
+    localisedUrls?: BaseLocaleDetectionOptions['localisedUrls'];
+    getLatestI18nInstance: () => I18nInstance | undefined;
+    getI18nextProvider: () => React.ComponentType<any> | null | undefined;
+}
+export declare const createI18nRootWrapper: (options: I18nRootWrapperOptions) => (App: React.ComponentType<any>) => (props: Record<string, unknown>) => React.JSX.Element;
+export {};

package/dist/types/runtime/reactI18next.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+export interface ReactI18nextIntegration {
+    I18nextProvider: React.ComponentType<any> | null;
+    initReactI18next: any | null;
+}
+export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
+export declare const resolveReactI18nextIntegration: (reactI18next: boolean, loadReactI18nextIntegration?: LoadReactI18nextIntegration) => Promise<ReactI18nextIntegration | null>;

package/dist/types/runtime/routerAdapter.d.ts

@@ -1,21 +1,21 @@
 import type React from 'react';
-export type I18nRouterFramework = 'react-router' | 'tanstack' | string;
-export interface I18nRouterLocation {
+type I18nRouterFramework = 'react-router' | 'tanstack' | string;
+interface I18nRouterLocation {
     pathname: string;
     search: string;
     hash: string;
 }
-export interface I18nRouterNavigateOptions {
+interface I18nRouterNavigateOptions {
     replace?: boolean;
     state?: unknown;
 }
-export type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
-export type I18nRouterLink = React.ComponentType<{
+type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
+type I18nRouterLink = React.ComponentType<{
     to: string;
     children?: React.ReactNode;
     [key: string]: unknown;
 }>;
-export interface I18nRouterAdapter {
+interface I18nRouterAdapter {
     framework?: I18nRouterFramework;
     hasRouter: boolean;
     location: I18nRouterLocation | null;
@@ -24,3 +24,4 @@ export interface I18nRouterAdapter {
     params: Record<string, string>;
 }
 export declare const useI18nRouterAdapter: () => I18nRouterAdapter;
+export {};

package/dist/types/runtime/utils.d.ts

@@ -1,6 +1,11 @@
-import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
 import type { LocalisedUrlsOption } from '../shared/localisedUrls';
-export declare const getPathname: (context: TInternalRuntimeContext) => string;
+export declare const getPathname: (context: {
+    ssrContext?: {
+        request?: {
+            pathname?: string;
+        };
+    };
+}) => string;
 export declare const getEntryPath: () => string;
 /**
  * Helper function to get language from current pathname

package/dist/types/server/apiPrefix.d.ts

@@ -0,0 +1,7 @@
+type ApiPrefixInput = string | string[] | undefined;
+export declare const collectApiPrefixes: (routes: Array<{
+    isApi?: boolean;
+    urlPath?: string;
+}>, bffPrefix?: ApiPrefixInput) => string[];
+export declare const matchesApiPrefix: (pathname: string, apiPrefixes: string[]) => boolean;
+export {};

package/dist/types/server/detectorOptions.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
+/**
+ * Convert i18next detection options to hono languageDetector options
+ */
+export declare const convertToHonoLanguageDetectorOptions: (languages: string[], fallbackLanguage: string, detectionOptions?: LanguageDetectorOptions) => {
+    supportedLanguages: string[];
+    fallbackLanguage: string;
+    order: ("cookie" | "header" | "path" | "querystring")[];
+    lookupQueryString: string;
+    lookupCookie: string;
+    lookupFromHeaderKey: string;
+    caches?: false | ["cookie"] | undefined;
+    cookieOptions?: {
+        maxAge: number;
+        sameSite: "Lax" | "None" | "Strict";
+        secure: boolean;
+        httpOnly: boolean;
+        domain?: string | undefined;
+    } | undefined;
+    ignoreCase: boolean;
+};