@intlayer/core 7.0.8 → 7.0.9-canary.2

package/dist/index.d.mts

@@ -0,0 +1,1323 @@
+import * as _intlayer_types0 from "@intlayer/types";
+import { ContentNode, CookiesAttributes, DeclaredLocales, Dictionary, DictionaryKeys, DictionaryRegistryContent, GetSubPath, IntlayerConfig, KeyPath, Locale, LocalesValues, NodeType, StrictModeLocaleMap, TypedNodeModel } from "@intlayer/types";
+
+//#region src/transpiler/condition/condition.d.ts
+type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
+  fallback?: Content;
+};
+type ConditionContent<Content = unknown> = TypedNodeModel<NodeType.Condition, ConditionContentStates<Content>>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a condition.
+ *
+ * Usage:
+ *
+ * ```ts
+ * cond({
+ *  'true': 'The condition is validated',
+ *  'false': 'The condition is not validated',
+ * });
+ * ```
+ *
+ * The last key provided will be used as the fallback value.
+ *
+ */
+declare const condition: <Content>(content?: ConditionContentStates<Content>) => TypedNodeModel<NodeType.Condition, ConditionContentStates<Content> | undefined, {}>;
+//#endregion
+//#region src/transpiler/enumeration/enumeration.d.ts
+type Positive = number | `${number}`;
+type Negative = `-${number}`;
+type Numbers = Positive | Negative;
+type Equal = Numbers;
+type EqualString = `=${Numbers}`;
+type Superior = `>${Numbers}`;
+type SuperiorOrEqual = `>=${Numbers}`;
+type Inferior = `<${Numbers}`;
+type InferiorOrEqual = `<=${Numbers}`;
+type EnterFormat = Equal | EqualString | Superior | SuperiorOrEqual | Inferior | InferiorOrEqual;
+type EnumerationContentState<Content> = Partial<Record<EnterFormat, Content>> & {
+  fallback?: Content;
+};
+type EnumerationContent<Content = unknown> = TypedNodeModel<NodeType.Enumeration, EnumerationContentState<Content>>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * enu({
+ *  '<=-2.3': 'You have less than -2.3',
+ *  '<1': 'You have less than one',
+ *  '2': 'You have two',
+ *  '>=3': 'You have three or more',
+ * });
+ * ```
+ *
+ * > The order of the keys will define the priority of the content.
+ *
+ */
+declare const enumeration: <Content>(content?: EnumerationContentState<Content>) => TypedNodeModel<NodeType.Enumeration, EnumerationContentState<Content> | undefined, {}>;
+//#endregion
+//#region src/transpiler/file/file.d.ts
+type FileContentConstructor<T extends Record<string, any> = {}> = TypedNodeModel<NodeType.File, string, T>;
+type FileContent = FileContentConstructor<{
+  content: string;
+  fixedPath?: string;
+}>;
+declare const fileContent: (path: string, callerDir: string, baseDir: string) => FileContent;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow identify the usage of an external resource.
+ *
+ * Usage:
+ *
+ * ```ts
+ * file('/path/to/file.md') // absolute path
+ *
+ * // or
+ *
+ * file('path/to/file.md') // relative path
+ * ```
+ */
+declare const file: (path: string) => FileContent;
+//#endregion
+//#region src/transpiler/gender/gender.d.ts
+type Gender = 'male' | 'female' | 'fallback';
+type GenderContentStates<Content> = Record<`${Gender}`, Content> & {
+  fallback?: Content;
+};
+type GenderContent<Content = unknown> = TypedNodeModel<NodeType.Gender, GenderContentStates<Content>>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a gender.
+ *
+ * Usage:
+ *
+ * ```ts
+ * gender({
+ *  'true': 'The gender is validated',
+ *  'false': 'The gender is not validated',
+ * });
+ * ```
+ *
+ * The last key provided will be used as the fallback value.
+ *
+ */
+declare const gender: <Content>(content?: GenderContentStates<Content>) => TypedNodeModel<NodeType.Gender, GenderContentStates<Content> | undefined, {}>;
+//#endregion
+//#region src/transpiler/insertion/getInsertionValues.d.ts
+declare const getInsertionValues: (content: string) => string[];
+//#endregion
+//#region src/transpiler/insertion/insertion.d.ts
+type InsertionContentConstructor<Content = unknown, T extends Record<string, any> = {}> = TypedNodeModel<NodeType.Insertion, Content, T>;
+type InsertionContent<Content = unknown> = InsertionContentConstructor<Content, {
+  fields: string[];
+}>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to identify insertions inside a content.
+ *
+ * Usage:
+ *
+ * ```ts
+ * insertion('Hi, my name is {{name}} and I am {{age}} years old.')
+ * ```
+ *
+ */
+declare const insertion: <Content = unknown>(content: Content) => InsertionContent<Content>;
+//#endregion
+//#region src/transpiler/markdown/getMarkdownMetadata.d.ts
+declare const getMarkdownMetadata: <T extends Record<string, any>>(markdown: string) => T;
+//#endregion
+//#region src/transpiler/markdown/markdown.d.ts
+type MarkdownContentConstructor<T extends Record<string, any> = {}, Content = unknown> = TypedNodeModel<NodeType.Markdown, Content, T>;
+type MarkdownContent<_Content = unknown> = MarkdownContentConstructor<{
+  metadata?: Record<string, any>;
+}>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * markdown('## Hello world!');
+ * ```
+ *
+ */
+declare const markdown: <Content = unknown>(content: Content) => MarkdownContent;
+//#endregion
+//#region src/transpiler/nesting/nesting.d.ts
+/**
+ * Recursively builds dot-notation strings for all valid paths in T.
+ * Example:
+ *   type X = { a: { b: { c: string }}, d: number };
+ *   DotPath<X> = "a" | "a.b" | "a.b.c" | "d"
+ */
+type DotPath<T> = T extends object ? { [K in keyof T & (string | number)]: T[K] extends object ?
+// Either just K, or K + '.' + deeper path
+`${K}` | `${K}.${DotPath<T[K]>}` : `${K}` }[keyof T & (string | number)] : never;
+type DeepReplace<T, From, To> = T extends From ? To : T extends object ? { [K in keyof T]: DeepReplace<T[K], From, To> } : T;
+/** Build all valid dot-notation strings for a dictionary entry. */
+type ValidDotPathsFor<K$1 extends DictionaryKeys> = DotPath<DeepReplace<DeepTransformContent<DictionaryRegistryContent<K$1>>, {
+  type: any;
+  props: any;
+  key: any;
+}, string>>;
+type NestedContentState<K$1 extends DictionaryKeys> = {
+  dictionaryKey: K$1;
+  /**
+   * Path must match existing keys in DictionaryRegistryContent<K>.
+   * Can be either:
+   *  - "dot.dot.dot" format
+   */
+  path?: ValidDotPathsFor<K$1>;
+};
+type NestedContent<K$1 extends DictionaryKeys = never> = TypedNodeModel<NodeType.Nested, NestedContentState<K$1>>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to extract the content of another dictionary and nest it in the current dictionary.
+ *
+ * Usage:
+ *
+ * ```ts
+ * nest("dictionaryKey");
+ * nest("dictionaryKey", "path.to.content");
+ * ```
+ *
+ * The order of the keys will define the priority of the content.
+ *
+ */
+declare const nesting: <K$1 extends DictionaryKeys>(dictionaryKey: K$1, path?: ValidDotPathsFor<K$1>) => NestedContent<K$1>;
+//#endregion
+//#region src/transpiler/translation/translation.d.ts
+type TranslationContent<Content = unknown, RecordContent extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>> = TypedNodeModel<NodeType.Translation, RecordContent>;
+/**
+ *
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Get the content of a translation based on the locale.
+ *
+ * Usage:
+ *
+ * ```ts
+ * translation<string>({
+ *   "en": "Hello",
+ *   "fr": "Bonjour",
+ *   // ... any other available locale
+ * })
+ * ```
+ *
+ * Using TypeScript:
+ * - this function require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+declare const translation: <Content = unknown, ContentRecord extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>>(content: ContentRecord) => TypedNodeModel<NodeType.Translation, ContentRecord, {
+  nodeType: NodeType.Translation | "translation";
+} & {
+  translation: ContentRecord;
+}>;
+//#endregion
+//#region src/interpreter/getCondition.d.ts
+/**
+ * Allow to pick a content based on a condition.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = getCondition({
+ *  'true': 'The condition is validated',
+ *  'false': 'The condition is not validated',
+ * }, true);
+ * // 'The condition is validated'
+ * ```
+ *
+ * The last key provided will be used as the fallback value.
+ *
+ * ```ts
+ * const content = getCondition({
+ *  'false': 'The condition is not validated',
+ *  'true': 'The condition is validated',
+ * }, undefined);
+ * // 'The condition is validated'
+ */
+declare const getCondition: <Content>(conditionContent: ConditionContentStates<Content>, state?: boolean) => Content;
+//#endregion
+//#region src/interpreter/getNesting.d.ts
+type GetNestingResult<K$1 extends DictionaryKeys, P$1 = undefined, S = IInterpreterPluginState> = GetSubPath<DeepTransformContent<DictionaryRegistryContent<K$1>, S>, P$1>;
+/**
+ * Allow to extract the content of another dictionary.
+ *
+ * Usage:
+ * ```ts
+ * const content = getNesting("dictionaryKey", "path.to.content");
+ * // 'Example content'
+ * ```
+ */
+declare const getNesting: <K$1 extends DictionaryKeys, P$1>(dictionaryKey: K$1, path?: P$1 extends ValidDotPathsFor<K$1> ? P$1 : never, props?: NodeProps) => GetNestingResult<K$1, P$1>;
+//#endregion
+//#region src/interpreter/getContent/plugins.d.ts
+/** ---------------------------------------------
+ *  PLUGIN DEFINITION
+ *  --------------------------------------------- */
+/**
+ * A plugin/transformer that can optionally transform a node during a single DFS pass.
+ * - `canHandle` decides if the node is transformable by this plugin.
+ * - `transform` returns the transformed node (and does not recurse further).
+ *
+ * > `transformFn` is a function that can be used to deeply transform inside the plugin.
+ */
+type Plugins = {
+  id: string;
+  canHandle: (node: any) => boolean;
+  transform: (node: any, props: NodeProps, transformFn: (node: any, props: NodeProps) => any) => any;
+};
+/** ---------------------------------------------
+ *  TRANSLATION PLUGIN
+ *  --------------------------------------------- */
+type TranslationCond<T, S, L extends LocalesValues> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Translation]: infer U;
+} ? U extends Record<PropertyKey, unknown> ? L extends keyof U ? DeepTransformContent<U[L], S> : DeepTransformContent<U[keyof U], S> : never : never;
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+declare const translationPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
+/** ---------------------------------------------
+ *  ENUMERATION PLUGIN
+ *  --------------------------------------------- */
+type EnumerationCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Enumeration]: object;
+} ? (quantity: number) => DeepTransformContent<T[NodeType.Enumeration][keyof T[NodeType.Enumeration]], S> : never;
+/** Enumeration plugin. Replaces node with a function that takes quantity => string. */
+declare const enumerationPlugin: Plugins;
+/** ---------------------------------------------
+ *  CONDITION PLUGIN
+ *  --------------------------------------------- */
+type ConditionCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Condition]: object;
+} ? (value: boolean) => DeepTransformContent<T[NodeType.Condition][keyof T[NodeType.Condition]], S> : never;
+/** Condition plugin. Replaces node with a function that takes boolean => string. */
+declare const conditionPlugin: Plugins;
+/** ---------------------------------------------
+ *  GENDER PLUGIN
+ *  --------------------------------------------- */
+type GenderCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Gender]: object;
+} ? (value: Gender) => DeepTransformContent<T[NodeType.Gender][keyof T[NodeType.Gender]], S> : never;
+/** Gender plugin. Replaces node with a function that takes gender => string. */
+declare const genderPlugin: Plugins;
+/** ---------------------------------------------
+ *  INSERTION PLUGIN
+ *  --------------------------------------------- */
+type InsertionCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Insertion]: infer I;
+  fields?: infer U;
+} ? U extends readonly string[] ? (data: Record<U[number], string | number>) => DeepTransformContent<I, S> : (data: Record<string, string | number>) => DeepTransformContent<I, S> : never;
+declare const insertionPlugin: Plugins;
+/** ---------------------------------------------
+ *  NESTED PLUGIN
+ *  --------------------------------------------- */
+type NestedCond<T, S, L> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.Nested]: infer U;
+} ? U extends {
+  dictionaryKey: infer K extends DictionaryKeys;
+  path?: infer P;
+} ? GetNestingResult<K, P, S> : never : never;
+/** Nested plugin. Replaces node with the result of `getNesting`. */
+declare const nestedPlugin: Plugins;
+type FileCond<T> = T extends {
+  nodeType: NodeType | string;
+  [NodeType.File]: string;
+  content?: string;
+} ? string : never;
+/** File plugin. Replaces node with the result of `getNesting`. */
+declare const filePlugin: Plugins;
+/**
+ * PLUGIN RESULT
+ */
+/**
+ * Interface that defines the properties of a node.
+ * This interface can be augmented in other packages, such as `react-intlayer`.
+ */
+interface NodeProps {
+  dictionaryKey: string;
+  keyPath: KeyPath[];
+  plugins?: Plugins[];
+  locale?: Locale;
+  dictionaryPath?: string;
+  children?: any;
+}
+/**
+ * Interface that defines the plugins that can be used to transform a node.
+ * This interface can be augmented in other packages, such as `react-intlayer`.
+ */
+interface IInterpreterPlugin<T, S, L extends LocalesValues> {
+  translation: TranslationCond<T, S, L>;
+  insertion: InsertionCond<T, S, L>;
+  enumeration: EnumerationCond<T, S, L>;
+  condition: ConditionCond<T, S, L>;
+  nested: NestedCond<T, S, L>;
+}
+/**
+ * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.
+ */
+type IInterpreterPluginState = {
+  translation: true;
+  enumeration: true;
+  condition: true;
+  insertion: true;
+  nested: true;
+};
+/**
+ * Utility type to check if a plugin can be applied to a node.
+ */
+type CheckApplyPlugin<T, K$1 extends keyof IInterpreterPlugin<T, S, L>, S, L extends LocalesValues = DeclaredLocales> = K$1 extends keyof S ? S[K$1] extends true ? IInterpreterPlugin<T, S, L>[K$1] extends never ? never : IInterpreterPlugin<T, S, L>[K$1] : never : never;
+/**
+ * Traverse recursively through an object or array, applying each plugin as needed.
+ */
+type Traverse<T, S, L extends LocalesValues = DeclaredLocales> = T extends ReadonlyArray<infer U> ? Array<DeepTransformContent<U, S, L>> : T extends object ? { [K in keyof T]: DeepTransformContent<T[K], S, L> } : T;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Traverse recursively through an object or array, applying each plugin as needed.
+ */
+type DeepTransformContent<T, S = IInterpreterPluginState, L extends LocalesValues = DeclaredLocales> = IsAny<T> extends true ? T : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S> extends never ? Traverse<T, S, L> : IInterpreterPlugin<T, S, L>[keyof IInterpreterPlugin<T, S, L>];
+//#endregion
+//#region src/interpreter/getContent/deepTransform.d.ts
+/**
+ * Recursively traverses a node (object/array/primitive).
+ * Applies the *first* plugin that can transform a node, then stops descending further.
+ * If no plugin transforms it, it recurses into its children.
+ */
+declare const deepTransformNode: (node: any, props: NodeProps) => any;
+//#endregion
+//#region src/interpreter/getContent/getContent.d.ts
+/**
+ * Transforms a node in a single pass, applying each plugin as needed.
+ *
+ * @param node The node to transform.
+ * @param locale The locale to use if your transformers need it (e.g. for translations).
+ */
+declare const getContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, nodeProps: NodeProps, locale?: L) => DeepTransformContent<T, IInterpreterPluginState, L>;
+//#endregion
+//#region src/interpreter/getDictionary.d.ts
+/**
+ * Transforms a dictionary in a single pass, applying each plugin as needed.
+ *
+ * @param dictionary The dictionary to transform.
+ * @param locale The locale to use if your transformers need it (e.g. for translations).
+ * @param additionalPlugins An array of NodeTransformer that define how to transform recognized nodes.
+ *                      If omitted, we’ll use a default set of plugins.
+ */
+declare const getDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<T["content"], IInterpreterPluginState, L>;
+//#endregion
+//#region src/interpreter/getEnumeration.d.ts
+/**
+ * Find the matching condition for a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const key = findMatchingCondition({
+ *  '<=-2.3': 'You have less than -2.3',
+ *  '<1': 'You have less than one',
+ *  '2': 'You have two',
+ *  '>=3': 'You have three or more',
+ * }, 2);
+ * // '2'
+ * ```
+ *
+ * The order of the keys will define the priority of the content.
+ *
+ * ```ts
+ * const key = findMatchingCondition({
+ *  '<4': 'You have less than four',
+ *  '2': 'You have two',
+ * }, 2);
+ * // '<4'
+ * ```
+ *
+ * If no keys match, the default key is '1'.
+ */
+declare const findMatchingCondition: <Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => EnterFormat;
+/**
+ * Allow to pick a content based on a quantity.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = getEnumeration({
+ *  '<=-2.3': 'You have less than -2.3',
+ *  '<1': 'You have less than one',
+ *  '2': 'You have two',
+ *  '>=3': 'You have three or more',
+ * }, 2);
+ * // 'You have two'
+ * ```
+ *
+ * The order of the keys will define the priority of the content.
+ *
+ * ```ts
+ * const content = getEnumeration({
+ *  '<4': 'You have less than four',
+ *  '2': 'You have two',
+ * }, 2);
+ * // 'You have less than four'
+ * ```
+ *
+ */
+declare const getEnumeration: <Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => Content;
+//#endregion
+//#region src/interpreter/getIntlayer.d.ts
+declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryContent<T>, IInterpreterPluginState, L>;
+//#endregion
+//#region src/interpreter/getTranslation.d.ts
+/**
+ *
+ * Allow to pick a content based on a locale.
+ * If not locale found, it will return the content related to the default locale.
+ *
+ * Return either the content editor, or the content itself depending on the configuration.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const content = getTranslation<string>({
+ * en: 'Hello',
+ * fr: 'Bonjour',
+ * }, 'fr');
+ * // 'Bonjour'
+ * ```
+ *
+ * Using TypeScript:
+ * - this function will require each locale to be defined if defined in the project configuration.
+ * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
+ */
+declare const getTranslation: <Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
+//#endregion
+//#region src/deepTransformPlugins/getFilteredLocalesContent.d.ts
+declare const getFilteredLocalesContent: (node: ContentNode, locales: LocalesValues | LocalesValues[], nodeProps: NodeProps) => any;
+declare const getFilteredLocalesDictionary: (dictionary: Dictionary, locale: LocalesValues | LocalesValues[]) => {
+  content: any;
+  $schema?: string;
+  id?: _intlayer_types0.DictionaryId;
+  projectIds?: string[];
+  localId?: _intlayer_types0.LocalDictionaryId;
+  localIds?: _intlayer_types0.LocalDictionaryId[];
+  key: _intlayer_types0.DictionaryKey;
+  title?: string;
+  description?: string;
+  versions?: string[];
+  version?: string;
+  filePath?: string;
+  tags?: string[];
+  locale?: LocalesValues;
+  fill?: _intlayer_types0.Fill;
+  filled?: true;
+  priority?: number;
+  live?: boolean;
+  location?: _intlayer_types0.DictionaryLocation;
+};
+//#endregion
+//#region src/deepTransformPlugins/getFilterMissingTranslationsContent.d.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+declare const filterMissingTranslationsOnlyPlugin: (localeToCheck: LocalesValues) => Plugins;
+/**
+ * For each translation node, it compare is both localeToCheck and baseLocale are present.
+ *
+ * If yes, it should remove the node from the content.
+ * If no, it should keep the node
+ *
+ * In complete mode, for large dictionaries, we want to filter all content that is already translated
+ *
+ * locale: fr
+ *
+ * { test1: t({ ar: 'Hello', en: 'Hello', fr: 'Bonjour' } }) -> {}
+ * { test2: t({ ar: 'Hello', en: 'Hello' }) } -> { test2: t({ ar: 'Hello', en: 'Hello' }) }
+ *
+ */
+declare const getFilterMissingTranslationsContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, localeToCheck: L, nodeProps: NodeProps) => any;
+declare const getFilterMissingTranslationsDictionary: (dictionary: Dictionary, localeToCheck: LocalesValues) => {
+  content: any;
+  $schema?: string;
+  id?: _intlayer_types0.DictionaryId;
+  projectIds?: string[];
+  localId?: _intlayer_types0.LocalDictionaryId;
+  localIds?: _intlayer_types0.LocalDictionaryId[];
+  key: _intlayer_types0.DictionaryKey;
+  title?: string;
+  description?: string;
+  versions?: string[];
+  version?: string;
+  filePath?: string;
+  tags?: string[];
+  locale?: LocalesValues;
+  fill?: _intlayer_types0.Fill;
+  filled?: true;
+  priority?: number;
+  live?: boolean;
+  location?: _intlayer_types0.DictionaryLocation;
+};
+//#endregion
+//#region src/deepTransformPlugins/getFilterTranslationsOnlyContent.d.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+declare const filterTranslationsOnlyPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
+/**
+ * Return the content of a node with only the translation plugin.
+ *
+ * @param node The node to transform.
+ * @param locale The locale to use if your transformers need it (e.g. for translations).
+ */
+declare const getFilterTranslationsOnlyContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L | undefined, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
+declare const getFilterTranslationsOnlyDictionary: (dictionary: Dictionary, locale?: LocalesValues, fallback?: LocalesValues) => {
+  content: any;
+  $schema?: string;
+  id?: _intlayer_types0.DictionaryId;
+  projectIds?: string[];
+  localId?: _intlayer_types0.LocalDictionaryId;
+  localIds?: _intlayer_types0.LocalDictionaryId[];
+  key: _intlayer_types0.DictionaryKey;
+  title?: string;
+  description?: string;
+  versions?: string[];
+  version?: string;
+  filePath?: string;
+  tags?: string[];
+  locale?: LocalesValues;
+  fill?: _intlayer_types0.Fill;
+  filled?: true;
+  priority?: number;
+  live?: boolean;
+  location?: _intlayer_types0.DictionaryLocation;
+};
+//#endregion
+//#region src/deepTransformPlugins/getLocalizedContent.d.ts
+/**
+ * Transforms a node in a single pass, applying each plugin as needed.
+ * In comparison to `getContent`, this function will only apply the translation plugin.
+ * It will not transform enumerations, insertions, or other content types.
+ *
+ * @param node The node to transform.
+ * @param locale The locale to use if your transformers need it (e.g. for translations).
+ */
+declare const getLocalizedContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
+declare const getPerLocaleDictionary: <T extends Dictionary, L extends LocalesValues>(dictionary: T, locale: L, fallback?: LocalesValues) => Dictionary;
+//#endregion
+//#region src/deepTransformPlugins/getMaskContent.d.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+declare const buildMaskPlugin: Plugins;
+declare const getMaskContent: (source: Dictionary) => any;
+//#endregion
+//#region src/deepTransformPlugins/getMissingLocalesContent.d.ts
+/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
+declare const checkMissingLocalesPlugin: (locales: Locale[], onMissingLocale: (locale: Locale) => void) => Plugins;
+/**
+ * Return the content of a node with only the translation plugin.
+ *
+ * @param node The node to transform.
+ * @param locales The locales to check for missing translations.
+ */
+declare const getMissingLocalesContent: <T extends ContentNode>(node: T, locales: LocalesValues[] | undefined, nodeProps: NodeProps) => Locale[];
+declare const getMissingLocalesContentFromDictionary: (dictionary: Dictionary, locales?: LocalesValues[]) => Locale[];
+//#endregion
+//#region src/deepTransformPlugins/getMultilingualDictionary.d.ts
+/**
+ * Transform a per-locale dictionary into a multilingual dictionary.
+ *
+ * Example:
+ * ```json
+ * {
+ *   "key": "about-page",
+ *   "locale": "en",
+ *   "content": {
+ *     "myContent": "English content"
+ *   }
+ * }
+ * ```
+ *
+ * ```json
+ * {
+ *   "key": "about-page",
+ *   "content": {
+ *     "myContent": t({
+ *       "en": "English content",
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare const getMultilingualDictionary: (dictionary: Dictionary) => Dictionary;
+//#endregion
+//#region src/deepTransformPlugins/getReplacedValuesContent.d.ts
+declare const getReplacedValuesContent: (node: ContentNode, value: string | number | boolean, nodeProps: NodeProps) => any;
+//#endregion
+//#region src/deepTransformPlugins/getSplittedContent.d.ts
+type SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {
+  common: T;
+};
+declare const getSplittedContent: (content: ContentNode) => SplittedContentOutput;
+/**
+ * Splits the `content` field of a Dictionary into "common" and per-locale buckets.
+ *
+ * Given a dictionary like:
+ * ```js
+ * {
+ *   key: "my-key",
+ *   content: {
+ *     commonContent: "common content",
+ *     multilingualContent: t({
+ *       en: "english content",
+ *       fr: "french content",
+ *       de: "german content",
+ *     }),
+ *   },
+ * }
+ * ```
+ *
+ * It produces:
+ * ```js
+ * {
+ *   common: { commonContent: "common content" },
+ *   en: { multilingualContent: "english content" },
+ *   fr: { multilingualContent: "french content" },
+ *   de: { multilingualContent: "german content" },
+ * }
+ * ```
+ *
+ * @param dictionary - The input dictionary object with possible multilingual or common content.
+ * @returns An object mapping "common" and each locale to their corresponding content subtrees.
+ */
+declare const getSplittedDictionaryContent: (dictionary: Dictionary) => SplittedContentOutput<Dictionary["content"]>;
+//#endregion
+//#region src/deepTransformPlugins/insertContentInDictionary.d.ts
+/**
+ * Insert content into a dictionary with deep merge support
+ * Handles translation blocks and nested structures
+ *
+ * @param dictionary - The dictionary to insert content into
+ * @param content - The content to insert
+ * @param locale - Optional locale to target specific translation
+ * @returns Updated dictionary
+ *
+ * @example
+ * // Without locale - deep merge all content
+ * insertContentInDictionary(dictionary, { title: 'New Title' })
+ *
+ * @example
+ * // With locale - insert content for specific locale
+ * insertContentInDictionary(dictionary, { title: 'このページ' }, 'ja')
+ */
+declare const insertContentInDictionary: (dictionary: Dictionary, content: Dictionary["content"], locale?: LocalesValues) => Dictionary;
+//#endregion
+//#region src/dictionaryManipulator/editDictionaryByKeyPath.d.ts
+declare const editDictionaryByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], newValue: ContentNode) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/getContentNodeByKeyPath.d.ts
+declare const getContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], fallbackLocale?: Locale) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/getDefaultNode.d.ts
+declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/getEmptyNode.d.ts
+declare const getEmptyNode: (section: ContentNode) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/getNodeChildren.d.ts
+declare const getNodeChildren: (section: ContentNode) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/getNodeType.d.ts
+declare const getNodeType: (content: ContentNode) => NodeType;
+//#endregion
+//#region src/dictionaryManipulator/mergeDictionaries.d.ts
+declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
+//#endregion
+//#region src/dictionaryManipulator/normalizeDictionary.d.ts
+declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
+declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
+//#endregion
+//#region src/dictionaryManipulator/orderDictionaries.d.ts
+/**
+ * Orders dictionaries based on the dictionary priority strategy.
+ *
+ * @param dictionaries - Array of dictionaries to order
+ * @param priorityStrategy - The priority strategy ('local_first' or 'distant_first')
+ * @returns Ordered array of dictionaries
+ */
+declare const orderDictionaries: (dictionaries: Dictionary[], configuration?: _intlayer_types0.IntlayerConfig) => Dictionary[];
+//#endregion
+//#region src/dictionaryManipulator/removeContentNodeByKeyPath.d.ts
+declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/renameContentNodeByKeyPath.d.ts
+declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath["key"], keyPath: KeyPath[]) => ContentNode;
+//#endregion
+//#region src/dictionaryManipulator/updateNodeChildren.d.ts
+declare const updateNodeChildren: <T extends ContentNode, U$1 extends ContentNode>(section: T, newChildren: U$1) => ContentNode;
+//#endregion
+//#region src/formatters/compact.d.ts
+/**
+ * Formats a numeric value using compact notation (e.g., 1K, 1M, 1B)
+ * based on locale and formatting options.
+ *
+ * @example
+ * compact({ value: 1200 }); // "1.2K"
+ *
+ * @example
+ * compact({ value: "1000000", locale: Locales.FRENCH, compactDisplay: "long" });
+ * // "1 million"
+ */
+declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/currency.d.ts
+/**
+ * Formats a numeric or string value into a localized currency string using the Intl API.
+ *
+ *  @example
+ * currency({ value: 1234.5, currency: 'EUR' });
+ * // "€1,234.50"
+ *
+ * @example
+ * currency({ value: "5000", locale: Locales.FRENCH, currency: "CAD", currencyDisplay: "code" });
+ * // "5 000,00 CAD"
+ */
+declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/date.d.ts
+/**
+ * Formats a date/time value into a localized string using Intl.DateTimeFormat.
+ *
+ * @example
+ * date({ date: new Date(), options: "short" });
+ * // "08/02/25, 14:30"
+ *
+ * @example
+ * date({ date: "2025-08-02T14:30:00Z", locale: Locales.FRENCH, options: { month: "long", day: "numeric" } });
+ * // "2 août"
+ */
+declare const date: (date: Date | string | number, options?: Intl.DateTimeFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/list.d.ts
+/**
+ * Formats an array of values into a localized list string using the Intl API.
+ *
+ * @example
+ * list(['apple', 'banana', 'orange']);
+ * // "apple, banana, and orange"
+ *
+ * @example
+ * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });
+ * // "rouge, vert ou bleu"
+ *
+ * @example
+ * list([1, 2, 3], { type: 'unit' });
+ * // "1, 2, 3"
+ */
+declare const list: (values: (string | number)[], options?: Intl.ListFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/number.d.ts
+/**
+ * Formats a numeric value using locale-aware formatting.
+ *
+ * @example
+ * number({ value: 123456.789 }); // "123,456.789"
+ * number({ value: "1000000", locale: Locales.FRENCH }); // "1 000 000"
+ */
+declare const number: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/percentage.d.ts
+/**
+ * Formats a number as a percentage string (e.g., 0.25 → "25%").
+ *
+ * @example
+ * percentage({ value: 0.25 }) // "25%"
+ * percentage({ value: 0.25, minimumFractionDigits: 2 }) // "25.00%"
+ */
+declare const percentage: (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/formatters/relativeTime.d.ts
+type RelativeTimeUnit = Intl.RelativeTimeFormatUnit;
+declare const relativeTime: (from: Date | string | number, to?: Date | string | number, options?: Intl.RelativeTimeFormatOptions & {
+  locale?: LocalesValues;
+  unit?: RelativeTimeUnit;
+}) => string;
+//#endregion
+//#region src/formatters/units.d.ts
+/**
+ * Formats a numeric value as a localized unit string.
+ *
+ * @example
+ * units({ value: 5, unit: "kilometer", unitDisplay: "long", locale: "en-GB" })
+ * // "5 kilometers"
+ */
+declare const units: (value: number | string, options?: Intl.NumberFormatOptions & {
+  locale?: LocalesValues;
+}) => string;
+//#endregion
+//#region src/getStorageAttributes.d.ts
+type CookieEntry = {
+  name: string;
+  attributes: Omit<CookiesAttributes, 'type' | 'name'>;
+};
+type WebStorageEntry = {
+  name: string;
+};
+type HeaderEntry = {
+  name: string;
+};
+type ProcessedStorageAttributes = {
+  cookies: CookieEntry[];
+  localStorage: WebStorageEntry[];
+  sessionStorage: WebStorageEntry[];
+  headers: HeaderEntry[];
+};
+/**
+ * Extracts and normalizes storage configuration into separate arrays for each storage type
+ *
+ * @param options - The storage configuration from IntlayerConfig
+ * @returns An object containing arrays for cookies, localStorage, and sessionStorage
+ */
+declare const getStorageAttributes: (options: IntlayerConfig["routing"]["storage"]) => ProcessedStorageAttributes;
+//#endregion
+//#region src/utils/localeStorage.d.ts
+type CookieBuildAttributes = {
+  /**
+   * 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?: number | undefined;
+};
+type LocaleStorageOptions = {
+  overwrite?: boolean;
+  isCookieEnabled?: boolean;
+  setCookieStore?: (name: string, value: string, cookie: CookieBuildAttributes) => void;
+  setCookieString?: (name: string, cookie: string) => void;
+  getCookie?: (name: string) => string | undefined | null;
+  setSessionStorage?: (name: string, value: string) => void;
+  getSessionStorage?: (name: string) => string | undefined | null;
+  setLocaleStorage?: (name: string, value: string) => void;
+  getLocaleStorage?: (name: string) => string | undefined | null;
+  getHeader?: (name: string) => string | undefined | null;
+  setHeader?: (name: string, value: string) => void;
+};
+/**
+ * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function checks storage locations in order of priority as defined in the configuration.
+ *
+ * @returns The locale if found in any storage, or undefined if not found
+ */
+declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, "getCookie" | "getSessionStorage" | "getLocaleStorage" | "getHeader" | "isCookieEnabled">) => Locale | undefined;
+/**
+ * Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function writes to all configured storage locations according to their attributes.
+ * Respects overwrite flags for localStorage and sessionStorage.
+ *
+ * @param locale - The locale to store
+ */
+declare const setLocaleInStorage: (locale: LocalesValues, options?: LocaleStorageOptions) => void;
+/**
+ * Utility object to get and set the locale in the storage by considering the configuration
+ *
+ * @property getLocale - Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * Retrieves the locale from various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function checks storage locations in order of priority as defined in the configuration.
+ *
+ * @property setLocale - Stores the locale in various storage mechanisms (cookies, localStorage, sessionStorage, headers).
+ * The function writes to all configured storage locations according to their attributes.
+ * Respects overwrite flags for localStorage and sessionStorage.
+ *
+ * @returns The locale if found in any storage, or undefined if not found
+ */
+declare const LocaleStorage: (options: LocaleStorageOptions) => {
+  getLocale: () => Locale | undefined;
+  setLocale: (locale: LocalesValues) => void;
+};
+//#endregion
+//#region src/localization/getBrowserLocale.d.ts
+declare enum LanguageDetector {
+  Querystring = "querystring",
+  Storage = "storage",
+  Navigator = "navigator",
+  HtmlTag = "htmlTag",
+}
+declare const localeStorageOptions: LocaleStorageOptions;
+type LanguageDetectorOptions = {
+  order?: LanguageDetector[];
+  lookupQuerystring?: string;
+  htmlTag?: HTMLElement | null;
+};
+/**
+ * Core language detector function for browser environments.
+ *
+ * Detects the user's preferred locale by checking multiple sources in order:
+ * 1. Query string parameter
+ * 2. Storage (cookies, localStorage, sessionStorage) - uses getLocaleFromStorage
+ * 3. Navigator languages - uses localeDetector
+ * 4. HTML lang attribute - uses localeDetector
+ *
+ * @param userOptions - Optional configuration for detection order and lookup keys
+ * @returns The detected locale or the default locale
+ *
+ * @example
+ * const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
+ */
+declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
+//#endregion
+//#region src/localization/getHTMLTextDir.d.ts
+type Dir = 'ltr' | 'rtl' | 'auto';
+/**
+ * Returns the text direction of the given locale.
+ *
+ * Example:
+ *
+ * getHTMLTextDir('en-US') // 'ltr'
+ * getHTMLTextDir('en') // 'ltr'
+ * getHTMLTextDir('fr-CA') // 'ltr'
+ * getHTMLTextDir('fr') // 'ltr'
+ *
+ * @param locale The locale to get the text direction for.
+ * @returns The text direction of the given locale.
+ */
+declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
+//#endregion
+//#region src/localization/getLocaleFromPath.d.ts
+/**
+ * Extracts the locale segment from the given URL or pathname if present.
+ * If no locale is present, returns the default locale (en).
+ *
+ * Example:
+ *
+ * ```ts
+ * getLocaleFromPath('/en/dashboard') // Returns 'en'
+ * getLocaleFromPath('/fr/dashboard') // Returns 'fr'
+ * getLocaleFromPath('/dashboard') // Returns 'en'
+ * getLocaleFromPath('dashboard') // Returns 'en'
+ * getLocaleFromPath('https://example.com/es/dashboard') // Returns 'es'
+ * getLocaleFromPath('https://example.com/fr/dashboard') // Returns 'fr'
+ * getLocaleFromPath('https://example.com/dashboard') // Returns 'en'
+ * ```
+ *
+ * @param inputUrl - The complete URL string or pathname to process.
+ * @returns The detected locale or default (en) if no locale is found
+ */
+declare const getLocaleFromPath: (inputUrl: string) => Locale;
+//#endregion
+//#region src/localization/getLocaleLang.d.ts
+/**
+ * Returns the language code of the given locale for locales including the country code.
+ *
+ * Example:
+ *
+ * getLocaleLang('en-US') // 'en'
+ * getLocaleLang('en') // 'en'
+ * getLocaleLang('fr-CA') // 'fr'
+ * getLocaleLang('fr') // 'fr'
+ *
+ * @param locale The locale to get the language code for.
+ * @returns The language code of the given locale.
+ */
+declare const getLocaleLang: (locale?: LocalesValues) => string;
+//#endregion
+//#region src/localization/getLocaleName.d.ts
+declare const getLocaleName: (displayLocale: LocalesValues, targetLocale?: LocalesValues) => string;
+//#endregion
+//#region src/localization/getLocalizedUrl.d.ts
+/**
+ * Generate URL by prefixing the given URL with the referenced locale or adding search parameters
+ * based on the routing mode. Handles both absolute and relative URLs appropriately.
+ *
+ * This function gets the locales, default locale, and routing mode from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ *  // prefix-no-default mode
+ *  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'prefix-no-default');
+ *  // Returns '/fr/about' for the French locale
+ *  // Returns '/about' for the English locale (default)
+ *
+ *  // prefix-all mode
+ *  getLocalizedUrl('/about', 'en', ['en', 'fr'], 'en', 'prefix-all');
+ *  // Returns '/en/about' for the English locale
+ *  // Returns '/fr/about' for the French locale
+ *
+ *  // search-params mode
+ *  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'search-params');
+ *  // Returns '/about?locale=fr' for the French locale
+ *
+ *  // no-prefix mode
+ *  getLocalizedUrl('/about', 'fr', ['en', 'fr'], 'en', 'no-prefix');
+ *  // Returns '/about' for any locale
+ * ```
+ *
+ * @param url - The original URL string to be processed.
+ * @param currentLocale - The current locale.
+ * @param locales - Optional array of supported locales. Defaults to configured locales.
+ * @param defaultLocale - The default locale. Defaults to configured default locale.
+ * @param mode - URL routing mode for locale handling. Defaults to configured mode.
+ * @returns The localized URL for the current locale.
+ */
+declare const getLocalizedUrl: (url: string, currentLocale: LocalesValues, locales?: LocalesValues[] | undefined, defaultLocale?: LocalesValues | undefined, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params" | undefined) => string;
+//#endregion
+//#region src/localization/getMultilingualUrls.d.ts
+/**
+ * Generates multilingual URLs by prefixing the given URL with each supported locale
+ * or adding search parameters based on the routing mode.
+ * Handles both absolute and relative URLs appropriately.
+ *
+ * This function gets the locales, default locale, and routing mode from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ *  // prefix-no-default mode
+ *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-no-default')
+ *     // Returns { en: '/dashboard', fr: '/fr/dashboard' }
+ *
+ *  // prefix-all mode
+ *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'prefix-all')
+ *     // Returns { en: '/en/dashboard', fr: '/fr/dashboard' }
+ *
+ *  // search-params mode
+ *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'search-params')
+ *     // Returns { en: '/dashboard?locale=en', fr: '/dashboard?locale=fr' }
+ *
+ *  // no-prefix mode
+ *  getMultilingualUrls('/dashboard', ['en', 'fr'], 'en', 'no-prefix')
+ *     // Returns { en: '/dashboard', fr: '/dashboard' }
+ * ```
+ *
+ * @param url - The original URL string to be processed.
+ * @param locales - Optional array of supported locales. Defaults to configured locales.
+ * @param defaultLocale - The default locale. Defaults to configured default locale.
+ * @param mode - URL routing mode for locale handling. Defaults to configured mode.
+ * @returns An object mapping each locale to its corresponding multilingual URL.
+ */
+declare const getMultilingualUrls: (url: string, locales?: LocalesValues[] | undefined, defaultLocale?: LocalesValues | undefined, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params" | undefined) => StrictModeLocaleMap<string>;
+//#endregion
+//#region src/localization/getPathWithoutLocale.d.ts
+/**
+ * Removes the locale segment from the given URL or pathname if present.
+ * Also removes locale from search parameters if present.
+ *
+ * This function get the locales from the configuration if not provided.
+ *
+ * Example:
+ *
+ * ```ts
+ * getPathWithoutLocale('/en/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('/fr/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('/dashboard') // Returns '/dashboard'
+ * getPathWithoutLocale('dashboard') // Returns 'dashboard'
+ * getPathWithoutLocale('/dashboard?locale=fr') // Returns '/dashboard'
+ * getPathWithoutLocale('https://example.com/en/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/fr/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/dashboard') // Returns 'https://example.com/dashboard'
+ * getPathWithoutLocale('https://example.com/dashboard?locale=fr') // Returns 'https://example.com/dashboard'
+ * ```
+ *
+ * @param inputUrl - The complete URL string or pathname to process.
+ * @param locales - Optional array of supported locales. Defaults to `localesDefault`.
+ * @returns The URL string or pathname without the locale segment or locale search parameter.
+ */
+declare const getPathWithoutLocale: (inputUrl: string, locales?: LocalesValues[]) => string;
+//#endregion
+//#region src/localization/localeDetector.d.ts
+/**
+ * Detects the locale from the request headers
+ *
+ * Headers are provided by the browser and can be used to determine the user's preferred language
+ */
+declare const localeDetector: (headers: Record<string, string | undefined>, locales?: Locale[], defaultLocale?: Locale) => Locale;
+//#endregion
+//#region src/localization/localeMapper.d.ts
+type LocaleData = {
+  locale: Locale;
+  defaultLocale: Locale;
+  isDefault: boolean;
+  locales: Locale[];
+  urlPrefix: string;
+};
+/**
+ * Map the locale data to an array of objects
+ *
+ * @example
+ * ```ts
+ * const routes = localeMap((localizedData) =>
+ * ({
+ *    path: localizedData.urlPrefix,
+ *    name: localizedData.locale,
+ *    isDefault: localizedData.isDefault,
+ *    locales: localizedData.locales,
+ *    defaultLocale: localizedData.defaultLocale,
+ *  }),
+ * );
+ *
+ * // Result
+ * [
+ *   { path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' },
+ *   { path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' },
+ *   { path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' },
+ * ]
+ * ```
+ *
+ * @param mapper - The mapper function that returns an object
+ * @returns An array of objects
+ */
+declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+/**
+ * Flatten the locale map into a single array of objects
+ *
+ * @example
+ * ```ts
+ * const routes = localeMap((localizedData) =>
+ * [{
+ *    path: localizedData.urlPrefix,
+ *    name: localizedData.locale,
+ *    isDefault: localizedData.isDefault,
+ *    locales: localizedData.locales,
+ *    defaultLocale: localizedData.defaultLocale,
+ *  }],
+ * );
+ *
+ * // Result
+ * [
+ *   path: '/', name: 'en', isDefault: true, locales: ['en'], defaultLocale: 'en', urlPrefix: '' ,
+ *   path: '/fr', name: 'fr', isDefault: false, locales: ['fr'], defaultLocale: 'en', urlPrefix: '/fr' ,
+ *   path: '/es', name: 'es', isDefault: false, locales: ['es'], defaultLocale: 'en', urlPrefix: '/es' ,
+ * ]
+ * ```
+ *
+ * @param mapper - The mapper function that returns an array of objects
+ * @returns An array of objects
+ */
+declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+/**
+ * Creates a record object mapping locales to values transformed by the mapper function
+ *
+ * @example
+ * ```ts
+ * const translations = localeRecord(({ locale }) =>
+ *   require(`./translations/${locale}.json`)
+ * );
+ *
+ * // Result
+ *
+ *   en: ... , // Content of translations/en.json
+ *   fr: ... , // Content of translations/fr.json
+ *   es: ...
+ *
+ * ```
+ *
+ * @param mapper - Function that takes locale data and returns a value for that locale
+ * @param locales - Array of locale codes to map over (defaults to configured locales)
+ * @param defaultLocale - The default locale (defaults to configured default)
+ * @param mode - URL routing mode for locale handling (defaults to configured value)
+ * @returns Record mapping locale codes to mapped values
+ */
+declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => Record<LocalesValues, T>;
+//#endregion
+//#region src/localization/localeResolver.d.ts
+/**
+ * Resolves the most specific locale from a user-provided list,
+ * or falls back to the default locale if no match is found.
+ */
+declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => Locale;
+//#endregion
+//#region src/utils/checkIsURLAbsolute.d.ts
+declare const checkIsURLAbsolute: (url: string) => boolean;
+//#endregion
+//#region src/utils/intl.d.ts
+type IntlConstructors = { [K in keyof typeof Intl as (typeof Intl)[K] extends (new (...args: any) => any) ? K : never]: (typeof Intl)[K] };
+type ReplaceLocaleWithLocalesValues<T> = T extends (new (locales: any, options?: infer Options) => infer Instance) ? new (locales?: LocalesValues, options?: Options) => Instance : T extends (new (locales: any) => infer Instance) ? new (locales?: LocalesValues) => Instance : T;
+type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors ? ReplaceLocaleWithLocalesValues<(typeof Intl)[K]> : (typeof Intl)[K] };
+declare const createCachedIntl: () => WrappedIntl;
+declare const CachedIntl: WrappedIntl;
+//#endregion
+//#region src/utils/isSameKeyPath.d.ts
+declare const isSameKeyPath: (keyPath1: KeyPath[], keyPath2: KeyPath[]) => boolean;
+//#endregion
+//#region src/utils/isValidReactElement.d.ts
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param object
+ * @return True if `object` is a ReactElement.
+ * @final
+ */
+declare const isValidElement: (object: any) => boolean;
+//#endregion
+//#region src/utils/parseYaml.d.ts
+declare const parseYaml: <T = any>(input: string) => T | null;
+//#endregion
+export { CachedIntl, CachedIntl as Intl, ConditionCond, ConditionContent, ConditionContentStates, DeepTransformContent, DotPath, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, FileCond, FileContent, FileContentConstructor, Gender, GenderCond, GenderContent, GenderContentStates, GetNestingResult, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, InsertionContent, InsertionContentConstructor, IsAny, LocaleStorage, LocaleStorageOptions, MarkdownContent, MarkdownContentConstructor, NestedCond, NestedContent, NestedContentState, NodeProps, Plugins, ProcessedStorageAttributes, TranslationCond, TranslationContent, ValidDotPathsFor, buildMaskPlugin, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, condition as cond, conditionPlugin, createCachedIntl, currency, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, file, fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, getBrowserLocale, getCondition, getContent, getContentNodeByKeyPath, getDefaultNode, getDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getHTMLTextDir, getInsertionValues, getIntlayer, getLocaleFromPath, getLocaleFromStorage, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getReplacedValuesContent, getSplittedContent, getSplittedDictionaryContent, getStorageAttributes, getTranslation, insertion as insert, insertContentInDictionary, insertionPlugin, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, nesting as nest, nestedPlugin, normalizeDictionaries, normalizeDictionary, number, orderDictionaries, parseYaml, percentage, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, setLocaleInStorage, translation as t, translationPlugin, units, updateNodeChildren };