@intlayer/config 9.4.3 → 9.5.0

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

@@ -5,7 +5,6 @@
  * (@intlayer/babel, @intlayer/vue-compiler, @intlayer/svelte-compiler, @intlayer/engine)
  * and the `eslint-plugin-intlayer` `no-raw-text` rule.
  */
-declare const ATTRIBUTES_TO_EXTRACT: readonly ['title', 'placeholder', 'alt', 'aria-label', 'label'];
+export declare const ATTRIBUTES_TO_EXTRACT: readonly ['title', 'placeholder', 'alt', 'aria-label', 'label'];
 //#endregion
-export { ATTRIBUTES_TO_EXTRACT };
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/extract/constants.ts"],"mappings":";;;;;;;cAMa"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/extract/constants.ts"],"mappings":";;;;;;;qBAMa"}

package/dist/types/extract/shouldExtract.d.ts

@@ -9,7 +9,6 @@
  * - Uncapitalized strings of 2 words or fewer (likely technical terms)
  * - Dynamic content patterns like Vue bindings (`v-`) or object patterns (`{`)
  */
-declare const shouldExtract: (text: string) => boolean;
+export declare const shouldExtract: (text: string) => boolean;
 //#endregion
-export { shouldExtract };
 //# sourceMappingURL=shouldExtract.d.ts.map

package/dist/types/extract/shouldExtract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shouldExtract.d.ts","names":[],"sources":["../../../src/extract/shouldExtract.ts"],"mappings":";;;;;;;;;;;cAUa,gBAAa"}
+{"version":3,"file":"shouldExtract.d.ts","names":[],"sources":["../../../src/extract/shouldExtract.ts"],"mappings":";;;;;;;;;;;qBAUa,gBAAa"}

package/dist/types/loadEnvFile.d.ts

@@ -1,10 +1,9 @@
 //#region src/loadEnvFile.d.ts
-type LoadEnvFileOptions = {
+export type LoadEnvFileOptions = {
   env?: string;
   envFile?: string;
 };
-declare const getEnvFilePath: (env?: string, envFile?: string) => string | undefined;
-declare const loadEnvFile: (options?: Partial<LoadEnvFileOptions>) => Record<string, string>;
+export declare const getEnvFilePath: (env?: string, envFile?: string) => string | undefined;
+export declare const loadEnvFile: (options?: Partial<LoadEnvFileOptions>) => Record<string, string>;
 //#endregion
-export { LoadEnvFileOptions, getEnvFilePath, loadEnvFile };
 //# sourceMappingURL=loadEnvFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"loadEnvFile.d.ts","names":[],"sources":["../../src/loadEnvFile.ts"],"mappings":";KAKY;EACV;EACA;;cAGW,iBAAc,cACd;cAwCA,cAAW,UACZ,QAAQ,wBACjB"}
+{"version":3,"file":"loadEnvFile.d.ts","names":[],"sources":["../../src/loadEnvFile.ts"],"mappings":";YAKY;EACV;EACA;;qBAGW,iBAAc,cACd;qBAwCA,cAAW,UACZ,QAAQ,wBACjB"}

package/dist/types/loadExternalFile/bundleFile.d.ts

@@ -1,9 +1,8 @@
 import { BuildOptions, Loader, Plugin } from "esbuild";
 //#region src/loadExternalFile/bundleFile.d.ts
-type ESBuildPlugin = Plugin;
-declare const getLoader: (extension: string) => Loader;
-declare const bundleFileSync: (code: string, filePath: string, options?: BuildOptions) => string | undefined;
-declare const bundleFile: (code: string, filePath: string, options?: BuildOptions) => Promise<string | undefined>;
+export type ESBuildPlugin = Plugin;
+export declare const getLoader: (extension: string) => Loader;
+export declare const bundleFileSync: (code: string, filePath: string, options?: BuildOptions) => string | undefined;
+export declare const bundleFile: (code: string, filePath: string, options?: BuildOptions) => Promise<string | undefined>;
 //#endregion
-export { ESBuildPlugin, bundleFile, bundleFileSync, getLoader };
 //# sourceMappingURL=bundleFile.d.ts.map

package/dist/types/loadExternalFile/bundleFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundleFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleFile.ts"],"mappings":";;KAWY,gBAAgB;cAEf,YAAS,sBAAwB;cAiDjC,iBAAc,cACb,kBACI,UACN;cAqBC,aAAU,cACT,kBACI,UACN,iBACT"}
+{"version":3,"file":"bundleFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleFile.ts"],"mappings":";;YAWY,gBAAgB;qBAEf,YAAS,sBAAwB;qBAiDjC,iBAAc,cACb,kBACI,UACN;qBAqBC,aAAU,cACT,kBACI,UACN,iBACT"}

package/dist/types/loadExternalFile/bundleJSFile.d.ts

@@ -1,6 +1,6 @@
 import { BuildOptions } from "esbuild";
 //#region src/loadExternalFile/bundleJSFile.d.ts
-declare const bundleJSFile: (buildOptions: BuildOptions) => Promise<import("esbuild").BuildResult<{
+export declare const bundleJSFile: (buildOptions: BuildOptions) => Promise<import("esbuild").BuildResult<{
   legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external';
   sourceRoot?: string;
   sourcesContent?: boolean;
@@ -95,5 +95,4 @@ declare const bundleJSFile: (buildOptions: BuildOptions) => Promise<import("esbu
   };
 }>>;
 //#endregion
-export { bundleJSFile };
 //# sourceMappingURL=bundleJSFile.d.ts.map

package/dist/types/loadExternalFile/bundleJSFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundleJSFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleJSFile.ts"],"mappings":";;cAyBa,eAAY,cAAwB,iBAAY,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAZlD;aACC;aACA;aACD;aACC;aACA;aACC;aACF;aACC"}
+{"version":3,"file":"bundleJSFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleJSFile.ts"],"mappings":";;qBAyBa,eAAY,cAAwB,iBAAY,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAZlD;aACC;aACA;aACD;aACC;aACA;aACC;aACF;aACC"}

package/dist/types/loadExternalFile/loadExternalFile.d.ts

@@ -2,7 +2,7 @@ import { SandBoxContextOptions } from "./parseFileContent.js";
 import { TranspileOptions } from "./transpileTSToCJS.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/loadExternalFile/loadExternalFile.d.ts
-type LoadExternalFileOptions = {
+export type LoadExternalFileOptions = {
   configuration?: IntlayerConfig;
   buildOptions?: TranspileOptions;
   logError?: boolean;
@@ -20,13 +20,12 @@ type LoadExternalFileOptions = {
  *
  * Accepts JSON, JS, MJS and TS files as configuration
  */
-declare const loadExternalFileSync: (filePath: string, options?: LoadExternalFileOptions) => any | undefined;
+export declare const loadExternalFileSync: (filePath: string, options?: LoadExternalFileOptions) => any | undefined;
 /**
  * Load the content declaration from the given path
  *
  * Accepts JSON, JS, MJS and TS files as configuration
  */
-declare const loadExternalFile: (filePath: string, options?: LoadExternalFileOptions) => Promise<any | undefined>;
+export declare const loadExternalFile: (filePath: string, options?: LoadExternalFileOptions) => Promise<any | undefined>;
 //#endregion
-export { LoadExternalFileOptions, loadExternalFile, loadExternalFileSync };
 //# sourceMappingURL=loadExternalFile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"loadExternalFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/loadExternalFile.ts"],"mappings":";;;;KAmBY;EACV,gBAAgB;EAChB,eAAe;EACf;;;;;;;;EAQA,iBAAiB;IACf;;;;;;cAOS,uBAAoB,kBACf,UACN;;;;;;cA+FC,mBAAgB,kBACX,UACN,4BACT"}
+{"version":3,"file":"loadExternalFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/loadExternalFile.ts"],"mappings":";;;;YAmBY;EACV,gBAAgB;EAChB,eAAe;EACf;;;;;;;;EAQA,iBAAiB;IACf;;;;;;qBAOS,uBAAoB,kBACf,UACN;;;;;;qBA+FC,mBAAgB,kBACX,UACN,4BACT"}

package/dist/types/loadExternalFile/parseFileContent.d.ts

@@ -1,7 +1,7 @@
 import { LoadEnvFileOptions } from "../loadEnvFile.js";
 import { Context } from "node:vm";
 //#region src/loadExternalFile/parseFileContent.d.ts
-type SandBoxContextOptions = {
+export type SandBoxContextOptions = {
   envVarOptions?: LoadEnvFileOptions;
   projectRequire?: NodeJS.Require;
   additionalEnvVars?: Record<string, string>;
@@ -30,8 +30,7 @@ type SandBoxContextOptions = {
  * full host privileges. Only ever run trusted, build-time project files
  * (same trust model as `vite.config.ts`).
  */
-declare const getSandBoxContext: (options?: SandBoxContextOptions) => Context;
-declare const parseFileContent: <T>(fileContentString: string, options?: SandBoxContextOptions) => T | undefined;
+export declare const getSandBoxContext: (options?: SandBoxContextOptions) => Context;
+export declare const parseFileContent: <T>(fileContentString: string, options?: SandBoxContextOptions) => T | undefined;
 //#endregion
-export { SandBoxContextOptions, getSandBoxContext, parseFileContent };
 //# sourceMappingURL=parseFileContent.d.ts.map

package/dist/types/loadExternalFile/parseFileContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseFileContent.d.ts","names":[],"sources":["../../../src/loadExternalFile/parseFileContent.ts"],"mappings":";;;KAKY;EACV,gBAAgB;EAChB,iBAAiB,OAAO;EACxB,oBAAoB;;;;;;;;EAQpB,QAAQ;;;;;;;EAOR,UAAU;;;;;;;;;;;cA2FC,oBAAiB,UAAc,0BAAwB;cAuEvD,mBAAoB,GAAC,2BACP,UACf,0BACT"}
+{"version":3,"file":"parseFileContent.d.ts","names":[],"sources":["../../../src/loadExternalFile/parseFileContent.ts"],"mappings":";;;YAKY;EACV,gBAAgB;EAChB,iBAAiB,OAAO;EACxB,oBAAoB;;;;;;;;EAQpB,QAAQ;;;;;;;EAOR,UAAU;;;;;;;;;;;qBA2FC,oBAAiB,UAAc,0BAAwB;qBAuEvD,mBAAoB,GAAC,2BACP,UACf,0BACT"}

package/dist/types/loadExternalFile/transpileTSToCJS.d.ts

@@ -1,6 +1,6 @@
 import { BuildOptions } from "esbuild";
 //#region src/loadExternalFile/transpileTSToCJS.d.ts
-type TranspileOptions = BuildOptions & {
+export type TranspileOptions = BuildOptions & {
   /**
    * Optional custom esbuild instance to use for transpilation.
    * Useful in environments (e.g. VS Code extensions) where the bundled
@@ -11,9 +11,8 @@ type TranspileOptions = BuildOptions & {
   esbuildInstance?: typeof import('esbuild');
 };
 /** Clears the in-memory transpilation cache (mainly for tests). */
-declare const clearTranspileCache: () => void;
-declare const transpileTSToCJSSync: (code: string, filePath: string, options?: TranspileOptions) => string | undefined;
-declare const transpileTSToCJS: (code: string, filePath: string, options?: TranspileOptions) => Promise<string | undefined>;
+export declare const clearTranspileCache: () => void;
+export declare const transpileTSToCJSSync: (code: string, filePath: string, options?: TranspileOptions) => string | undefined;
+export declare const transpileTSToCJS: (code: string, filePath: string, options?: TranspileOptions) => Promise<string | undefined>;
 //#endregion
-export { TranspileOptions, clearTranspileCache, transpileTSToCJS, transpileTSToCJSSync };
 //# sourceMappingURL=transpileTSToCJS.d.ts.map

package/dist/types/loadExternalFile/transpileTSToCJS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transpileTSToCJS.d.ts","names":[],"sources":["../../../src/loadExternalFile/transpileTSToCJS.ts"],"mappings":";;KAeY,mBAAmB;;;;;;;;EAQ7B;;;cA4KW;cAKA,uBAAoB,cACnB,kBACI,UACN;cAsFC,mBAAgB,cACf,kBACI,UACN,qBACT"}
+{"version":3,"file":"transpileTSToCJS.d.ts","names":[],"sources":["../../../src/loadExternalFile/transpileTSToCJS.ts"],"mappings":";;YAeY,mBAAmB;;;;;;;;EAQ7B;;;qBA4KW;qBAKA,uBAAoB,cACnB,kBACI,UACN;qBAsFC,mBAAgB,cACf,kBACI,UACN,qBACT"}

package/dist/types/logger.d.ts

@@ -2,46 +2,45 @@ import { colors_d_exports } from "./colors.js";
 import { CustomIntlayerConfig, IntlayerConfig } from "@intlayer/types/config";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/logger.d.ts
-type ANSIColorsType = (typeof colors_d_exports)[keyof typeof colors_d_exports];
-type Details = {
+export type ANSIColorsType = (typeof colors_d_exports)[keyof typeof colors_d_exports];
+export type Details = {
   isVerbose?: boolean;
   level?: 'info' | 'warn' | 'error' | 'debug';
   config?: CustomIntlayerConfig['log'];
 };
-type Logger = (content: any, details?: Details) => void;
-declare const setPrefix: (prefix: string | undefined) => void;
-declare const getPrefix: (configPrefix?: string) => string | undefined;
-declare const logger: Logger;
-declare const spinnerFrames: string[];
+export type Logger = (content: any, details?: Details) => void;
+export declare const setPrefix: (prefix: string | undefined) => void;
+export declare const getPrefix: (configPrefix?: string) => string | undefined;
+export declare const logger: Logger;
+export declare const spinnerFrames: string[];
 /**
  * The appLogger function takes the logger and merges it with the configuration from the intlayer config file.
  * It allows overriding the default configuration by passing a config object in the details parameter.
  * The configuration is merged with the default configuration from the intlayer config file.
  */
-declare const getAppLogger: (configuration?: Pick<IntlayerConfig, 'log'>, globalDetails?: Details) => (content: any, details?: Details) => void;
-declare const colorize: (string: string, color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
-declare const colorizeLocales: (locales: Locale | Locale[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
-declare const colorizeKey: (keyPath: string | string[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
-declare const colorizePath: (path: string | string[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
-declare const colorizeNumber: (number: number | string, options?: Partial<Record<Intl.LDMLPluralRule, ANSIColorsType>>) => string;
-declare const colorizeObject: (obj: any, indentLevel?: number, indentSize?: number, key?: string) => string;
-declare const removeColor: (text: string) => string;
+export declare const getAppLogger: (configuration?: Pick<IntlayerConfig, 'log'>, globalDetails?: Details) => (content: any, details?: Details) => void;
+export declare const colorize: (string: string, color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
+export declare const colorizeLocales: (locales: Locale | Locale[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
+export declare const colorizeKey: (keyPath: string | string[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
+export declare const colorizePath: (path: string | string[], color?: ANSIColorsType, reset?: boolean | ANSIColorsType) => string;
+export declare const colorizeNumber: (number: number | string, options?: Partial<Record<Intl.LDMLPluralRule, ANSIColorsType>>) => string;
+export declare const colorizeObject: (obj: any, indentLevel?: number, indentSize?: number, key?: string) => string;
+export declare const removeColor: (text: string) => string;
 /**
  * Create a string of spaces of a given length.
  *
  * @param colSize - The length of the string to create.
  * @returns A string of spaces.
  */
-declare const colon: (text: string | string[], options?: {
+export declare const colon: (text: string | string[], options?: {
   colSize?: number | number[] | string | string[];
   minSize?: number;
   maxSize?: number;
   pad?: 'left' | 'right';
   padChar?: string;
 }) => string;
-declare const x: string;
-declare const v: string;
-declare const clock: string;
+export declare const x: string;
+export declare const v: string;
+export declare const clock: string;
 //#endregion
-export { ANSIColorsType, Details, Logger, clock, colon, colorize, colorizeKey, colorizeLocales, colorizeNumber, colorizeObject, colorizePath, getAppLogger, getPrefix, logger, removeColor, setPrefix, spinnerFrames, v, x };
 //# sourceMappingURL=logger.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/logger.ts"],"mappings":";;;;KAkBY,yBACF,+BAA8B;KAE5B;EACV;EACA;EACA,SAAS;;KAGC,UAAU,cAAc,UAAU;cAIjC,YAAS;cAIT,YAAS;cAQT,QAAQ;cAgBR;;;;;;cAOA,eAAY,gBACN,KAAK,wBAAsB,gBAAkB,aAAO,cACxD,UAAY;cAUd,WAAQ,gBACL,QACN,gBAAc,kBACJ;cAMP,kBAAe,SACjB,SAAS,UAAQ,QACnB,gBAAc,kBACJ;cAON,cAAW,4BACI,QACnB,gBAAc,kBACJ;cAON,eAAY,yBACA,QAChB,gBAAc,kBACJ;cAON,iBAAc,yBACF,UACd,QAAQ,OAAO,KAAK,gBAAgB;cAqBlC,iBAAc,UACjB,sBAAA,qBAAA;cAiFG,cAAW;;;;;;;cAyCX,QAAK,yBACO;EAErB;EACA;EACA;EACA;EACA;;cAyBS;cACA;cACA"}
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/logger.ts"],"mappings":";;;;YAkBY,yBACF,+BAA8B;YAE5B;EACV;EACA;EACA,SAAS;;YAGC,UAAU,cAAc,UAAU;qBAIjC,YAAS;qBAIT,YAAS;qBAQT,QAAQ;qBAgBR;;;;;;qBAOA,eAAY,gBACN,KAAK,wBAAsB,gBAAkB,aAAO,cACxD,UAAY;qBAUd,WAAQ,gBACL,QACN,gBAAc,kBACJ;qBAMP,kBAAe,SACjB,SAAS,UAAQ,QACnB,gBAAc,kBACJ;qBAON,cAAW,4BACI,QACnB,gBAAc,kBACJ;qBAON,eAAY,yBACA,QAChB,gBAAc,kBACJ;qBAON,iBAAc,yBACF,UACd,QAAQ,OAAO,KAAK,gBAAgB;qBAqBlC,iBAAc,UACjB,sBAAA,qBAAA;qBAiFG,cAAW;;;;;;;qBAyCX,QAAK,yBACO;EAErB;EACA;EACA;EACA;EACA;;qBAyBS;qBACA;qBACA"}

package/dist/types/secrets.browser.d.ts

@@ -13,7 +13,6 @@
  *
  * @returns `undefined`.
  */
-declare const getEditorClientSecret: () => string | undefined;
+export declare const getEditorClientSecret: () => string | undefined;
 //#endregion
-export { getEditorClientSecret };
 //# sourceMappingURL=secrets.browser.d.ts.map

package/dist/types/secrets.browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secrets.browser.d.ts","names":[],"sources":["../../src/secrets.browser.ts"],"mappings":";;;;;;;;;;;;;;;cAea"}
+{"version":3,"file":"secrets.browser.d.ts","names":[],"sources":["../../src/secrets.browser.ts"],"mappings":";;;;;;;;;;;;;;;qBAea"}

package/dist/types/secrets.d.ts

@@ -39,7 +39,6 @@
  *
  * @returns The OAuth2 client secret, or `undefined`.
  */
-declare const getEditorClientSecret: () => string | undefined;
+export declare const getEditorClientSecret: () => string | undefined;
 //#endregion
-export { getEditorClientSecret };
 //# sourceMappingURL=secrets.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"secrets.d.ts","names":[],"sources":["../../src/secrets.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCa"}
+{"version":3,"file":"secrets.d.ts","names":[],"sources":["../../src/secrets.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCa"}

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

@@ -1,17 +1,16 @@
 //#region src/utils/ESMxCJSHelpers.d.ts
-declare const isESModule: boolean;
+export declare const isESModule: boolean;
 /**
  * Require relative to the user project
  *
  * Note: Can resolve package that are installed in the user project, ex `'intlayer'`
  */
-declare const getProjectRequire: (startDir?: string) => NodeJS.Require;
+export declare const getProjectRequire: (startDir?: string) => NodeJS.Require;
 /**
  * Require relative to the @intlayer/config package
  *
  * Note: Can resolve package that are installed in the config package, ex `'@intlayer/types'`
  */
-declare const configESMxCJSRequire: NodeJS.Require;
+export declare const configESMxCJSRequire: NodeJS.Require;
 //#endregion
-export { configESMxCJSRequire, getProjectRequire, isESModule };
 //# sourceMappingURL=ESMxCJSHelpers.d.ts.map

package/dist/types/utils/ESMxCJSHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ESMxCJSHelpers.d.ts","names":[],"sources":["../../../src/utils/ESMxCJSHelpers.ts"],"mappings":";cAGa;;;;;;cAOA,oBAAiB,sBAAwB,OAAO;;;;;;cAYhD,sBAAsB,OAAO"}
+{"version":3,"file":"ESMxCJSHelpers.d.ts","names":[],"sources":["../../../src/utils/ESMxCJSHelpers.ts"],"mappings":";qBAGa;;;;;;qBAOA,oBAAiB,sBAAwB,OAAO;;;;;;qBAYhD,sBAAsB,OAAO"}

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

@@ -1,11 +1,11 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/utils/alias.d.ts
-type GetAliasOptions = {
+export type GetAliasOptions = {
   configuration: IntlayerConfig;
   format?: 'esm' | 'cjs';
   formatter?: (value: string) => string;
 };
-declare const getAlias: ({ configuration, format, formatter }: GetAliasOptions) => {
+export declare const getAlias: ({ configuration, format, formatter }: GetAliasOptions) => {
   readonly '@intlayer/dictionaries-entry': string;
   readonly '@intlayer/unmerged-dictionaries-entry': string;
   readonly '@intlayer/remote-dictionaries-entry': string;
@@ -14,5 +14,4 @@ declare const getAlias: ({ configuration, format, formatter }: GetAliasOptions)
   readonly '@intlayer/config/built': string;
 };
 //#endregion
-export { GetAliasOptions, getAlias };
 //# sourceMappingURL=alias.d.ts.map

package/dist/types/utils/alias.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alias.d.ts","names":[],"sources":["../../../src/utils/alias.ts"],"mappings":";;KAKY;EACV,eAAe;EACf;EACA,aAAa;;cAGF,aAAQ,eAAA,QAAA,aAIlB;WAwFC;WACA;WACA;WACA;WACA;WACA"}
+{"version":3,"file":"alias.d.ts","names":[],"sources":["../../../src/utils/alias.ts"],"mappings":";;YAKY;EACV,eAAe;EACf;EACA,aAAa;;qBAGF,aAAQ,eAAA,QAAA,aAIlB;WAwFC;WACA;WACA;WACA;WACA;WACA"}

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

@@ -15,11 +15,10 @@
  * they can never drift: adding a section here is the only change required to
  * expose it in every build target.
  */
-declare const BUILT_CONFIG_KEYS: readonly ["internationalization", "dictionary", "routing", "content", "system", "editor", "analytics", "log", "ai", "build", "compiler", "schemas", "plugins"];
+export declare const BUILT_CONFIG_KEYS: readonly ["internationalization", "dictionary", "routing", "content", "system", "editor", "analytics", "log", "ai", "build", "compiler", "schemas", "plugins"];
 /**
  * Union of the configuration section names exposed by `@intlayer/config/built`.
  */
-type BuiltConfigKey = (typeof BUILT_CONFIG_KEYS)[number];
+export type BuiltConfigKey = (typeof BUILT_CONFIG_KEYS)[number];
 //#endregion
-export { BUILT_CONFIG_KEYS, BuiltConfigKey };
 //# sourceMappingURL=builtConfigKeys.d.ts.map

package/dist/types/utils/builtConfigKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtConfigKeys.d.ts","names":[],"sources":["../../../src/utils/builtConfigKeys.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa;;;;KAmBD,yBAAyB"}
+{"version":3,"file":"builtConfigKeys.d.ts","names":[],"sources":["../../../src/utils/builtConfigKeys.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa;;;;YAmBD,yBAAyB"}

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

@@ -14,8 +14,8 @@ type LocalCacheOptions = {
   compress?: boolean;
 };
 /** Clears the in-memory portion of the disk cache without touching disk files. */
-declare const clearDiskCacheMemory: () => void;
-declare const cacheDisk: (intlayerConfig: IntlayerConfig, keys: CacheKey[], options?: LocalCacheOptions) => {
+export declare const clearDiskCacheMemory: () => void;
+export declare const cacheDisk: (intlayerConfig: IntlayerConfig, keys: CacheKey[], options?: LocalCacheOptions) => {
   /** In-memory first, then disk (if enabled), otherwise undefined. */
   get: <T>() => Promise<T | undefined>;
   /** Sets in-memory (always) and persists to disk if enabled. */
@@ -32,5 +32,4 @@ declare const cacheDisk: (intlayerConfig: IntlayerConfig, keys: CacheKey[], opti
   filePath: string;
 };
 //#endregion
-export { cacheDisk, clearDiskCacheMemory };
 //# sourceMappingURL=cacheDisk.d.ts.map

package/dist/types/utils/cacheDisk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cacheDisk.d.ts","names":[],"sources":["../../../src/utils/cacheDisk.ts"],"mappings":";;;KA8BK;;EAEH;;EAEA;;EAEA;;EAEA;;EAEA;;;cAmDW;cAIA,YAAS,gBACJ,gBAAc,MACxB,YAAU,UACN;;EAoHI,MAAA,QAAM,QAAQ;;EAWP,MAAA,mBAAU;;EAQZ,aAAA;;EAQG,gBAAA;;EAgBD,eAAA"}
+{"version":3,"file":"cacheDisk.d.ts","names":[],"sources":["../../../src/utils/cacheDisk.ts"],"mappings":";;;KA8BK;;EAEH;;EAEA;;EAEA;;EAEA;;EAEA;;;qBAmDW;qBAIA,YAAS,gBACJ,gBAAc,MACxB,YAAU,UACN;;EAoHI,MAAA,QAAM,QAAQ;;EAWP,MAAA,mBAAU;;EAQZ,aAAA;;EAQG,gBAAA;;EAgBD,eAAA"}

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

@@ -1,20 +1,19 @@
 //#region src/utils/cacheMemory.d.ts
 /** Public stringify kept for convenience / debugging (now faster & broader). */
-declare const stableStringify: (value: unknown, _stack?: WeakSet<object>) => string;
+export declare const stableStringify: (value: unknown, _stack?: WeakSet<object>) => string;
 /** Compute a compact, stable id for arbitrary key tuples. */
-declare const computeKeyId: (keyParts: unknown[]) => string;
+export declare const computeKeyId: (keyParts: unknown[]) => string;
 /** ------------------------- In-memory cache ------------------------- **/
-type CacheKey = unknown;
-declare const getCache: <T>(...key: CacheKey[]) => T | undefined;
+export type CacheKey = unknown;
+export declare const getCache: <T>(...key: CacheKey[]) => T | undefined;
 type CacheSetArgs<T> = [...keys: CacheKey[], value: T];
-declare const setCache: <T>(...args: CacheSetArgs<T>) => void;
-declare const clearCache: (idOrKey: string) => void;
-declare const clearAllCache: () => void;
-declare const cacheMemory: {
+export declare const setCache: <T>(...args: CacheSetArgs<T>) => void;
+export declare const clearCache: (idOrKey: string) => void;
+export declare const clearAllCache: () => void;
+export declare const cacheMemory: {
   get: typeof getCache;
   set: typeof setCache;
   clear: typeof clearCache;
 };
 //#endregion
-export { CacheKey, cacheMemory, clearAllCache, clearCache, computeKeyId, getCache, setCache, stableStringify };
 //# sourceMappingURL=cacheMemory.d.ts.map

package/dist/types/utils/cacheMemory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cacheMemory.d.ts","names":[],"sources":["../../../src/utils/cacheMemory.ts"],"mappings":";;cAyRa,kBAAe,gBACZ,SAAA;;cASH,eAAY;;KAab;cAGC,WAAY,MAAC,KAAU,eAAa;KAI5C,aAAa,SAAS,MAAM,YAAY,OAAO;cAEvC,WAAY,MAAC,MAAW,aAAa;cAMrC,aAAU;cAKV;cAIA;EACX,YAAG;EACH,YAAG;EACH,cAAK"}
+{"version":3,"file":"cacheMemory.d.ts","names":[],"sources":["../../../src/utils/cacheMemory.ts"],"mappings":";;qBAyRa,kBAAe,gBACZ,SAAA;;qBASH,eAAY;;YAab;qBAGC,WAAY,MAAC,KAAU,eAAa;KAI5C,aAAa,SAAS,MAAM,YAAY,OAAO;qBAEvC,WAAY,MAAC,MAAW,aAAa;qBAMrC,aAAU;qBAKV;qBAIA;EACX,YAAG;EACH,YAAG;EACH,cAAK"}

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

@@ -2,7 +2,6 @@
 /**
  * Recursively clears the require cache for a module and all its dependencies
  */
-declare const clearModuleCache: (modulePath: string, visited?: Set<string>) => void;
+export declare const clearModuleCache: (modulePath: string, visited?: Set<string>) => void;
 //#endregion
-export { clearModuleCache };
 //# sourceMappingURL=clearModuleCache.d.ts.map

package/dist/types/utils/clearModuleCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clearModuleCache.d.ts","names":[],"sources":["../../../src/utils/clearModuleCache.ts"],"mappings":";;;;cAKa,mBAAgB,oBACT,UAAA"}
+{"version":3,"file":"clearModuleCache.d.ts","names":[],"sources":["../../../src/utils/clearModuleCache.ts"],"mappings":";;;;qBAKa,mBAAgB,oBACT,UAAA"}

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

@@ -7,7 +7,6 @@
  * @param comparison - type of comparison: 'gt', 'lt', 'eq', 'gte', 'lte'
  * @returns boolean indicating if version1 meets the specified comparison condition vs version2
  */
-declare const compareVersions: (version1: string, comparison: '>' | '<' | '=' | '≥' | '≤', version2: string) => boolean;
+export declare const compareVersions: (version1: string, comparison: '>' | '<' | '=' | '≥' | '≤', version2: string) => boolean;
 //#endregion
-export { compareVersions };
 //# sourceMappingURL=compareVersions.d.ts.map

package/dist/types/utils/compareVersions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareVersions.d.ts","names":[],"sources":["../../../src/utils/compareVersions.ts"],"mappings":";;;;;;;;;cAQa,kBAAe,kBACV,yCACuB"}
+{"version":3,"file":"compareVersions.d.ts","names":[],"sources":["../../../src/utils/compareVersions.ts"],"mappings":";;;;;;;;;qBAQa,kBAAe,kBACV,yCACuB"}

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

@@ -1,5 +1,4 @@
 //#region src/utils/extractErrorMessage.d.ts
-declare const extractErrorMessage: (error: unknown) => string;
+export declare const extractErrorMessage: (error: unknown) => string;
 //#endregion
-export { extractErrorMessage };
 //# sourceMappingURL=extractErrorMessage.d.ts.map

package/dist/types/utils/extractErrorMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractErrorMessage.d.ts","names":[],"sources":["../../../src/utils/extractErrorMessage.ts"],"mappings":";cAAa,sBAAmB"}
+{"version":3,"file":"extractErrorMessage.d.ts","names":[],"sources":["../../../src/utils/extractErrorMessage.ts"],"mappings":";qBAAa,sBAAmB"}

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

@@ -16,7 +16,6 @@ type DictionaryOrGroup = Dictionary | QualifiedDictionaryGroup;
  * // true  → at least one collection / variant / meta dictionary
  * // false → only plain dictionaries (selector logic can be stripped)
  */
-declare const getHasDictionarySelector: (dictionaries: Record<string, DictionaryOrGroup> | DictionaryOrGroup[]) => boolean;
+export declare const getHasDictionarySelector: (dictionaries: Record<string, DictionaryOrGroup> | DictionaryOrGroup[]) => boolean;
 //#endregion
-export { getHasDictionarySelector };
 //# sourceMappingURL=getDictionarySelectorUsage.d.ts.map

package/dist/types/utils/getDictionarySelectorUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionarySelectorUsage.d.ts","names":[],"sources":["../../../src/utils/getDictionarySelectorUsage.ts"],"mappings":";;KAKK,oBAAoB,aAAa;;;;;;;;;;;;;;;;cAiBzB,2BAAwB,cACrB,eAAe,qBAAqB"}
+{"version":3,"file":"getDictionarySelectorUsage.d.ts","names":[],"sources":["../../../src/utils/getDictionarySelectorUsage.ts"],"mappings":";;KAKK,oBAAoB,aAAa;;;;;;;;;;;;;;;;qBAiBzB,2BAAwB,cACrB,eAAe,qBAAqB"}

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

@@ -1,6 +1,5 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/utils/getExtension.d.ts
-declare const getExtension: (configuration: IntlayerConfig, format?: 'esm' | 'cjs' | undefined) => "cjs" | "mjs";
+export declare const getExtension: (configuration: IntlayerConfig, format?: 'esm' | 'cjs' | undefined) => "cjs" | "mjs";
 //#endregion
-export { getExtension };
 //# sourceMappingURL=getExtension.d.ts.map

package/dist/types/utils/getExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getExtension.d.ts","names":[],"sources":["../../../src/utils/getExtension.ts"],"mappings":";;cAEa,eAAY,eACR,gBAAc"}
+{"version":3,"file":"getExtension.d.ts","names":[],"sources":["../../../src/utils/getExtension.ts"],"mappings":";;qBAEa,eAAY,eACR,gBAAc"}

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

@@ -3,7 +3,6 @@ type PackageJsonPathCache = {
   packageJsonPath: string;
   baseDir: string;
 };
-declare const getPackageJsonPath: (startDir?: string) => PackageJsonPathCache;
+export declare const getPackageJsonPath: (startDir?: string) => PackageJsonPathCache;
 //#endregion
-export { getPackageJsonPath };
 //# sourceMappingURL=getPackageJsonPath.d.ts.map

package/dist/types/utils/getPackageJsonPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPackageJsonPath.d.ts","names":[],"sources":["../../../src/utils/getPackageJsonPath.ts"],"mappings":";KAMK;EACH;EACA;;cAGW,qBAAkB,sBAE5B"}
+{"version":3,"file":"getPackageJsonPath.d.ts","names":[],"sources":["../../../src/utils/getPackageJsonPath.ts"],"mappings":";KAMK;EACH;EACA;;qBAGW,qBAAkB,sBAE5B"}

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

@@ -7,7 +7,6 @@ import { ProcessedStorageAttributes, RoutingStorageInput } from "@intlayer/types
  * @param options - The storage configuration from IntlayerConfig
  * @returns An object containing arrays for cookies, localStorage, sessionStorage and headers
  */
-declare const getStorageAttributes: (options: RoutingStorageInput) => ProcessedStorageAttributes;
+export declare const getStorageAttributes: (options: RoutingStorageInput) => ProcessedStorageAttributes;
 //#endregion
-export { getStorageAttributes };
 //# sourceMappingURL=getStorageAttributes.d.ts.map

package/dist/types/utils/getStorageAttributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getStorageAttributes.d.ts","names":[],"sources":["../../../src/utils/getStorageAttributes.ts"],"mappings":";;;;;;;;;cA+Ma,uBAAoB,SACtB,wBACR"}
+{"version":3,"file":"getStorageAttributes.d.ts","names":[],"sources":["../../../src/utils/getStorageAttributes.ts"],"mappings":";;;;;;;;;qBA+Ma,uBAAoB,SACtB,wBACR"}

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

@@ -1,7 +1,7 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { PLUGIN_NODE_TYPES } from "@intlayer/types/nodeType";
 //#region src/utils/getUsedNodeTypes.d.ts
-type PluginNodeType = (typeof PLUGIN_NODE_TYPES)[number];
+export type PluginNodeType = (typeof PLUGIN_NODE_TYPES)[number];
 /**
  * Returns the set of NodeType strings actually used across the given
  * built dictionaries.
@@ -10,10 +10,9 @@ type PluginNodeType = (typeof PLUGIN_NODE_TYPES)[number];
  * const used = getUsedNodeTypes(getDictionaries(config));
  * // Set { 'translation', 'enumeration' }
  */
-declare const getUsedNodeTypes: (dictionaries: Record<string, Dictionary> | Dictionary[]) => PluginNodeType[];
-declare const getUnusedNodeTypes: (dictionaries: Record<string, Dictionary> | Dictionary[]) => PluginNodeType[];
-declare const getUsedNodeTypesAsync: (dictionaries: Record<string, Dictionary> | Dictionary[]) => Promise<PluginNodeType[]>;
-declare const getUnusedNodeTypesAsync: (dictionaries: Record<string, Dictionary> | Dictionary[]) => Promise<PluginNodeType[]>;
+export declare const getUsedNodeTypes: (dictionaries: Record<string, Dictionary> | Dictionary[]) => PluginNodeType[];
+export declare const getUnusedNodeTypes: (dictionaries: Record<string, Dictionary> | Dictionary[]) => PluginNodeType[];
+export declare const getUsedNodeTypesAsync: (dictionaries: Record<string, Dictionary> | Dictionary[]) => Promise<PluginNodeType[]>;
+export declare const getUnusedNodeTypesAsync: (dictionaries: Record<string, Dictionary> | Dictionary[]) => Promise<PluginNodeType[]>;
 //#endregion
-export { PluginNodeType, getUnusedNodeTypes, getUnusedNodeTypesAsync, getUsedNodeTypes, getUsedNodeTypesAsync };
 //# sourceMappingURL=getUsedNodeTypes.d.ts.map

package/dist/types/utils/getUsedNodeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUsedNodeTypes.d.ts","names":[],"sources":["../../../src/utils/getUsedNodeTypes.ts"],"mappings":";;;KAQY,yBAAyB;;;;;;;;;cAyDxB,mBAAgB,cACb,eAAe,cAAc,iBAC1C;cAaU,qBAAkB,cACf,eAAe,cAAc,iBAC1C;cAQU,wBAAqB,cAClB,eAAe,cAAc,iBAC1C,QAAQ;cA0BE,0BAAuB,cACpB,eAAe,cAAc,iBAC1C,QAAQ"}
+{"version":3,"file":"getUsedNodeTypes.d.ts","names":[],"sources":["../../../src/utils/getUsedNodeTypes.ts"],"mappings":";;;YAQY,yBAAyB;;;;;;;;;qBAyDxB,mBAAgB,cACb,eAAe,cAAc,iBAC1C;qBAaU,qBAAkB,cACf,eAAe,cAAc,iBAC1C;qBAQU,wBAAqB,cAClB,eAAe,cAAc,iBAC1C,QAAQ;qBA0BE,0BAAuB,cACpB,eAAe,cAAc,iBAC1C,QAAQ"}

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

@@ -17,7 +17,6 @@
  * @param baseDir - Directory the resolution starts from. Defaults to the current working directory.
  * @returns `true` when the package is installed in the project, `false` otherwise.
  */
-declare const isPackageInstalled: (packageName: string, baseDir?: string) => boolean;
+export declare const isPackageInstalled: (packageName: string, baseDir?: string) => boolean;
 //#endregion
-export { isPackageInstalled };
 //# sourceMappingURL=isPackageInstalled.d.ts.map

package/dist/types/utils/isPackageInstalled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPackageInstalled.d.ts","names":[],"sources":["../../../src/utils/isPackageInstalled.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAoBa,qBAAkB,qBACV"}
+{"version":3,"file":"isPackageInstalled.d.ts","names":[],"sources":["../../../src/utils/isPackageInstalled.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAoBa,qBAAkB,qBACV"}

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

@@ -1,7 +1,6 @@
 //#region src/utils/logStack.d.ts
-declare const logStack: (message: string, options?: {
+export declare const logStack: (message: string, options?: {
   limit: number;
 }) => void;
 //#endregion
-export { logStack };
 //# sourceMappingURL=logStack.d.ts.map

package/dist/types/utils/logStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logStack.d.ts","names":[],"sources":["../../../src/utils/logStack.ts"],"mappings":";cAGa,WAAQ,iBACJ;EACJ"}
+{"version":3,"file":"logStack.d.ts","names":[],"sources":["../../../src/utils/logStack.ts"],"mappings":";qBAGa,WAAQ,iBACJ;EACJ"}

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

@@ -9,7 +9,6 @@
  * @param path - The path to normalize
  * @returns The normalized path
  */
-declare const normalizePath: (path: string) => string;
+export declare const normalizePath: (path: string) => string;
 //#endregion
-export { normalizePath };
 //# sourceMappingURL=normalizePath.d.ts.map

package/dist/types/utils/normalizePath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizePath.d.ts","names":[],"sources":["../../../src/utils/normalizePath.ts"],"mappings":";;;;;;;;;;;cAUa,gBAAa"}
+{"version":3,"file":"normalizePath.d.ts","names":[],"sources":["../../../src/utils/normalizePath.ts"],"mappings":";;;;;;;;;;;qBAUa,gBAAa"}