@intlayer/nuxtjs-i18n 9.5.10

package/dist/esm/runtime/define.mjs

@@ -0,0 +1,23 @@
+//#region src/runtime/define.ts
+/**
+* Identity helper for `i18n.config.ts`. Kept for migration: message catalogs
+* move to intlayer dictionaries, so the returned config is never loaded.
+*/
+const defineI18nConfig = (config) => config;
+/** Identity helper for lazy locale files; intlayer bundles dictionaries. */
+const defineI18nLocale = (loader) => loader;
+/** Identity helper for locale detectors; intlayer's middleware detects. */
+const defineI18nLocaleDetector = (detector) => detector;
+/**
+* Page route options. Localized paths come from intlayer's
+* `routing.rewrite` rules, so this is a no-op kept for migration.
+*/
+const defineI18nRoute = (_route) => {};
+/** Dynamic route params per locale; unused with intlayer's routing. */
+const useSetI18nParams = () => () => {};
+/** Preload hint for message keys; dictionaries are already bundled. */
+const useI18nPreloadKeys = (_keys) => {};
+
+//#endregion
+export { defineI18nConfig, defineI18nLocale, defineI18nLocaleDetector, defineI18nRoute, useI18nPreloadKeys, useSetI18nParams };
+//# sourceMappingURL=define.mjs.map

package/dist/esm/runtime/define.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.mjs","names":[],"sources":["../../../src/runtime/define.ts"],"sourcesContent":["import type { I18nOptions } from 'vue-i18n';\nimport type {\n  ConfigLoader,\n  I18nRoute,\n  LocaleLoader,\n  SetI18nParamsFunction,\n} from '../types';\n\n/**\n * Identity helper for `i18n.config.ts`. Kept for migration: message catalogs\n * move to intlayer dictionaries, so the returned config is never loaded.\n */\nexport const defineI18nConfig = <Config extends I18nOptions>(\n  config: ConfigLoader<Config>\n): ConfigLoader<Config> => config;\n\n/** Identity helper for lazy locale files; intlayer bundles dictionaries. */\nexport const defineI18nLocale = <Messages = Record<string, unknown>>(\n  loader: LocaleLoader<Messages>\n): LocaleLoader<Messages> => loader;\n\n/** Identity helper for locale detectors; intlayer's middleware detects. */\nexport const defineI18nLocaleDetector = <\n  Detector extends (...args: never[]) => string,\n>(\n  detector: Detector\n): Detector => detector;\n\n/**\n * Page route options. Localized paths come from intlayer's\n * `routing.rewrite` rules, so this is a no-op kept for migration.\n */\nexport const defineI18nRoute = (_route: I18nRoute | false): void => {};\n\n/** Dynamic route params per locale; unused with intlayer's routing. */\nexport const useSetI18nParams = (): SetI18nParamsFunction => () => {};\n\n/** Preload hint for message keys; dictionaries are already bundled. */\nexport const useI18nPreloadKeys = (_keys: string[]): void => {};\n"],"mappings":";;;;;AAYA,MAAa,oBACX,WACyB;;AAG3B,MAAa,oBACX,WAC2B;;AAG7B,MAAa,4BAGX,aACa;;;;;AAMf,MAAa,mBAAmB,WAAoC,CAAC;;AAGrE,MAAa,+BAAsD,CAAC;;AAGpE,MAAa,sBAAsB,UAA0B,CAAC"}

package/dist/esm/runtime/index.mjs

@@ -0,0 +1,7 @@
+import { STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT } from "../constants.mjs";
+import { useBrowserLocale, useCookieLocale, useLocaleHead, useLocalePath, useLocaleRoute, useRouteBaseName, useSwitchLocalePath } from "./routing.mjs";
+import { useDictionary, useDictionaryDynamic, useI18n } from "./composer.mjs";
+import { defineI18nConfig, defineI18nLocale, defineI18nLocaleDetector, defineI18nRoute, useI18nPreloadKeys, useSetI18nParams } from "./define.mjs";
+import { NuxtLinkLocale } from "./NuxtLinkLocale.mjs";
+
+export { NuxtLinkLocale, STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT, defineI18nConfig, defineI18nLocale, defineI18nLocaleDetector, defineI18nRoute, useBrowserLocale, useCookieLocale, useDictionary, useDictionaryDynamic, useI18n, useI18nPreloadKeys, useLocaleHead, useLocalePath, useLocaleRoute, useRouteBaseName, useSetI18nParams, useSwitchLocalePath };

package/dist/esm/runtime/nuxtPlugin.mjs

@@ -0,0 +1,32 @@
+import { createLocalePath, createLocaleRoute, createRouteBaseName, createSwitchLocalePath, getLocaleHead } from "./routing.mjs";
+import { createI18n } from "@intlayer/vue-i18n";
+import { defineNuxtPlugin } from "#app";
+
+//#region src/runtime/nuxtPlugin.ts
+/**
+* Installs vue-i18n's globals (`$t`, `$d`, `$n`, `v-t`…) and the
+* @nuxtjs/i18n helpers (`$localePath`, `$switchLocalePath`…) on the app.
+*
+* Registered after `nuxt-intlayer`'s plugin, which installs the intlayer
+* client every helper reads the locale from.
+*/
+var nuxtPlugin_default = defineNuxtPlugin({
+	name: "intlayer:nuxtjs-i18n",
+	setup: (nuxtApp) => {
+		const i18n = createI18n({});
+		nuxtApp.vueApp.use(i18n);
+		const router = nuxtApp.$router;
+		return { provide: {
+			i18n: i18n.global,
+			localePath: createLocalePath(router),
+			switchLocalePath: createSwitchLocalePath(router),
+			localeRoute: createLocaleRoute(router),
+			getRouteBaseName: createRouteBaseName(router),
+			localeHead: (options) => getLocaleHead(options, router)
+		} };
+	}
+});
+
+//#endregion
+export { nuxtPlugin_default as default };
+//# sourceMappingURL=nuxtPlugin.mjs.map

package/dist/esm/runtime/nuxtPlugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxtPlugin.mjs","names":[],"sources":["../../../src/runtime/nuxtPlugin.ts"],"sourcesContent":["// @ts-nocheck -- Nuxt runtime types are provided at application level\n\nimport { createI18n } from '@intlayer/vue-i18n';\nimport { defineNuxtPlugin } from '#app';\nimport {\n  createLocalePath,\n  createLocaleRoute,\n  createRouteBaseName,\n  createSwitchLocalePath,\n  getLocaleHead,\n} from './routing';\n\n/**\n * Installs vue-i18n's globals (`$t`, `$d`, `$n`, `v-t`…) and the\n * @nuxtjs/i18n helpers (`$localePath`, `$switchLocalePath`…) on the app.\n *\n * Registered after `nuxt-intlayer`'s plugin, which installs the intlayer\n * client every helper reads the locale from.\n */\nexport default defineNuxtPlugin({\n  name: 'intlayer:nuxtjs-i18n',\n  setup: (nuxtApp) => {\n    const i18n = createI18n({});\n    nuxtApp.vueApp.use(i18n);\n\n    const router = nuxtApp.$router;\n\n    return {\n      provide: {\n        i18n: i18n.global,\n        localePath: createLocalePath(router),\n        switchLocalePath: createSwitchLocalePath(router),\n        localeRoute: createLocaleRoute(router),\n        getRouteBaseName: createRouteBaseName(router),\n        localeHead: (options) => getLocaleHead(options, router),\n      },\n    };\n  },\n});\n"],"mappings":";;;;;;;;;;;;AAmBA,yBAAe,iBAAiB;CAC9B,MAAM;CACN,QAAQ,YAAY;EAClB,MAAM,OAAO,WAAW,CAAC,CAAC;EAC1B,QAAQ,OAAO,IAAI,IAAI;EAEvB,MAAM,SAAS,QAAQ;EAEvB,OAAO,EACL,SAAS;GACP,MAAM,KAAK;GACX,YAAY,iBAAiB,MAAM;GACnC,kBAAkB,uBAAuB,MAAM;GAC/C,aAAa,kBAAkB,MAAM;GACrC,kBAAkB,oBAAoB,MAAM;GAC5C,aAAa,YAAY,cAAc,SAAS,MAAM;EACxD,EACF;CACF;AACF,CAAC"}

package/dist/esm/runtime/routing.mjs

@@ -0,0 +1,143 @@
+import { internationalization, routing } from "@intlayer/config/built";
+import { getHTMLTextDir, getLocalizedUrl, getPathWithoutLocale } from "@intlayer/core/localization";
+import { getCachedLocaleFromStorageClient } from "@intlayer/core/utils";
+import { computed, getCurrentInstance, ref } from "vue";
+import { createIntlayerClient } from "vue-intlayer";
+
+//#region src/runtime/routing.ts
+const defaultLocale = internationalization?.defaultLocale ?? "en";
+const localeCodes = internationalization?.locales ?? [defaultLocale];
+/** Separator of localized route names generated by `nuxt-intlayer`. */
+const ROUTE_NAME_SEPARATOR = "___";
+/** @nuxtjs/i18n strategy equivalent to intlayer's `routing.mode`. */
+const strategy = {
+	"prefix-all": "prefix",
+	"prefix-no-default": "prefix_except_default",
+	"no-prefix": "no_prefix",
+	"search-params": "no_prefix"
+}[routing?.mode ?? "prefix-no-default"];
+/** The active locale — intlayer's client singleton, readable anywhere. */
+const getActiveLocale = () => createIntlayerClient().locale.value ?? defaultLocale;
+/** The first browser language matching a configured locale. */
+const detectBrowserLocale = () => typeof navigator === "undefined" ? void 0 : navigator.languages.map((language) => localeCodes.find((code) => code === language) ?? localeCodes.find((code) => code === language.split("-")[0])).find((code) => code !== void 0);
+/** `useBrowserLocale()` — the browser locale among the configured ones. */
+const useBrowserLocale = () => detectBrowserLocale() ?? null;
+/** `useCookieLocale()` — the locale persisted by intlayer, or `''`. */
+const useCookieLocale = () => ref(getCachedLocaleFromStorageClient() ?? "");
+/** The app router, when called from a component setup. */
+const getRouter = () => getCurrentInstance()?.appContext.config.globalProperties.$router;
+/** Current URL path (`/fr/about?tab=1#top`), from the router or `window`. */
+const getCurrentFullPath = (router) => {
+	if (router) return router.currentRoute.value.fullPath;
+	if (typeof window === "undefined") return "/";
+	const { pathname, search, hash } = window.location;
+	return `${pathname}${search}${hash}`;
+};
+const toSearch = (query) => {
+	if (!query) return "";
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) for (const item of Array.isArray(value) ? value : [value]) searchParams.append(key, String(item));
+	const search = searchParams.toString();
+	return search ? `?${search}` : "";
+};
+/**
+* Serialises a route argument to a path with query and hash. A named route
+* is resolved through the router when one is available.
+*/
+const toFullPath = (route, router) => {
+	if (typeof route === "string") return route.startsWith("/") ? route : `/${route}`;
+	if (!route.path && route.name && router?.hasRoute(route.name)) return router.resolve({
+		name: route.name,
+		params: route.params,
+		query: route.query,
+		hash: route.hash
+	}).fullPath;
+	const path = route.path ?? `/${route.name ?? ""}`;
+	const hash = route.hash ? route.hash.startsWith("#") ? route.hash : `#${route.hash}` : "";
+	return `${path.startsWith("/") ? path : `/${path}`}${toSearch(route.query)}${hash}`;
+};
+/** Localizes a full path (query and hash kept) for `locale`. */
+const localizeFullPath = (fullPath, locale) => getLocalizedUrl(getPathWithoutLocale(fullPath), locale);
+/** `localePath(route, locale?)` bound to a router. */
+const createLocalePath = (router) => (route, locale) => localizeFullPath(toFullPath(route, router), locale ?? getActiveLocale());
+/** `switchLocalePath(locale)` bound to a router. */
+const createSwitchLocalePath = (router) => (locale) => localizeFullPath(getCurrentFullPath(router), locale);
+/** `localeRoute(route, locale?)` bound to a router. */
+const createLocaleRoute = (router) => {
+	const localePath = createLocalePath(router);
+	return (route, locale) => {
+		const fullPath = localePath(route, locale);
+		const path = fullPath.split(/[?#]/)[0] ?? fullPath;
+		return typeof route === "string" ? {
+			path,
+			fullPath
+		} : {
+			...route,
+			path,
+			fullPath
+		};
+	};
+};
+/**
+* Route base name bound to a router: strips the locale from a route name
+* (`about___fr`) or path (`/fr/about`).
+*/
+const createRouteBaseName = (router) => (route) => {
+	const name = typeof route === "object" ? route.name : route && !route.startsWith("/") ? route : void 0;
+	if (name) return name.split(ROUTE_NAME_SEPARATOR)[0];
+	const path = typeof route === "string" ? route : route?.path ?? getCurrentFullPath(router);
+	return getPathWithoutLocale(path.split(/[?#]/)[0] ?? path).replace(/^\//, "") || "index";
+};
+/** `localePath(route, locale?)` — the localized path of a route. */
+const useLocalePath = () => createLocalePath(getRouter());
+/** `switchLocalePath(locale)` — the current route in another locale. */
+const useSwitchLocalePath = () => createSwitchLocalePath(getRouter());
+/** `localeRoute(route, locale?)` — a localized route object. */
+const useLocaleRoute = () => createLocaleRoute(getRouter());
+/** `getRouteBaseName(route?)` — a route name without its locale suffix. */
+const useRouteBaseName = () => createRouteBaseName(getRouter());
+/** Resolves `html` attributes and SEO links for the active locale. */
+const resolveLocaleHead = ({ dir = true, lang = true, seo = true }, router) => {
+	const activeLocale = getActiveLocale();
+	const head = { htmlAttrs: {
+		...lang ? { lang: activeLocale } : {},
+		...dir ? { dir: getHTMLTextDir(activeLocale) } : {}
+	} };
+	if (!seo) return head;
+	const basePath = getPathWithoutLocale(getCurrentFullPath(router).split(/[?#]/)[0] ?? "/");
+	head.link = [
+		...localeCodes.map((locale) => ({
+			rel: "alternate",
+			hreflang: locale,
+			href: localizeFullPath(basePath, locale)
+		})),
+		{
+			rel: "alternate",
+			hreflang: "x-default",
+			href: localizeFullPath(basePath, defaultLocale)
+		},
+		{
+			rel: "canonical",
+			href: localizeFullPath(basePath, activeLocale)
+		}
+	];
+	head.meta = [{
+		property: "og:locale",
+		content: activeLocale
+	}, ...localeCodes.filter((locale) => locale !== activeLocale).map((locale) => ({
+		property: "og:locale:alternate",
+		content: locale
+	}))];
+	return head;
+};
+/** `useLocaleHead()` — reactive head attributes for the active locale. */
+const useLocaleHead = (options = {}) => {
+	const router = getRouter();
+	return computed(() => resolveLocaleHead(options, router));
+};
+/** Non-reactive head attributes, for `$localeHead()`. */
+const getLocaleHead = (options = {}, router) => resolveLocaleHead(options, router);
+
+//#endregion
+export { createLocalePath, createLocaleRoute, createRouteBaseName, createSwitchLocalePath, defaultLocale, detectBrowserLocale, getActiveLocale, getCurrentFullPath, getLocaleHead, getRouter, localeCodes, localizeFullPath, strategy, useBrowserLocale, useCookieLocale, useLocaleHead, useLocalePath, useLocaleRoute, useRouteBaseName, useSwitchLocalePath };
+//# sourceMappingURL=routing.mjs.map

package/dist/esm/runtime/routing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.mjs","names":[],"sources":["../../../src/runtime/routing.ts"],"sourcesContent":["import { internationalization, routing } from '@intlayer/config/built';\nimport {\n  getHTMLTextDir,\n  getLocalizedUrl,\n  getPathWithoutLocale,\n} from '@intlayer/core/localization';\nimport { getCachedLocaleFromStorageClient } from '@intlayer/core/utils';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { computed, getCurrentInstance, type Ref, ref } from 'vue';\nimport { createIntlayerClient } from 'vue-intlayer';\nimport type { Router } from 'vue-router';\nimport type {\n  I18nHeadMetaInfo,\n  I18nHeadOptions,\n  LocalePathFunction,\n  LocaleRouteFunction,\n  LocalizedRoute,\n  RouteBaseNameFunction,\n  RouteLocationGeneric,\n  Strategies,\n  SwitchLocalePathFunction,\n} from '../types';\n\nexport const defaultLocale = (internationalization?.defaultLocale ??\n  'en') as string;\nexport const localeCodes = (internationalization?.locales ?? [\n  defaultLocale,\n]) as string[];\n\n/** Separator of localized route names generated by `nuxt-intlayer`. */\nconst ROUTE_NAME_SEPARATOR = '___';\n\n/** @nuxtjs/i18n strategy equivalent to intlayer's `routing.mode`. */\nexport const strategy: Strategies = (\n  {\n    'prefix-all': 'prefix',\n    'prefix-no-default': 'prefix_except_default',\n    'no-prefix': 'no_prefix',\n    'search-params': 'no_prefix',\n  } as const\n)[routing?.mode ?? 'prefix-no-default'];\n\n/** The active locale — intlayer's client singleton, readable anywhere. */\nexport const getActiveLocale = (): string =>\n  (createIntlayerClient().locale.value as string | undefined) ?? defaultLocale;\n\n/** The first browser language matching a configured locale. */\nexport const detectBrowserLocale = (): string | undefined =>\n  typeof navigator === 'undefined'\n    ? undefined\n    : navigator.languages\n        .map(\n          (language) =>\n            localeCodes.find((code) => code === language) ??\n            localeCodes.find((code) => code === language.split('-')[0])\n        )\n        .find((code) => code !== undefined);\n\n/** `useBrowserLocale()` — the browser locale among the configured ones. */\nexport const useBrowserLocale = (): string | null =>\n  detectBrowserLocale() ?? null;\n\n/** `useCookieLocale()` — the locale persisted by intlayer, or `''`. */\nexport const useCookieLocale = (): Ref<string> =>\n  ref(getCachedLocaleFromStorageClient() ?? '');\n\n/** The app router, when called from a component setup. */\nexport const getRouter = (): Router | undefined =>\n  getCurrentInstance()?.appContext.config.globalProperties.$router as\n    | Router\n    | undefined;\n\n/** Current URL path (`/fr/about?tab=1#top`), from the router or `window`. */\nexport const getCurrentFullPath = (router: Router | undefined): string => {\n  if (router) return router.currentRoute.value.fullPath;\n  if (typeof window === 'undefined') return '/';\n  const { pathname, search, hash } = window.location;\n  return `${pathname}${search}${hash}`;\n};\n\nconst toSearch = (\n  query: Exclude<RouteLocationGeneric, string>['query']\n): string => {\n  if (!query) return '';\n\n  const searchParams = new URLSearchParams();\n  for (const [key, value] of Object.entries(query)) {\n    for (const item of Array.isArray(value) ? value : [value]) {\n      searchParams.append(key, String(item));\n    }\n  }\n\n  const search = searchParams.toString();\n  return search ? `?${search}` : '';\n};\n\n/**\n * Serialises a route argument to a path with query and hash. A named route\n * is resolved through the router when one is available.\n */\nconst toFullPath = (\n  route: RouteLocationGeneric,\n  router: Router | undefined\n): string => {\n  if (typeof route === 'string') {\n    return route.startsWith('/') ? route : `/${route}`;\n  }\n\n  if (!route.path && route.name && router?.hasRoute(route.name)) {\n    return router.resolve({\n      name: route.name,\n      params: route.params,\n      query: route.query,\n      hash: route.hash,\n    }).fullPath;\n  }\n\n  const path = route.path ?? `/${route.name ?? ''}`;\n  const hash = route.hash\n    ? route.hash.startsWith('#')\n      ? route.hash\n      : `#${route.hash}`\n    : '';\n\n  return `${path.startsWith('/') ? path : `/${path}`}${toSearch(route.query)}${hash}`;\n};\n\n/** Localizes a full path (query and hash kept) for `locale`. */\nexport const localizeFullPath = (fullPath: string, locale: string): string =>\n  getLocalizedUrl(\n    getPathWithoutLocale(fullPath),\n    locale as LocalesValues\n  ) as string;\n\n/** `localePath(route, locale?)` bound to a router. */\nexport const createLocalePath =\n  (router: Router | undefined): LocalePathFunction =>\n  (route, locale) =>\n    localizeFullPath(toFullPath(route, router), locale ?? getActiveLocale());\n\n/** `switchLocalePath(locale)` bound to a router. */\nexport const createSwitchLocalePath =\n  (router: Router | undefined): SwitchLocalePathFunction =>\n  (locale) =>\n    localizeFullPath(getCurrentFullPath(router), locale);\n\n/** `localeRoute(route, locale?)` bound to a router. */\nexport const createLocaleRoute = (\n  router: Router | undefined\n): LocaleRouteFunction => {\n  const localePath = createLocalePath(router);\n\n  return (route, locale): LocalizedRoute => {\n    const fullPath = localePath(route, locale);\n    const path = fullPath.split(/[?#]/)[0] ?? fullPath;\n\n    return typeof route === 'string'\n      ? { path, fullPath }\n      : { ...route, path, fullPath };\n  };\n};\n\n/**\n * Route base name bound to a router: strips the locale from a route name\n * (`about___fr`) or path (`/fr/about`).\n */\nexport const createRouteBaseName =\n  (router: Router | undefined): RouteBaseNameFunction =>\n  (route) => {\n    // A string without a leading slash is a route name, not a path.\n    const name =\n      typeof route === 'object'\n        ? route.name\n        : route && !route.startsWith('/')\n          ? route\n          : undefined;\n    if (name) return name.split(ROUTE_NAME_SEPARATOR)[0];\n\n    const path =\n      typeof route === 'string'\n        ? route\n        : (route?.path ?? getCurrentFullPath(router));\n    const basePath = getPathWithoutLocale(path.split(/[?#]/)[0] ?? path);\n\n    return basePath.replace(/^\\//, '') || 'index';\n  };\n\n/** `localePath(route, locale?)` — the localized path of a route. */\nexport const useLocalePath = (): LocalePathFunction =>\n  createLocalePath(getRouter());\n\n/** `switchLocalePath(locale)` — the current route in another locale. */\nexport const useSwitchLocalePath = (): SwitchLocalePathFunction =>\n  createSwitchLocalePath(getRouter());\n\n/** `localeRoute(route, locale?)` — a localized route object. */\nexport const useLocaleRoute = (): LocaleRouteFunction =>\n  createLocaleRoute(getRouter());\n\n/** `getRouteBaseName(route?)` — a route name without its locale suffix. */\nexport const useRouteBaseName = (): RouteBaseNameFunction =>\n  createRouteBaseName(getRouter());\n\n/** Resolves `html` attributes and SEO links for the active locale. */\nconst resolveLocaleHead = (\n  { dir = true, lang = true, seo = true }: I18nHeadOptions,\n  router: Router | undefined\n): I18nHeadMetaInfo => {\n  const activeLocale = getActiveLocale();\n  const head: I18nHeadMetaInfo = {\n    htmlAttrs: {\n      ...(lang ? { lang: activeLocale } : {}),\n      ...(dir ? { dir: getHTMLTextDir(activeLocale as LocalesValues) } : {}),\n    },\n  };\n\n  if (!seo) return head;\n\n  const basePath = getPathWithoutLocale(\n    getCurrentFullPath(router).split(/[?#]/)[0] ?? '/'\n  );\n\n  head.link = [\n    ...localeCodes.map((locale) => ({\n      rel: 'alternate',\n      hreflang: locale,\n      href: localizeFullPath(basePath, locale),\n    })),\n    {\n      rel: 'alternate',\n      hreflang: 'x-default',\n      href: localizeFullPath(basePath, defaultLocale),\n    },\n    {\n      rel: 'canonical',\n      href: localizeFullPath(basePath, activeLocale),\n    },\n  ];\n  head.meta = [\n    { property: 'og:locale', content: activeLocale },\n    ...localeCodes\n      .filter((locale) => locale !== activeLocale)\n      .map((locale) => ({ property: 'og:locale:alternate', content: locale })),\n  ];\n\n  return head;\n};\n\n/** `useLocaleHead()` — reactive head attributes for the active locale. */\nexport const useLocaleHead = (\n  options: I18nHeadOptions = {}\n): Ref<I18nHeadMetaInfo> => {\n  const router = getRouter();\n\n  return computed(() => resolveLocaleHead(options, router));\n};\n\n/** Non-reactive head attributes, for `$localeHead()`. */\nexport const getLocaleHead = (\n  options: I18nHeadOptions = {},\n  router?: Router\n): I18nHeadMetaInfo => resolveLocaleHead(options, router);\n"],"mappings":"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"}

package/dist/types/constants.d.ts

@@ -0,0 +1,13 @@
+//#region src/constants.d.ts
+export declare const STRATEGY_PREFIX = "prefix";
+export declare const STRATEGY_PREFIX_EXCEPT_DEFAULT = "prefix_except_default";
+export declare const STRATEGY_PREFIX_AND_DEFAULT = "prefix_and_default";
+export declare const STRATEGY_NO_PREFIX = "no_prefix";
+export declare const STRATEGIES: {
+  readonly PREFIX: 'prefix';
+  readonly PREFIX_EXCEPT_DEFAULT: 'prefix_except_default';
+  readonly PREFIX_AND_DEFAULT: 'prefix_and_default';
+  readonly NO_PREFIX: 'no_prefix';
+};
+//#endregion
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../src/constants.ts"],"mappings":";qBAAa;qBACA;qBACA;qBACA;qBAEA;WACX;WACA;WACA;WACA"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import { STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT } from "./constants.js";
+import { ConfigLoader, Directions, I18nHeadMetaInfo, I18nHeadOptions, I18nRoute, LocaleHeadFunction, LocaleLoader, LocaleObject, LocalePathFunction, LocaleRouteFunction, LocaleType, LocalizedRoute, MetaAttrs, NuxtI18nOptions, RouteBaseNameFunction, RouteLocationGeneric, SetI18nParamsFunction, Strategies, SwitchLocalePathFunction } from "./types.js";
+import nuxtjsI18nModule from "./module.js";
+export { type ConfigLoader, type Directions, type I18nHeadMetaInfo, type I18nHeadOptions, type I18nRoute, type LocaleHeadFunction, type LocaleLoader, type LocaleObject, type LocalePathFunction, type LocaleRouteFunction, type LocaleType, type LocalizedRoute, type MetaAttrs, type NuxtI18nOptions, type RouteBaseNameFunction, type RouteLocationGeneric, STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT, type SetI18nParamsFunction, type Strategies, type SwitchLocalePathFunction, nuxtjsI18nModule as default, nuxtjsI18nModule };

package/dist/types/module.d.ts

@@ -0,0 +1,28 @@
+import { NuxtI18nOptions } from "./types.js";
+import { NuxtModule } from "@nuxt/schema";
+//#region src/module.d.ts
+/**
+ * Nuxt module replacing `@nuxtjs/i18n` with intlayer.
+ *
+ * - installs `nuxt-intlayer` (dictionaries, locale routing, Vite plugin) with
+ *   the `useI18n` caller, so `useI18n({ namespace })` call sites are
+ *   rewritten to import only their dictionary;
+ * - aliases `#i18n` and auto-imports the @nuxtjs/i18n composables;
+ * - registers `<NuxtLinkLocale>` and the plugin providing `$t`,
+ *   `$localePath`, `$switchLocalePath`…
+ *
+ * Locales, default locale and routing come from `intlayer.config.ts`; the
+ * `i18n` key of `nuxt.config` is accepted for migration and ignored.
+ *
+ * @example
+ * ```ts
+ * // nuxt.config.ts
+ * export default defineNuxtConfig({
+ *   modules: ['@intlayer/nuxtjs-i18n'],
+ * });
+ * ```
+ */
+export declare const nuxtjsI18nModule: NuxtModule<NuxtI18nOptions>;
+//#endregion
+export { nuxtjsI18nModule as default };
+//# sourceMappingURL=module.d.ts.map

package/dist/types/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","names":[],"sources":["../../src/module.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;qBAyDa,kBAAkB,WAAW"}

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

@@ -0,0 +1,42 @@
+import { RouteLocationGeneric } from "../types.js";
+import { PropType } from "vue";
+//#region src/runtime/NuxtLinkLocale.d.ts
+/**
+ * `<NuxtLinkLocale to="/about" locale="fr">` — a `<NuxtLink>` whose target
+ * is localized for the active (or given) locale.
+ */
+export declare const NuxtLinkLocale: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  to: {
+    type: PropType<RouteLocationGeneric>;
+    default: any;
+  };
+  href: {
+    type: PropType<RouteLocationGeneric>;
+    default: any;
+  };
+  locale: {
+    type: StringConstructor;
+    default: any;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  to: {
+    type: PropType<RouteLocationGeneric>;
+    default: any;
+  };
+  href: {
+    type: PropType<RouteLocationGeneric>;
+    default: any;
+  };
+  locale: {
+    type: StringConstructor;
+    default: any;
+  };
+}>> & Readonly<{}>, {
+  to: RouteLocationGeneric;
+  href: RouteLocationGeneric;
+  locale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//# sourceMappingURL=NuxtLinkLocale.d.ts.map

package/dist/types/runtime/NuxtLinkLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NuxtLinkLocale.d.ts","names":[],"sources":["../../../src/runtime/NuxtLinkLocale.ts"],"mappings":";;;;;;;qBASa,8BAAc,8BAAA;;IAKK,MAAA,SAAS;;;;IAIT,MAAA,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;qCAsBvC"}

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

@@ -0,0 +1,66 @@
+import { LocaleObject, Strategies } from "../types.js";
+import { ComputedRef } from "vue";
+import { Dictionary } from "@intlayer/types/dictionary";
+import { DictionaryKeys, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { LooseComposer, ScopedComposer, TypedComposer } from "@intlayer/vue-i18n";
+//#region src/runtime/composer.d.ts
+/** What @nuxtjs/i18n adds to vue-i18n's composer. */
+export type NuxtI18nComposerExtras = {
+  locales: ComputedRef<LocaleObject[]>;
+  localeCodes: ComputedRef<string[]>;
+  localeProperties: ComputedRef<LocaleObject>;
+  defaultLocale: string;
+  strategy: Strategies;
+  /** Activates a locale, persists it and navigates to the localized route. */
+  setLocale: (locale: string) => Promise<void>;
+  getBrowserLocale: () => string | undefined;
+  getLocaleCookie: () => string | undefined;
+  setLocaleCookie: (locale: string) => void;
+  /** Kept for API parity: locale switches are never deferred. */
+  finalizePendingLocaleChange: () => Promise<void>;
+  /** Kept for API parity: locale switches are never deferred. */
+  waitForPendingLocaleChange: () => Promise<void>;
+  /** Kept for API parity: intlayer dictionaries need no loading. */
+  loadLocaleMessages: (locale: string) => Promise<void>;
+};
+/** The @nuxtjs/i18n locale object describing a locale code. */
+export declare const toLocaleObject: (code: string) => LocaleObject;
+type ComposerOptions = Record<string, unknown>;
+type NuxtUseI18n = {
+  <N extends DictionaryKeys>(options: ComposerOptions & {
+    namespace: N;
+  }): TypedComposer<N> & NuxtI18nComposerExtras;
+  (options?: ComposerOptions & {
+    namespace?: undefined;
+  }): LooseComposer & NuxtI18nComposerExtras;
+};
+type NuxtUseDictionary = {
+  <T extends Dictionary>(dictionary: T, options?: ComposerOptions & {
+    namespace?: undefined;
+  }): TypedComposer<T['key'] & DictionaryKeys> & NuxtI18nComposerExtras;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, options: ComposerOptions & {
+    namespace: Prefix;
+  }): ScopedComposer<T['key'] & DictionaryKeys, Prefix> & NuxtI18nComposerExtras;
+};
+type NuxtUseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>>, key: K, options?: ComposerOptions & {
+    namespace?: undefined;
+  }): TypedComposer<K> & NuxtI18nComposerExtras;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryLoaders: StrictModeLocaleMap<() => Promise<T>>, key: K, options: ComposerOptions & {
+    namespace: Prefix;
+  }): ScopedComposer<K, Prefix> & NuxtI18nComposerExtras;
+};
+/**
+ * `useI18n()` of @nuxtjs/i18n: vue-i18n's composer (backed by intlayer
+ * dictionaries) plus the Nuxt locale helpers.
+ */
+export declare const useI18n: NuxtUseI18n;
+/**
+ * Build-optimized `useI18n({ namespace })`: the optimize pass rewrites the
+ * call to pass the dictionary, so only it reaches the bundle.
+ */
+export declare const useDictionary: NuxtUseDictionary;
+/** Per-locale lazy variant of {@link useDictionary}. */
+export declare const useDictionaryDynamic: NuxtUseDictionaryDynamic;
+//#endregion
+//# sourceMappingURL=composer.d.ts.map

package/dist/types/runtime/composer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer.d.ts","names":[],"sources":["../../../src/runtime/composer.ts"],"mappings":";;;;;;;YAmCY;EACV,SAAS,YAAY;EACrB,aAAa;EACb,kBAAkB,YAAY;EAC9B;EACA,UAAU;;EAEV,YAAY,mBAAmB;EAC/B;EACA;EACA,kBAAkB;;EAElB,mCAAmC;;EAEnC,kCAAkC;;EAElC,qBAAqB,mBAAmB;;;qBAI7B,iBAAc,iBAAmB;KA+CzC,kBAAkB;KAElB;GACF,UAAU,gBACT,SAAS;IAAoB,WAAW;MACvC,cAAc,KAAK;GAEpB,UAAU;IAAoB;MAC7B,gBAAgB;;KAGhB;GACF,UAAU,YACT,YAAY,GACZ,UAAU;IAAoB;MAC7B,cAAc,WAAW,kBAAkB;GAC7C,UAAU,YAAY,uBACrB,YAAY,GACZ,SAAS;IAAoB,WAAW;MACvC,eAAe,WAAW,gBAAgB,UAAU;;KAGpD;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,UAAU;IAAoB;MAC7B,cAAc,KAAK;GACrB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,SAAS;IAAoB,WAAW;MACvC,eAAe,GAAG,UAAU;;;;;;qBAOpB,SAGN;;;;;qBAMM,eAMN;;qBAGM,sBAON"}

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

@@ -0,0 +1,23 @@
+import { ConfigLoader, I18nRoute, LocaleLoader, SetI18nParamsFunction } from "../types.js";
+import { I18nOptions } from "vue-i18n";
+//#region src/runtime/define.d.ts
+/**
+ * Identity helper for `i18n.config.ts`. Kept for migration: message catalogs
+ * move to intlayer dictionaries, so the returned config is never loaded.
+ */
+export declare const defineI18nConfig: <Config extends I18nOptions>(config: ConfigLoader<Config>) => ConfigLoader<Config>;
+/** Identity helper for lazy locale files; intlayer bundles dictionaries. */
+export declare const defineI18nLocale: <Messages = Record<string, unknown>>(loader: LocaleLoader<Messages>) => LocaleLoader<Messages>;
+/** Identity helper for locale detectors; intlayer's middleware detects. */
+export declare const defineI18nLocaleDetector: <Detector extends (...args: never[]) => string>(detector: Detector) => Detector;
+/**
+ * Page route options. Localized paths come from intlayer's
+ * `routing.rewrite` rules, so this is a no-op kept for migration.
+ */
+export declare const defineI18nRoute: (_route: I18nRoute | false) => void;
+/** Dynamic route params per locale; unused with intlayer's routing. */
+export declare const useSetI18nParams: () => SetI18nParamsFunction;
+/** Preload hint for message keys; dictionaries are already bundled. */
+export declare const useI18nPreloadKeys: (_keys: string[]) => void;
+//#endregion
+//# sourceMappingURL=define.d.ts.map

package/dist/types/runtime/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","names":[],"sources":["../../../src/runtime/define.ts"],"mappings":";;;;;;;qBAYa,mBAAoB,eAAe,aAAW,QACjD,aAAa,YACpB,aAAa;;qBAGH,mBAAoB,WAAW,yBAAuB,QACzD,aAAa,cACpB,aAAa;;qBAGH,2BACX,qBAAqB,0BAAwB,UAEnC,aACT;;;;;qBAMU,kBAAe,QAAY;;qBAG3B,wBAAuB;;qBAGvB,qBAAkB"}

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

@@ -0,0 +1,6 @@
+import { STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT } from "../constants.js";
+import { NuxtLinkLocale } from "./NuxtLinkLocale.js";
+import { NuxtI18nComposerExtras, useDictionary, useDictionaryDynamic, useI18n } from "./composer.js";
+import { defineI18nConfig, defineI18nLocale, defineI18nLocaleDetector, defineI18nRoute, useI18nPreloadKeys, useSetI18nParams } from "./define.js";
+import { useBrowserLocale, useCookieLocale, useLocaleHead, useLocalePath, useLocaleRoute, useRouteBaseName, useSwitchLocalePath } from "./routing.js";
+export { type NuxtI18nComposerExtras, NuxtLinkLocale, STRATEGIES, STRATEGY_NO_PREFIX, STRATEGY_PREFIX, STRATEGY_PREFIX_AND_DEFAULT, STRATEGY_PREFIX_EXCEPT_DEFAULT, defineI18nConfig, defineI18nLocale, defineI18nLocaleDetector, defineI18nRoute, useBrowserLocale, useCookieLocale, useDictionary, useDictionaryDynamic, useI18n, useI18nPreloadKeys, useLocaleHead, useLocalePath, useLocaleRoute, useRouteBaseName, useSetI18nParams, useSwitchLocalePath };

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

@@ -0,0 +1,12 @@
+//#region src/runtime/nuxtPlugin.d.ts
+/**
+ * Installs vue-i18n's globals (`$t`, `$d`, `$n`, `v-t`…) and the
+ * @nuxtjs/i18n helpers (`$localePath`, `$switchLocalePath`…) on the app.
+ *
+ * Registered after `nuxt-intlayer`'s plugin, which installs the intlayer
+ * client every helper reads the locale from.
+ */
+declare const _default: any;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=nuxtPlugin.d.ts.map

package/dist/types/runtime/nuxtPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxtPlugin.d.ts","names":[],"sources":["../../../src/runtime/nuxtPlugin.ts"],"mappings":";;;;;;;;cAYA"}

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

@@ -0,0 +1,8 @@
+//#region src/runtime/nuxtVirtualModules.d.ts
+/** Nuxt virtual modules, typed by the application's generated `.nuxt` types. */
+declare module '#components' {
+  import type { Component } from 'vue';
+  export const NuxtLink: Component;
+}
+export {};
+//# sourceMappingURL=nuxtVirtualModules.d.ts.map

package/dist/types/runtime/nuxtVirtualModules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxtVirtualModules.d.ts","names":[],"sources":["../../../src/runtime/nuxtVirtualModules.d.ts"],"mappings":";;;gBAEgB;eAED,UAAU"}

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

@@ -0,0 +1,47 @@
+import { I18nHeadMetaInfo, I18nHeadOptions, LocalePathFunction, LocaleRouteFunction, RouteBaseNameFunction, Strategies, SwitchLocalePathFunction } from "../types.js";
+import { Ref } from "vue";
+import { Router } from "vue-router";
+//#region src/runtime/routing.d.ts
+export declare const defaultLocale: string;
+export declare const localeCodes: string[];
+/** @nuxtjs/i18n strategy equivalent to intlayer's `routing.mode`. */
+export declare const strategy: Strategies;
+/** The active locale — intlayer's client singleton, readable anywhere. */
+export declare const getActiveLocale: () => string;
+/** The first browser language matching a configured locale. */
+export declare const detectBrowserLocale: () => string | undefined;
+/** `useBrowserLocale()` — the browser locale among the configured ones. */
+export declare const useBrowserLocale: () => string | null;
+/** `useCookieLocale()` — the locale persisted by intlayer, or `''`. */
+export declare const useCookieLocale: () => Ref<string>;
+/** The app router, when called from a component setup. */
+export declare const getRouter: () => Router | undefined;
+/** Current URL path (`/fr/about?tab=1#top`), from the router or `window`. */
+export declare const getCurrentFullPath: (router: Router | undefined) => string;
+/** Localizes a full path (query and hash kept) for `locale`. */
+export declare const localizeFullPath: (fullPath: string, locale: string) => string;
+/** `localePath(route, locale?)` bound to a router. */
+export declare const createLocalePath: (router: Router | undefined) => LocalePathFunction;
+/** `switchLocalePath(locale)` bound to a router. */
+export declare const createSwitchLocalePath: (router: Router | undefined) => SwitchLocalePathFunction;
+/** `localeRoute(route, locale?)` bound to a router. */
+export declare const createLocaleRoute: (router: Router | undefined) => LocaleRouteFunction;
+/**
+ * Route base name bound to a router: strips the locale from a route name
+ * (`about___fr`) or path (`/fr/about`).
+ */
+export declare const createRouteBaseName: (router: Router | undefined) => RouteBaseNameFunction;
+/** `localePath(route, locale?)` — the localized path of a route. */
+export declare const useLocalePath: () => LocalePathFunction;
+/** `switchLocalePath(locale)` — the current route in another locale. */
+export declare const useSwitchLocalePath: () => SwitchLocalePathFunction;
+/** `localeRoute(route, locale?)` — a localized route object. */
+export declare const useLocaleRoute: () => LocaleRouteFunction;
+/** `getRouteBaseName(route?)` — a route name without its locale suffix. */
+export declare const useRouteBaseName: () => RouteBaseNameFunction;
+/** `useLocaleHead()` — reactive head attributes for the active locale. */
+export declare const useLocaleHead: (options?: I18nHeadOptions) => Ref<I18nHeadMetaInfo>;
+/** Non-reactive head attributes, for `$localeHead()`. */
+export declare const getLocaleHead: (options?: I18nHeadOptions, router?: Router) => I18nHeadMetaInfo;
+//#endregion
+//# sourceMappingURL=routing.d.ts.map

package/dist/types/runtime/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../../src/runtime/routing.ts"],"mappings":";;;;qBAuBa;qBAEA;;qBAQA,UAAU;;qBAUV;;qBAIA;;qBAYA;;qBAIA,uBAAsB;;qBAItB,iBAAgB;;qBAMhB,qBAAkB,QAAY;;qBAuD9B,mBAAgB,kBAAoB;;qBAOpC,mBAAgB,QAClB,uBAAqB;;qBAKnB,yBAAsB,QACxB,uBAAqB;;qBAKnB,oBAAiB,QACpB,uBACP;;;;;qBAiBU,sBAAmB,QACrB,uBAAqB;;qBAqBnB,qBAAoB;;qBAIpB,2BAA0B;;qBAI1B,sBAAqB;;qBAIrB,wBAAuB;;qBAiDvB,gBAAa,UACf,oBACR,IAAI;;qBAOM,gBAAa,UACf,iBAAe,SACf,WACR"}

package/dist/types/types.d.ts

@@ -0,0 +1,82 @@
+import { I18nOptions } from "vue-i18n";
+//#region src/types.d.ts
+export type Strategies = 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
+export type Directions = 'ltr' | 'rtl' | 'auto';
+export type LocaleObject<T extends string = string> = {
+  code: T;
+  name?: string;
+  dir?: Directions;
+  domain?: string;
+  file?: string;
+  files?: string[];
+  isCatchallLocale?: boolean;
+  language?: string;
+  /** @deprecated Use `language`. */
+  iso?: string;
+};
+export type LocaleType = string | LocaleObject;
+/** Page-level route options of `defineI18nRoute()`. */
+export type I18nRoute = {
+  paths?: Partial<Record<string, `/${string}`>>;
+  locales?: string[];
+};
+export type I18nHeadOptions = {
+  dir?: boolean;
+  lang?: boolean;
+  seo?: boolean | {
+    canonicalQueries?: string[];
+  };
+};
+export type MetaAttrs = Record<string, string | undefined>;
+export type I18nHeadMetaInfo = {
+  htmlAttrs?: MetaAttrs;
+  link?: MetaAttrs[];
+  meta?: MetaAttrs[];
+};
+/** A route as accepted by the localization helpers. */
+export type RouteLocationGeneric = string | {
+  name?: string;
+  path?: string;
+  query?: Record<string, string | number | (string | number)[]>;
+  hash?: string;
+  params?: Record<string, string | string[]>;
+};
+/** A route object returned by `localeRoute()`. */
+export type LocalizedRoute = {
+  path: string;
+  fullPath: string;
+  name?: string;
+  query?: Record<string, string | number | (string | number)[]>;
+  hash?: string;
+  params?: Record<string, string | string[]>;
+};
+export type LocalePathFunction = (route: RouteLocationGeneric, locale?: string) => string;
+export type SwitchLocalePathFunction = (locale: string) => string;
+export type LocaleRouteFunction = (route: RouteLocationGeneric, locale?: string) => LocalizedRoute;
+export type RouteBaseNameFunction = (route?: RouteLocationGeneric) => string | undefined;
+export type LocaleHeadFunction = (options?: I18nHeadOptions) => I18nHeadMetaInfo;
+export type SetI18nParamsFunction = (params: Record<string, Record<string, string | string[]>>) => void;
+export type LocaleLoader<Messages = Record<string, unknown>> = (locale: string) => Messages | Promise<Messages>;
+export type ConfigLoader<Config extends I18nOptions = I18nOptions> = () => Config | Promise<Config>;
+/**
+ * `i18n` options of `nuxt.config`. Intlayer's configuration owns locales,
+ * default locale and routing; these are accepted for migration and ignored.
+ */
+export type NuxtI18nOptions = {
+  defaultLocale?: string;
+  locales?: LocaleType[];
+  strategy?: Strategies;
+  lazy?: boolean;
+  langDir?: string;
+  rootRedirect?: string | null;
+  vueI18n?: string;
+  detectBrowserLanguage?: {
+    alwaysRedirect?: boolean;
+    cookieKey?: string;
+    fallbackLocale?: string | null;
+    redirectOn?: 'all' | 'root' | 'no prefix';
+    useCookie?: boolean;
+  } | false;
+};
+//#endregion
+//# sourceMappingURL=types.d.ts.map