@intlayer/types 8.4.4 → 8.4.6

package/dist/types/config.d.ts

@@ -1,2 +1,1168 @@
-import { C as SystemConfig, S as StrictMode, _ as RewriteRule, a as CommonAiConfig, b as Schema, c as CookiesAttributes, d as EditorConfig, f as InternationalizationConfig, g as RewriteObject, h as LogFunctions, i as BuildConfig, l as CustomIntlayerConfig, m as LogConfig, n as AiProviderConfigMap, o as CompilerConfig, p as IntlayerConfig, r as AiProviders, s as ContentConfig, t as AiConfig, u as DictionaryConfig, v as RewriteRules, w as URLType, x as StorageAttributes, y as RoutingConfig } from "./config-CE_7T8Jh.js";
-export { AiConfig, AiProviderConfigMap, AiProviders, BuildConfig, CommonAiConfig, CompilerConfig, ContentConfig, CookiesAttributes, CustomIntlayerConfig, DictionaryConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, Schema, StorageAttributes, StrictMode, SystemConfig, URLType };
+import { Locale } from "./allLocales.js";
+import { LocalesValues, StrictModeLocaleMap } from "./module_augmentation.js";
+import { ContentAutoTransformation, DictionaryLocation, Fill } from "./dictionary.js";
+import { Plugin } from "./plugin.js";
+
+//#region src/config.d.ts
+/**
+* Structural type for schema validation, compatible with Zod and other
+* schema libraries that implement safeParse. Avoids a hard dependency on Zod.
+*/
+type Schema = {
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: unknown;
+    error?: unknown;
+  };
+};
+type StrictMode = "strict" | "inclusive" | "loose";
+type Protocol = "http" | "https";
+type URLPath = `/${string}`;
+type OptionalURLPath = `/${string}` | "";
+type LocalhostURL = `${Protocol}://localhost:${number}${OptionalURLPath}`;
+type IPUrl = `${Protocol}://${number}.${string}${OptionalURLPath}` | `${Protocol}://${number}.${string}:${number}${OptionalURLPath}`;
+type DomainURL = `${Protocol}://${string}.${string}${OptionalURLPath}`;
+type URLType = LocalhostURL | IPUrl | DomainURL | (string & {});
+/**
+* Configuration for internationalization settings
+*/
+type InternationalizationConfig = {
+  /**
+  * Locales available in the application
+  *
+  * Default: [Locales.ENGLISH]
+  *
+  * You can define a list of available locales to support in the application.
+  */
+  locales: Locale[];
+  /**
+  * Locales required by TypeScript to ensure strong implementations of internationalized content using typescript.
+  *
+  * Default: []
+  *
+  * If empty, all locales are required in `strict` mode.
+  *
+  * Ensure required locales are also defined in the `locales` field.
+  */
+  requiredLocales: Locale[];
+  /**
+  * Ensure strong implementations of internationalized content using typescript.
+  * - If set to "strict", the translation `t` function will require each declared locales to be defined. If one locale is missing, or if a locale is not declared in your config, it will throw an error.
+  * - If set to "inclusive", the translation `t` function will require each declared locales to be defined. If one locale is missing, it will throw a warning. But will accept if a locale is not declared in your config, but exist.
+  * - If set to "loose", the translation `t` function will accept any existing locale.
+  *
+  * Default: "inclusive"
+  */
+  strictMode: StrictMode;
+  /**
+  * Default locale of the application for fallback
+  *
+  * Default: Locales.ENGLISH
+  *
+  * Used to specify a fallback locale in case no other locale is set.
+  */
+  defaultLocale: Locale;
+};
+type CookiesAttributes = {
+  /**
+  * Type of the storage
+  *
+  * The type of the storage. It can be 'cookie'.
+  */
+  type: "cookie";
+  /**
+  * Cookie name to store the locale information
+  *
+  * Default: 'INTLAYER_LOCALE'
+  *
+  * The cookie key where the locale information is stored.
+  */
+  name?: string;
+  /**
+  * Cookie domain to store the locale information
+  *
+  * Default: undefined
+  *
+  * Define the domain where the cookie is available. Defaults to
+  * the domain of the page where the cookie was created.
+  */
+  domain?: string;
+  /**
+  * Cookie path to store the locale information
+  *
+  * Default: undefined
+  *
+  * Define the path where the cookie is available. Defaults to '/'
+  */
+  path?: string;
+  /**
+  * Cookie secure to store the locale information
+  *
+  * Default: undefined
+  *
+  * A Boolean indicating if the cookie transmission requires a
+  * secure protocol (https). Defaults to false.
+  */
+  secure?: boolean;
+  /**
+  * Cookie httpOnly to store the locale information
+  *
+  * Default: undefined
+  *
+  * The cookie httpOnly where the locale information is stored.
+  */
+  httpOnly?: boolean;
+  /**
+  * Cookie sameSite to store the locale information
+  *
+  * Default: undefined
+  *
+  * Asserts that a cookie must not be sent with cross-origin requests,
+  * providing some protection against cross-site request forgery
+  * attacks (CSRF)
+  */
+  sameSite?: "strict" | "lax" | "none";
+  /**
+  * Cookie expires to store the locale information
+  *
+  * Default: undefined
+  *
+  * Define when the cookie will be removed. Value can be a Number
+  * which will be interpreted as days from time of creation or a
+  * Date instance. If omitted, the cookie becomes a session cookie.
+  */
+  expires?: Date | number | undefined;
+};
+type StorageAttributes = {
+  /**
+  * Storage type where the locale is stored
+  *
+  * Determines whether the locale is persisted in `localStorage` (across sessions)
+  * or `sessionStorage` (cleared when the browser session ends) or `header` (from the request header).
+  */
+  type: "localStorage" | "sessionStorage" | "header";
+  /**
+  * Storage key to store the locale information
+  *
+  * Default: 'INTLAYER_LOCALE'
+  *
+  * The key name used in the client storage to save the locale.
+  */
+  name?: string;
+};
+type RewriteRule<T extends string = string> = {
+  canonical: T;
+  localized: StrictModeLocaleMap<string>;
+};
+type RewriteRules = {
+  rules: RewriteRule[];
+};
+type RewriteObject = {
+  /**
+  * Used for client-side URL generation (e.g., getLocalizedUrl).
+  * Patterns are usually stripped of locale prefixes as the core logic handles prefixing.
+  */
+  url: RewriteRules;
+  /**
+  * Used for Next.js middleware / proxy.
+  * Patterns usually include [locale] or :locale to match incoming full URLs.
+  */
+  nextjs?: RewriteRules;
+  /**
+  * Used for Vite proxy middleware.
+  */
+  vite?: RewriteRules;
+};
+/**
+* Configuration for routing behaviors
+*/
+type RoutingConfig = {
+  /**
+  * Rewrite the URLs to a localized path
+  *
+  * Example:
+  * ```ts
+  *  // ...
+  *  routing: {
+  *    rewrite: nextjsRewrite({
+  *      '[locale]/about': {
+  *        fr: '[locale]/a-propos'
+  *      }
+  *    })
+  *  }
+  * ```
+  */
+  rewrite?: Record<URLPath, StrictModeLocaleMap<URLPath>> | RewriteObject;
+  /**
+  * URL routing mode for locale handling
+  *
+  * Controls how locales are represented in application URLs:
+  * - 'prefix-no-default': Prefix all locales except the default locale
+  * - 'prefix-all': Prefix all locales including the default locale
+  * - 'no-prefix': No locale prefixing in URLs
+  * - 'search-params': Use search parameters for locale handling
+  *
+  * Examples with defaultLocale = 'en':
+  * - 'prefix-no-default': /dashboard (en) or /fr/dashboard (fr)
+  * - 'prefix-all': /en/dashboard (en) or /fr/dashboard (fr)
+  * - 'no-prefix': /dashboard (locale handled via other means)
+  * - 'search-params': /dashboard?locale=fr
+  *
+  * Note: This setting do not impact the cookie, or locale storage management.
+  *
+  * Default: 'prefix-no-default'
+  */
+  mode: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params";
+  /**
+  * Configuration for storing the locale in the client (localStorage or sessionStorage)
+  *
+  * If false, the locale will not be stored by the middleware.
+  * If true, the locale storage will consider all default values.
+  *
+  * Default: ['cookie', 'header]
+  *
+  * Note: Check out GDPR compliance for cookies. See https://gdpr.eu/cookies/
+  * Note: useLocale hook includes a prop to disable the cookie storage.
+  * Note: Even if storage is disabled, the middleware will still detect the locale from the request header (1- check for `x-intlayer-locale`, 2- fallback to the `accept-language`).
+  *
+  * Recommendation:
+  * - Config both localStorage and cookies for the storage of the locale if you want to support GDPR compliance.
+  * - Disable the cookie storage by default on the useLocale hook by waiting for the user to consent to the cookie storage.
+  */
+  storage: false | "cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes | ("cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes)[];
+  /**
+  * Base path for application URLs
+  *
+  * Default: ''
+  *
+  * Defines the base path where the application is accessible from.
+  */
+  basePath: string;
+};
+/**
+* Configuration for intlayer editor
+*/
+type EditorConfig = {
+  /**
+  * URL of the application. Used to restrict the origin of the editor for security reasons.
+  *
+  * Default: ''
+  */
+  applicationURL?: URLType;
+  editorURL?: URLType;
+  cmsURL?: URLType;
+  backendURL?: URLType;
+  /**
+  * Indicates if the application interact with the visual editor
+  *
+  * Default: false;
+  *
+  * If true, the editor will be able to interact with the application.
+  * If false, the editor will not be able to interact with the application.
+  * In any case, the editor can only be enabled by the visual editor.
+  * Disabling the editor for specific environments is a way to enforce the security.
+  *
+  * Usage:
+  * ```js
+  * {
+  *  // Other configurations
+  *  editor: {
+  *   enabled: process.env.NODE_ENV !== 'production',
+  *  }
+  * };
+  * ```
+  *
+  */
+  enabled: boolean;
+  /** Port of the editor server
+  *
+  * Default: 8000
+  */
+  port: number;
+  /**
+  * clientId and clientSecret allow the intlayer packages to authenticate with the backend using oAuth2 authentication.
+  * An access token is use to authenticate the user related to the project.
+  * To get an access token, go to https://app.intlayer.org/project and create an account.
+  *
+  * Default: undefined
+  *
+  * > Important: The clientId and clientSecret should be kept secret and not shared publicly. Please ensure to keep them in a secure location, such as environment variables.
+  */
+  clientId?: string;
+  /**
+  * clientId and clientSecret allow the intlayer packages to authenticate with the backend using oAuth2 authentication.
+  * An access token is use to authenticate the user related to the project.
+  * To get an access token, go to https://app.intlayer.org/project and create an account.
+  *
+  * Default: undefined
+  *
+  * > Important: The clientId and clientSecret should be kept secret and not shared publicly. Please ensure to keep them in a secure location, such as environment variables.
+  */
+  clientSecret?: string;
+  /**
+  * Strategy for prioritizing dictionaries. If a dictionary is both present online and locally, the content will be merge.
+  * However, is a field is defined in both dictionary, this setting determines which fields takes the priority over the other.
+  *
+  * Default: 'local_first'
+  *
+  * The strategy for prioritizing dictionaries. It can be either 'local_first' or 'distant_first'.
+  * - 'local_first': The first dictionary found in the locale is used.
+  * - 'distant_first': The first dictionary found in the distant locales is used.
+  */
+  dictionaryPriorityStrategy: "local_first" | "distant_first";
+  /**
+  * Indicates if the application should hot reload the locale configurations when a change is detected.
+  * For example, when a new dictionary is added or updated, the application will update the content tu display in the page.
+  *
+  * Default: true
+  */
+  liveSync: boolean;
+  /**
+  * Port of the live sync server
+  *
+  * Default: 4000
+  */
+  liveSyncPort: number;
+  /**
+  * URL of the live sync server in case of remote live sync server
+  *
+  * Default: `http://localhost:${liveSyncPort}`
+  */
+  liveSyncURL: URLType;
+};
+declare enum AiProviders {
+  OPENAI = "openai",
+  ANTHROPIC = "anthropic",
+  MISTRAL = "mistral",
+  DEEPSEEK = "deepseek",
+  GEMINI = "gemini",
+  OLLAMA = "ollama",
+  OPENROUTER = "openrouter",
+  ALIBABA = "alibaba",
+  FIREWORKS = "fireworks",
+  GROQ = "groq",
+  HUGGINGFACE = "huggingface",
+  BEDROCK = "bedrock",
+  GOOGLEVERTEX = "googlevertex",
+  GOOGLEGENERATIVEAI = "googlegenerativeai",
+  TOGETHERAI = "togetherai"
+}
+type CommonAiConfig = {
+  /**
+  * API model
+  *
+  * The model to use for the AI features of Intlayer.
+  *
+  * Example: 'gpt-4o-2024-11-20'
+  *
+  */
+  model?: string;
+  /**
+  *  temperature
+  *
+  * The temperature to use for the AI features of Intlayer.
+  * The temperature controls the randomness of the AI's responses.
+  * A higher temperature will make the AI more creative and less predictable.
+  *
+  * Example: 0.1
+  */
+  temperature?: number;
+  /**
+  * API key
+  *
+  * Use your own OpenAI API key to use the AI features of Intlayer.
+  * If you don't have an OpenAI API key, you can get one for free at https://openai.com/api/.
+  *
+  */
+  apiKey?: string;
+  /**
+  * Application context
+  *
+  * The context of the application to use for the AI features of Intlayer.
+  *
+  * Example: 'This is a website for a company that sells products online.'
+  */
+  applicationContext?: string;
+  /**
+  * Base URL
+  *
+  * The base URL to use for the AI features of Intlayer.
+  *
+  * Example: 'https://api.openai.com/v1'
+  */
+  baseURL?: string;
+  /**
+  * Data serialization
+  *
+  * The data serialization format to use for the AI features of Intlayer.
+  *
+  * Default: 'json'
+  */
+  dataSerialization?: "json" | "toon";
+};
+type AiProviderConfigMap = {};
+type AiConfigUnion = { [P in keyof AiProviderConfigMap]: {
+  provider: P | `${P}`;
+} & AiProviderConfigMap[P] }[keyof AiProviderConfigMap];
+type AiConfig = CommonAiConfig & (AiConfigUnion | {
+  provider?: AiProviders | `${AiProviders}`;
+});
+type BuildConfig = {
+  /**
+  * Indicates the mode of the build
+  *
+  * Default: 'auto'
+  *
+  * If 'auto', the build will be enabled automatically when the application is built.
+  * If 'manual', the build will be set only when the build command is executed.
+  *
+  * Can be used to disable dictionaries build, for instance when execution on Node.js environment should be avoided.
+  */
+  mode: "auto" | "manual";
+  /**
+  * Indicates if the build should be optimized
+  *
+  * Default: undefined
+  *
+  * If true, the build will be optimized.
+  * If false, the build will not be optimized.
+  *
+  * Intlayer will replace all calls of dictionaries to optimize chunking. That way the final bundle will import only the dictionaries that are used.
+  * All imports will stay as static import to avoid async processing when loading the dictionaries.
+  *
+  * Note:
+  * - Intlayer will replace all call of `useIntlayer` with the defined mode by the `importMode` option.
+  * - Intlayer will replace all call of `getIntlayer` with `getDictionary`.
+  * - This option relies on the `@intlayer/babel` and `@intlayer/swc` plugins.
+  * - Ensure all keys are declared statically in the `useIntlayer` calls. e.g. `useIntlayer('navbar')`.
+  */
+  optimize?: boolean;
+  /**
+  * Indicates the mode of import to use for the dictionaries.
+  *
+  * Available modes:
+  * - "static": The dictionaries are imported statically.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionary`.
+  * - "dynamic": The dictionaries are imported dynamically in a synchronous component using the suspense API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  * - "fetch": The dictionaries are imported dynamically using the live sync API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  *   Fetch mode will use the live sync API to fetch the dictionaries. If the API call fails, the dictionaries will be imported dynamically as "dynamic" mode.
+  *
+  * Default: "static"
+  *
+  * By default, when a dictionary is loaded, it imports content for all locales as it's imported statically.
+  *
+  * Note:
+  * - Dynamic imports rely on Suspense and may slightly impact rendering performance.
+  * - If desabled all locales will be loaded at once, even if they are not used.
+  * - This option relies on the `@intlayer/babel` and `@intlayer/swc` plugins.
+  * - Ensure all keys are declared statically in the `useIntlayer` calls. e.g. `useIntlayer('navbar')`.
+  * - This option will be ignored if `optimize` is disabled.
+  * - This option will not impact the `getIntlayer`, `getDictionary`, `useDictionary`, `useDictionaryAsync` and `useDictionaryDynamic` functions. You can still use them to refine you code on manual optimization.
+  * - The "fetch" allows to sync the dictionaries to the live sync server.
+  * - Require static key to work. Example of invalid code: `const navbarKey = "my-key"; useIntlayer(navbarKey)`.
+  *
+  * @deprecated Use `dictionary.importMode` instead.
+  */
+  importMode?: "static" | "dynamic" | "fetch";
+  /**
+  * Pattern to traverse the code to optimize.
+  *
+  * Allows to avoid to traverse the code that is not relevant to the optimization.
+  * Improve build performance.
+  *
+  * Default: ['**\/*.{js,ts,mjs,cjs,jsx,tsx}', '!**\/node_modules/**']
+  *
+  * Example: `['src/**\/*.{ts,tsx}', '../ui-library/**\/*.{ts,tsx}', '!**\/node_modules/**']`
+  *
+  * Note:
+  * - This option will be ignored if `optimize` is disabled.
+  * - Use glob pattern.
+  */
+  traversePattern: string[];
+  /**
+  * Output format of the dictionaries
+  *
+  * Default: ['cjs', 'esm']
+  *
+  * The output format of the dictionaries. It can be either 'cjs' or 'esm'. Even if dictionaries are written in JSON, entry point to access the dictionaries are generated.
+  * This function will use the output format defined using this option.
+  * The default format is 'cjs' as it allows better interoperability with other libraries, scripts, and applications. But some build tools, such as Vite, require ES modules.
+  */
+  outputFormat: ("cjs" | "esm")[];
+  /**
+  * Indicates if the cache should be enabled
+  *
+  * Default: true
+  *
+  * If true, the cache will be enabled.
+  * If false, the cache will not be enabled.
+  */
+  cache: boolean;
+  /**
+  * Require function
+  *
+  * In some environments, as VSCode extension, the require function should be set relatively to the project root to work properly.
+  *
+  * Default: undefined
+  *
+  * If undefined, the require function will be set to the default require function.
+  * If defined, the require function will be set to the defined require function.
+  *
+  * Example:
+  * ```js
+  * {
+  *   require: require
+  * }
+  * ```
+  */
+  require?: NodeJS.Require;
+  /**
+  * Indicates if the build should check TypeScript types
+  *
+  * Default: false
+  *
+  * If true, the build will check TypeScript types and log errors.
+  * Note: This can slow down the build.
+  */
+  checkTypes: boolean;
+};
+type CompilerConfig = {
+  /**
+  * Indicates if the compiler should be enabled.
+  * If 'build-only', the compiler will be skipped during development mode to speed up start times.
+  */
+  enabled: boolean | "build-only";
+  /**
+  * Prefix for the extracted dictionary keys.
+  * Default: ''
+  */
+  dictionaryKeyPrefix?: string;
+  /**
+  * Pattern to traverse the code to optimize.
+  *
+  * Allows to avoid to traverse the code that is not relevant to the optimization.
+  * Improve build performance.
+  *
+  * Default: ['**\/*.{ts,tsx,jsx,js,cjs,mjs,svelte,vue}', '!**\/node_modules/**']
+  *
+  * Example: `['src/**\/*.{ts,tsx}', '../ui-library/**\/*.{ts,tsx}', '!**\/node_modules/**']`
+  *
+  * Note:
+  * - This option will be ignored if `optimize` is disabled.
+  * - Use glob pattern.
+  *
+  * @deprecated use build.traversePattern instead
+  */
+  transformPattern?: string | string[];
+  /**
+  * Pattern to exclude from the optimization.
+  *
+  * Allows to exclude files from the optimization.
+  *
+  * Default: ['**\/node_modules/**']
+  *
+  * Example: `['**\/node_modules/**', '!**\/node_modules/react/**']`
+  *
+  * @deprecated use build.traversePattern instead
+  */
+  excludePattern?: string | string[];
+  /**
+  * Defines the output files path. Replaces `outputDir`.
+  *
+  * - `./` paths are resolved relative to the component directory.
+  * - `/` paths are resolved relative to the project root (`baseDir`).
+  *
+  * - Including the `{{locale}}` variable in the path will trigger the generation of separate dictionaries per locale.
+  *
+  * Example:
+  * ```ts
+  * {
+  *   // Create Multilingual .content.ts files close to the component
+  *   output: ({ fileName, extension }) => `./${fileName}${extension}`,
+  *
+  *   // output: './{{fileName}}{{extension}}', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create centralize per-locale JSON at the root of the project
+  *   output: ({ key, locale }) => `/locales/${locale}/${key}.content.json`,
+  *
+  *   // output: '/locales/{{locale}}/{{key}}.content.json', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create per-locale JSON files with locale-specific output paths
+  *   output: {
+  *     en: ({ fileName, locale }) => `${fileName}.${locale}.content.json`,
+  *     fr: '{{fileName}}.{{locale}}.content.json',
+  *     es: false, // skip this locale
+  *   },
+  * }
+  * ```
+  *
+  * Variable list:
+  *   - `fileName`: The name of the file.
+  *   - `key`: The key of the content.
+  *   - `locale`: The locale of the content.
+  *   - `extension`: The extension of the file.
+  *   - `componentFileName`: The name of the component file.
+  *   - `componentExtension`: The extension of the component file.
+  *   - `format`: The format of the dictionary.
+  *   - `componentFormat`: The format of the component dictionary.
+  *   - `componentDirPath`: The directory path of the component.
+  */
+  output?: Fill;
+  /**
+  * Indicates if the metadata should be saved in the file.
+  *
+  * If true, the compiler will not save the metadata of the dictionaries.
+  *
+  * If true:
+  *
+  * ```json
+  * {
+  *   "key": "value"
+  * }
+  * ```
+  *
+  * If false:
+  *
+  * ```json
+  * {
+  *   "key": "value",
+  *   "content": {
+  *     "key": "value"
+  *   }
+  * }
+  * ```
+  *
+  * Default: false
+  *
+  * Note: Useful if used with loadJSON plugin
+  *
+  */
+  noMetadata?: boolean;
+  /**
+  * Indicates if the components should be saved after being transformed.
+  *
+  * If true, the compiler will replace the original files with the transformed files.
+  * That way, the compiler can be run only once to transform the app, and then it can be removed.
+  *
+  * Default: false
+  */
+  saveComponents: boolean;
+};
+/**
+* Custom configuration that can be provided to override default settings
+*/
+type CustomIntlayerConfig = {
+  /**
+  * Custom internationalization configuration
+  */
+  internationalization?: Partial<InternationalizationConfig>;
+  /**
+  * Custom dictionary configuration
+  */
+  dictionary?: Partial<DictionaryConfig>;
+  /**
+  * Custom routing configuration
+  */
+  routing?: Partial<RoutingConfig>;
+  /**
+  * Custom content configuration
+  */
+  content?: Partial<ContentConfig>;
+  /**
+  * Custom editor configuration
+  */
+  editor?: Partial<EditorConfig>;
+  /**
+  * Custom log configuration
+  */
+  log?: Partial<LogConfig>;
+  /**
+  * Custom AI configuration
+  */
+  ai?: Partial<AiConfig>;
+  /**
+  * Custom build configuration
+  */
+  build?: Partial<BuildConfig>;
+  /**
+  * Custom compiler configuration
+  */
+  compiler?: Partial<CompilerConfig>;
+  /**
+  * Custom system configuration
+  */
+  system?: Partial<SystemConfig>;
+  /**
+  * Custom schemas to validate the dictionaries content.
+  *
+  * Example:
+  * ```ts
+  * {
+  *  schemas: {
+  *   'my-schema': z.object({
+  *     title: z.string(),
+  *     description: z.string(),
+  *   }),
+  *  }
+  * }
+  * ```
+  */
+  schemas?: Record<string, Schema>;
+  /**
+  * Custom plugins configuration
+  */
+  plugins?: (Plugin | Promise<Plugin>)[];
+};
+type DictionaryConfig = {
+  /**
+  * Indicate how the dictionary should be filled using AI.
+  *
+  * Default: `true`
+  *
+  * - If `true`, will consider the `compiler.output` field.
+  * - If `false`, will skip the fill process.
+  *
+  * - `./` paths are resolved relative to the component directory.
+  * - `/` paths are resolved relative to the project root (`baseDir`).
+  *
+  * - If includes `{{locale}}` variable in the path, will trigger the generation of separate dictionaries per locale.
+  *
+  * Example:
+  * ```ts
+  * {
+  *   // Create Multilingual .content.ts files close to the component
+  *   fill: ({ fileName, extension }) => `./${fileName}${extension}`,
+  *
+  *   // fill: './{{fileName}}{{extension}}', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create centralize per-locale JSON at the root of the project
+  *   fill: ({ key, locale }) => `/locales/${locale}/${key}.content.json`,
+  *
+  *   // fill: '/locales/{{locale}}/{{key}}.content.json', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create custom output based on the locale
+  *   fill: {
+  *     en: ({ key }) => `/locales/en/${key}.content.json`,
+  *     fr: '/locales/fr/{{key}}.content.json',
+  *     es: false,
+  *     de: true,
+  *   },
+  * }
+  * ```
+  *
+  *
+  * Variable list:
+  *   - `fileName`: The name of the file.
+  *   - `key`: The key of the content.
+  *   - `locale`: The locale of the content.
+  *   - `extension`: The extension of the file.
+  *   - `componentFileName`: The name of the component file.
+  *   - `componentExtension`: The extension of the component file.
+  *   - `format`: The format of the dictionary.
+  *   - `componentFormat`: The format of the component dictionary.
+  *   - `componentDirPath`: The directory path of the component.
+  */
+  fill?: Fill;
+  /**
+  * The description of the dictionary. Helps to understand the purpose of the dictionary in the editor, and the CMS.
+  * The description is also used as context for translations generation.
+  *
+  * Example:
+  * ```ts
+  * {
+  *   "key": "about-page-meta",
+  *   "description":[
+  *     "This dictionary is manage the metadata of the About Page",
+  *     "Consider good practices for SEO:",
+  *     "- The title should be between 50 and 60 characters",
+  *     "- The description should be between 150 and 160 characters",
+  *   ].join('\n'),
+  *   "content": { ... }
+  * }
+  * ```
+  */
+  description?: string;
+  /**
+  * Transform the dictionary in a per-locale dictionary.
+  * Each field declared in a per-locale dictionary will be transformed in a translation node.
+  * If missing, the dictionary will be treated as a multilingual dictionary.
+  * If declared, do not use translation nodes in the content.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page",
+  *   "locale": "en",
+  *   "content": {
+  *     "multilingualContent": "English content"
+  *   }
+  * }
+  * ```
+  */
+  locale?: LocalesValues;
+  /**
+  * Indicators if the content of the dictionary should be automatically transformed.
+  * If true, the content will be transformed to the corresponding node type.
+  * - Markdown: `### Title` -> `md('### Title')`
+  * - HTML: `<div>Title</div>` -> `html('<div>Title</div>')`
+  * - Insertion: `Hello {{name}}` -> `insert('Hello {{name}}')`
+  *
+  * If an object is provided, you can specify which transformations should be enabled.
+  *
+  * Default: false
+  */
+  contentAutoTransformation?: ContentAutoTransformation;
+  /**
+  * Indicates the priority of the dictionary.
+  * In the case of conflicts, the dictionary with the highest priority will override the other dictionaries.
+  */
+  priority?: number;
+  /**
+  * Indicates the mode of import to use for the dictionaries.
+  *
+  * Available modes:
+  * - "static": The dictionaries are imported statically.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionary`.
+  * - "dynamic": The dictionaries are imported dynamically in a synchronous component using the suspense API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  * - "fetch": The dictionaries are imported dynamically using the live sync API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  *   Fetch mode will use the live sync API to fetch the dictionaries. If the API call fails, the dictionaries will be imported dynamically as "dynamic" mode.
+  *
+  * Default: "static"
+  *
+  * By default, when a dictionary is loaded, it imports content for all locales as it's imported statically.
+  *
+  * Note:
+  * - Dynamic imports rely on Suspense and may slightly impact rendering performance.
+  * - If disabled all locales will be loaded at once, even if they are not used.
+  * - This option relies on the `@intlayer/babel` and `@intlayer/swc` plugins.
+  * - Ensure all keys are declared statically in the `useIntlayer` calls. e.g. `useIntlayer('navbar')`.
+  * - This option will be ignored if `optimize` is disabled.
+  * - This option will not impact the `getIntlayer`, `getDictionary`, `useDictionary`, `useDictionaryAsync` and `useDictionaryDynamic` functions. You can still use them to refine you code on manual optimization.
+  * - The "fetch" allows to sync the dictionaries to the live sync server.
+  * - Require static key to work. Example of invalid code: `const navbarKey = "my-key"; useIntlayer(navbarKey)`.
+  */
+  importMode?: "static" | "dynamic" | "fetch";
+  /**
+  * The title of the dictionary. Helps to identify the dictionary in the editor, and the CMS.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page-meta",
+  *   "title": "About Page",
+  *   "content": { ... }
+  * }
+  * ```
+  */
+  title?: string;
+  /**
+  * Helps to categorize the dictionaries. The tags can provide more context and instructions for the dictionary.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page-meta",
+  *   "tags": ["metadata","about-page"]
+  * }
+  * ```
+  */
+  tags?: string[];
+  /**
+  * Indicates the location of the dictionary and controls how it synchronizes with the CMS.
+  *
+  * - 'hybrid': The dictionary is managed locally and remotely. Once pushed on the CMS, it will be synchronized from the local one. The local dictionary will be pulled from the CMS.
+  * - 'remote': The dictionary is managed remotely only. Once pushed on the CMS, it will be detached from the local one. At content load time, the remote dictionary will be pulled from the CMS. A '.content' file with remote location will be ignored.
+  * - 'local': The dictionary is managed locally. It will not be pushed to the remote CMS.
+  * - 'plugin' (or any custom string): The dictionary is managed by a plugin, or a custom source. When you will try to push it, the system will ask an action to the user.
+  */
+  location?: DictionaryLocation;
+};
+/**
+* Combined configuration for internationalization, middleware, and content
+*/
+type IntlayerConfig = {
+  /**
+  * Internationalization configuration
+  */
+  internationalization: InternationalizationConfig;
+  /**
+  * Default dictionary configuration
+  */
+  dictionary?: Partial<DictionaryConfig>;
+  /**
+  * Routing configuration
+  */
+  routing: RoutingConfig;
+  /**
+  * Content configuration
+  */
+  content: ContentConfig;
+  /**
+  * System configuration
+  */
+  system: SystemConfig;
+  /**
+  * Intlayer editor configuration
+  */
+  editor: EditorConfig;
+  /**
+  * Logger configuration
+  */
+  log: LogConfig;
+  /**
+  * AI configuration
+  */
+  ai?: Partial<AiConfig>;
+  /**
+  * Build configuration
+  */
+  build: BuildConfig;
+  /**
+  * Compiler configuration
+  */
+  compiler: CompilerConfig;
+  /**
+  * Custom schemas to validate the dictionaries content.
+  */
+  schemas?: Record<string, Schema>;
+  /**
+  * Plugins configuration
+  */
+  plugins?: Plugin[];
+  /**
+  * Metadata of the project
+  */
+  metadata: {
+    name: string;
+    version: string;
+    doc: string;
+  };
+};
+/**
+* Configuration for content handling
+*/
+type ContentConfig = {
+  /**
+  * File extensions of content to look for
+  *
+  * Default: ['.content.ts', '.content.js', '.content.cjs', '.content.mjs', '.content.json', '.content.tsx', '.content.jsx']
+  *
+  * List of file extensions to scan for content.
+  */
+  fileExtensions: string[];
+  /**
+  * Directory where the content is stored, relative to the base directory
+  *
+  * Default: ['.']
+  *
+  * Derived content directory based on the base configuration.
+  *
+  * Note: This is used to watch for content files.
+  */
+  contentDir: string[];
+  /**
+  * Directory where the code is stored, relative to the base directory
+  *
+  * Default: ['.']
+  *
+  * Derived code directory based on the base configuration.
+  *
+  * Note: This is used to watch for code files to transform.
+  */
+  codeDir: string[];
+  /**
+  * Directories to be excluded from content processing
+  *
+  * Default: ['node_modules', '.intlayer']
+  *
+  * A list of directories to exclude from content processing.
+  */
+  excludedPath: string[];
+  /**
+  * Indicates if Intlayer should watch for changes in the content declaration files in the app to rebuild the related dictionaries.
+  *
+  * Default: process.env.NODE_ENV === 'development'
+  */
+  watch: boolean;
+  /**
+  * Command to format the content. When intlayer write your .content files locally, this command will be used to format the content.
+  *
+  * Example:
+  *
+  * ```bash
+  * npx prettier --write {{file}}
+  * ```
+  *
+  * ```bash
+  * bunx biome format {{file}}
+  * ```
+  *
+  * ```bash
+  * bun format {{file}}
+  * ```
+  *
+  * ```bash
+  * npx eslint --fix {{file}}
+  * ```
+  *
+  * Intlayer will replace the {{file}} with the path of the file to format.
+  *
+  * Default: undefined
+  */
+  formatCommand: string | undefined;
+};
+type SystemConfig = {
+  /**
+  * Absolute path of the project's base directory
+  *
+  * Default: process.cwd()
+  *
+  * The root directory of the project, typically used for resolving other paths.
+  */
+  baseDir: string;
+  /**
+  * Directory for module augmentation, relative to the base directory
+  *
+  * Default: .intlayer/types
+  *
+  * Defines the derived path for module augmentation.
+  */
+  moduleAugmentationDir: string;
+  /**
+  * Directory where unmerged dictionaries are stored, relative to the result directory
+  *
+  * Default: .intlayer/unmerged_dictionary
+  *
+  * Specifies the derived path for unmerged dictionaries relative to the result directory.
+  */
+  unmergedDictionariesDir: string;
+  /**
+  * Directory where remote dictionaries are stored, relative to the result directory
+  *
+  * Default: .intlayer/remote_dictionary
+  *
+  * Specifies the derived path for remote dictionaries relative to the result directory.
+  */
+  remoteDictionariesDir: string;
+  /**
+  * Directory where final dictionaries are stored, relative to the result directory
+  *
+  * Default: .intlayer/dictionary
+  *
+  * Specifies the derived path for dictionaries relative to the result directory.
+  */
+  dictionariesDir: string;
+  /**
+  * Directory where dynamic dictionaries are stored, relative to the result directory
+  *
+  * Default: .intlayer/dynamic_dictionary
+  *
+  * Specifies the derived path for dynamic dictionaries relative to the result directory.
+  */
+  dynamicDictionariesDir: string;
+  /**
+  * Directory where fetch dictionaries are stored, relative to the result directory
+  *
+  * Default: .intlayer/fetch_dictionary
+  *
+  * Specifies the derived path for fetch dictionaries relative to the result directory.
+  */
+  fetchDictionariesDir: string;
+  /**
+  * Directory where dictionary types are stored, relative to the result directory
+  *
+  * Default: .intlayer/types
+  *
+  * Specifies the derived path for dictionary types relative to the result directory.
+  */
+  typesDir: string;
+  /**
+  * Directory where the main files are stored, relative to the result directory
+  *
+  * Default: .intlayer/main
+  *
+  * Specifies the derived path for the main files relative to the result directory.
+  */
+  mainDir: string;
+  /**
+  * Directory where the configuration files are stored, relative to the result directory
+  *
+  * Default: .intlayer/config
+  *
+  * Specifies the derived path for the configuration files relative to the result directory.
+  */
+  configDir: string;
+  /**
+  * Directory where the cache files are stored, relative to the result directory
+  *
+  * Default: .intlayer/cache
+  *
+  * Specifies the derived path for the cache files relative to the result directory.
+  */
+  cacheDir: string;
+  /**
+  * Directory where the temp files are stored, relative to the result directory
+  *
+  * Default: .intlayer/tmp
+  *
+  * Specifies the derived path for the tmp files relative to the result directory.
+  */
+  tempDir: string;
+};
+type LogFunctions = {
+  error?: typeof console.error;
+  log?: typeof console.log;
+  info?: typeof console.info;
+  warn?: typeof console.warn;
+};
+type LogConfig = {
+  /**
+  * Indicates if the logger is enabled
+  *
+  * Default: true
+  *
+  * If 'default', the logger is enabled and can be used.
+  * If 'verbose', the logger will be enabled and can be used, but will log more information.
+  * If 'disabled', the logger is disabled and cannot be used.
+  */
+  mode: "default" | "verbose" | "disabled";
+  /**
+  * Prefix of the logger
+  *
+  * Default: '[intlayer]'
+  *
+  * The prefix of the logger.
+  */
+  prefix: string;
+  /**
+  * Functions to log
+  */
+  error?: typeof console.error;
+  log?: typeof console.log;
+  info?: typeof console.info;
+  warn?: typeof console.warn;
+  debug?: typeof console.debug;
+};
+//#endregion
+export { AiConfig, AiProviderConfigMap, AiProviders, BuildConfig, CommonAiConfig, CompilerConfig, ContentConfig, CookiesAttributes, CustomIntlayerConfig, DictionaryConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, Schema, StorageAttributes, StrictMode, SystemConfig, URLType };
+//# sourceMappingURL=config.d.ts.map