@intlayer/engine 9.4.3 → 9.4.4

package/dist/types/buildIntlayerDictionary/buildIntlayerDictionary.d.ts

@@ -5,7 +5,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary } from "@intlayer/types/dictionary";
 import { OUTPUT_FORMAT } from "@intlayer/config/defaultValues";
 //#region src/buildIntlayerDictionary/buildIntlayerDictionary.d.ts
-type BuildDictionariesOptions = Partial<{
+export type BuildDictionariesOptions = Partial<{
   formats: typeof OUTPUT_FORMAT;
   importOtherDictionaries: boolean;
   env: 'prod' | 'dev';
@@ -13,12 +13,11 @@ type BuildDictionariesOptions = Partial<{
 /**
  * This function transpile the bundled code to to make dictionaries as JSON files
  */
-declare const buildDictionary: (localDictionariesEntries: Dictionary[], configuration: IntlayerConfig, options?: BuildDictionariesOptions) => Promise<{
+export declare const buildDictionary: (localDictionariesEntries: Dictionary[], configuration: IntlayerConfig, options?: BuildDictionariesOptions) => Promise<{
   unmergedDictionaries: UnmergedDictionaryOutput;
   mergedDictionaries: MergedDictionaryOutput;
   dynamicDictionaries: LocalizedDictionaryOutput;
   fetchDictionaries: LocalizedDictionaryOutput;
 }>;
 //#endregion
-export { BuildDictionariesOptions, buildDictionary };
 //# sourceMappingURL=buildIntlayerDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildIntlayerDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"mappings":";;;;;;;KAuBY,2BAA2B;EACrC,gBAAgB;EAChB;EACA;;;;;cAYW,kBAAe,0BACA,cAAY,eACvB,gBAAc,UACnB,6BAAwB;wBAAxB"}
+{"version":3,"file":"buildIntlayerDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/buildIntlayerDictionary.ts"],"mappings":";;;;;;;YAuBY,2BAA2B;EACrC,gBAAgB;EAChB;EACA;;;;;qBAYW,kBAAe,0BACA,cAAY,eACvB,gBAAc,UACnB,6BAAwB;wBAAxB"}

package/dist/types/buildIntlayerDictionary/processContentDeclaration.d.ts

@@ -4,7 +4,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
 /**
  * Function to load, process the module and return the Intlayer Dictionary from the module file
  */
-declare const processContentDeclaration: (contentDeclaration: Dictionary, configuration: IntlayerConfig) => Promise<Dictionary | undefined>;
+export declare const processContentDeclaration: (contentDeclaration: Dictionary, configuration: IntlayerConfig) => Promise<Dictionary | undefined>;
 //#endregion
-export { processContentDeclaration };
 //# sourceMappingURL=processContentDeclaration.d.ts.map

package/dist/types/buildIntlayerDictionary/processContentDeclaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processContentDeclaration.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"mappings":";;;;;;cASa,4BAAyB,oBAChB,YAAU,eACf,mBACd,QAAQ"}
+{"version":3,"file":"processContentDeclaration.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/processContentDeclaration.ts"],"mappings":";;;;;;qBASa,4BAAyB,oBAChB,YAAU,eACf,mBACd,QAAQ"}

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts

@@ -3,12 +3,12 @@ import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, DictionaryQualifierType, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.d.ts
-type DictionaryResult = {
+export type DictionaryResult = {
   dictionaryPath: string;
   dictionary: Dictionary;
 };
-type LocalizedDictionaryResult = Partial<Record<Locale, DictionaryResult>>;
-type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
+export type LocalizedDictionaryResult = Partial<Record<Locale, DictionaryResult>>;
+export type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
 /**
  * Generates the content of a dictionary entry point file.
  *
@@ -24,7 +24,7 @@ type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
  * @param format - Output module format.
  * @param nestedKeys - Keys referenced through `nest()`, transitively.
  */
-declare const generateDictionaryEntryPoint: (key: string, locales: string[], format?: 'cjs' | 'esm', nestedKeys?: string[]) => string;
+export declare const generateDictionaryEntryPoint: (key: string, locales: string[], format?: 'cjs' | 'esm', nestedKeys?: string[]) => string;
 /**
  * One entry of a qualified loader map.
  *
@@ -34,7 +34,7 @@ declare const generateDictionaryEntryPoint: (key: string, locales: string[], for
  * fan-out): the alias keeps its own tree position but points at the canonical
  * entry's chunk, so equal content is emitted — and downloaded — only once.
  */
-type QualifiedEntrySegments = {
+export type QualifiedEntrySegments = {
   treeSegments: string[];
   chunkSegments: string[];
 };
@@ -49,7 +49,7 @@ type QualifiedEntrySegments = {
  * dynamic imports (Turbopack). Entries whose content is identical share one
  * chunk: their leaves point at the canonical entry's import path.
  */
-declare const generateQualifiedDictionaryEntryPoint: (key: string, qualifierTypes: DictionaryQualifierType[], entries: QualifiedEntrySegments[], locales: string[], format?: 'cjs' | 'esm') => string;
+export declare const generateQualifiedDictionaryEntryPoint: (key: string, qualifierTypes: DictionaryQualifierType[], entries: QualifiedEntrySegments[], locales: string[], format?: 'cjs' | 'esm') => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -66,12 +66,12 @@ declare const generateQualifiedDictionaryEntryPoint: (key: string, qualifierType
  * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
  * ```
  */
-declare const writeDynamicDictionary: (mergedDictionaries: PlainMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[], nestedDictionaryGraph?: Map<string, Set<string>>) => Promise<LocalizedDictionaryOutput>;
-type QualifiedMergedDictionaryResult = {
+export declare const writeDynamicDictionary: (mergedDictionaries: PlainMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[], nestedDictionaryGraph?: Map<string, Set<string>>) => Promise<LocalizedDictionaryOutput>;
+export type QualifiedMergedDictionaryResult = {
   dictionaryPath: string;
   dictionary: QualifiedDictionaryGroup;
 };
-type QualifiedMergedDictionaryOutput = Record<string, QualifiedMergedDictionaryResult>;
+export type QualifiedMergedDictionaryOutput = Record<string, QualifiedMergedDictionaryResult>;
 /**
  * Writes the dynamic chunks and entry points of qualified dictionaries
  * (collections, variants — possibly combined) in
@@ -82,7 +82,6 @@ type QualifiedMergedDictionaryOutput = Record<string, QualifiedMergedDictionaryR
  * `{key}.{ext}` entry point exposes the matching nested loader tree, so the
  * entry point is discovered and aggregated exactly like a plain dynamic one.
  */
-declare const writeDynamicQualifiedDictionaries: (qualifiedDictionaries: QualifiedMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
+export declare const writeDynamicQualifiedDictionaries: (qualifiedDictionaries: QualifiedMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
 //#endregion
-export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, QualifiedEntrySegments, QualifiedMergedDictionaryOutput, QualifiedMergedDictionaryResult, generateDictionaryEntryPoint, generateQualifiedDictionaryEntryPoint, writeDynamicDictionary, writeDynamicQualifiedDictionaries };
 //# sourceMappingURL=writeDynamicDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;KA2BY;EACV;EACA,YAAY;;KAGF,4BAA4B,QACtC,OAAO,QAAQ;KAGL,4BAA4B,eAEtC;;;;;;;;;;;;;;;;cAyCW,+BAA4B,aAC5B,mBACM,wBACI;;;;;;;;;;KAoEX;EACV;EACA;;;;;;;;;;;;;cA8EW,wCAAqC,aACrC,gBACK,2BAAyB,SAChC,0BAAwB,mBAChB;;;;;;;;;;;;;;;;;cAyCN,yBAAsB,oBACb,6BAA2B,eAChC,gBAAc,6BACH,wBACH,YAAY,iBAClC,QAAQ;KA2EC;EACV;EACA,YAAY;;KAGF,kCAAkC,eAE5C;;;;;;;;;;;cAaW,oCAAiC,uBACrB,iCAA+B,eACvC,gBAAc,gCAE5B"}
+{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;YA2BY;EACV;EACA,YAAY;;YAGF,4BAA4B,QACtC,OAAO,QAAQ;YAGL,4BAA4B,eAEtC;;;;;;;;;;;;;;;;qBAyCW,+BAA4B,aAC5B,mBACM,wBACI;;;;;;;;;;YAoEX;EACV;EACA;;;;;;;;;;;;;qBA8EW,wCAAqC,aACrC,gBACK,2BAAyB,SAChC,0BAAwB,mBAChB;;;;;;;;;;;;;;;;;qBAyCN,yBAAsB,oBACb,6BAA2B,eAChC,gBAAc,6BACH,wBACH,YAAY,iBAClC,QAAQ;YA2EC;EACV;EACA,YAAY;;YAGF,kCAAkC,eAE5C;;;;;;;;;;;qBAaW,oCAAiC,uBACrB,iCAA+B,eACvC,gBAAc,gCAE5B"}

package/dist/types/buildIntlayerDictionary/writeFetchDictionary.d.ts

@@ -15,7 +15,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * @param format - Output module format.
  * @param nestedKeys - Keys referenced through `nest()`, transitively.
  */
-declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: 'cjs' | 'esm', nestedKeys?: string[]) => string;
+export declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: 'cjs' | 'esm', nestedKeys?: string[]) => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -32,7 +32,6 @@ declare const generateDictionaryEntryPoint: (key: string, locales: string[], rel
  * // .intlayer/fetch_dictionary/home.cjs
  * ```
  */
-declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[], nestedDictionaryGraph?: Map<string, Set<string>>) => Promise<LocalizedDictionaryOutput>;
+export declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[], nestedDictionaryGraph?: Map<string, Set<string>>) => Promise<LocalizedDictionaryOutput>;
 //#endregion
-export { generateDictionaryEntryPoint, writeFetchDictionary };
 //# sourceMappingURL=writeFetchDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeFetchDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;cAqDa,+BAA4B,aAC5B,mBACM,wBACK,wBACD;;;;;;;;;;;;;;;;;cA2FV,uBAAoB,qBACV,2BAAyB,eAC/B,gBAAc,6BACH,wBACH,YAAY,iBAClC,QAAQ"}
+{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAqDa,+BAA4B,aAC5B,mBACM,wBACK,wBACD;;;;;;;;;;;;;;;;;qBA2FV,uBAAoB,qBACV,2BAAyB,eAC/B,gBAAc,6BACH,wBACH,YAAY,iBAClC,QAAQ"}

package/dist/types/buildIntlayerDictionary/writeMergedDictionary.d.ts

@@ -2,21 +2,21 @@ import { UnmergedDictionaryOutput } from "./writeUnmergedDictionary.js";
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 //#region src/buildIntlayerDictionary/writeMergedDictionary.d.ts
-type MergedDictionaryResult = {
+export type MergedDictionaryResult = {
   dictionaryPath: string;
   dictionary: Dictionary | QualifiedDictionaryGroup;
 };
-type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;
+export type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;
 /**
  * Merged output restricted to plain (unqualified) dictionaries — qualified
  * groups (collections, variants) are static-only and filtered
  * out before the dynamic/fetch build steps.
  */
-type PlainMergedDictionaryResult = {
+export type PlainMergedDictionaryResult = {
   dictionaryPath: string;
   dictionary: Dictionary;
 };
-type PlainMergedDictionaryOutput = Record<string, PlainMergedDictionaryResult>;
+export type PlainMergedDictionaryOutput = Record<string, PlainMergedDictionaryResult>;
 /**
  * Write the merged dictionaries to the dictionariesDir
  * @param groupedDictionaries - The grouped dictionaries
@@ -33,7 +33,6 @@ type PlainMergedDictionaryOutput = Record<string, PlainMergedDictionaryResult>;
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeMergedDictionaries: (groupedDictionaries: UnmergedDictionaryOutput, configuration: IntlayerConfig) => Promise<MergedDictionaryOutput>;
+export declare const writeMergedDictionaries: (groupedDictionaries: UnmergedDictionaryOutput, configuration: IntlayerConfig) => Promise<MergedDictionaryOutput>;
 //#endregion
-export { MergedDictionaryOutput, MergedDictionaryResult, PlainMergedDictionaryOutput, PlainMergedDictionaryResult, writeMergedDictionaries };
 //# sourceMappingURL=writeMergedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeMergedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeMergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"mappings":";;;;KAiBY;EACV;EACA,YAAY,aAAa;;KAGf,yBAAyB,eAAe;;;;;;KAOxC;EACV;EACA,YAAY;;KAGF,8BAA8B,eAExC;;;;;;;;;;;;;;;;;cAmBW,0BAAuB,qBACb,0BAAwB,eAC9B,mBACd,QAAQ"}
+{"version":3,"file":"writeMergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"mappings":";;;;YAiBY;EACV;EACA,YAAY,aAAa;;YAGf,yBAAyB,eAAe;;;;;;YAOxC;EACV;EACA,YAAY;;YAGF,8BAA8B,eAExC;;;;;;;;;;;;;;;;;qBAmBW,0BAAuB,qBACb,0BAAwB,eAC9B,mBACd,QAAQ"}

package/dist/types/buildIntlayerDictionary/writeNestedDictionary.d.ts

@@ -6,7 +6,7 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * because the `**\/*.json` globs listing compiled dictionaries never match the
  * `.mjs` / `.cjs` files written here.
  */
-declare const NESTED_DICTIONARIES_SUBDIR = "nested";
+export declare const NESTED_DICTIONARIES_SUBDIR = "nested";
 /**
  * Path of the companion module carrying the `nest()` targets of a dictionary.
  *
@@ -18,7 +18,7 @@ declare const NESTED_DICTIONARIES_SUBDIR = "nested";
  * @param key - The dictionary key.
  * @param extension - Module extension, `'mjs'` (default) or `'cjs'`.
  */
-declare const getNestedDictionaryPath: (dictionariesDir: string, key: string, extension?: 'mjs' | 'cjs') => string;
+export declare const getNestedDictionaryPath: (dictionariesDir: string, key: string, extension?: 'mjs' | 'cjs') => string;
 /**
  * Generates a companion module that re-exports a compiled dictionary with its
  * `nest()` targets attached.
@@ -40,7 +40,7 @@ declare const getNestedDictionaryPath: (dictionariesDir: string, key: string, ex
  * export default { ..._dictionary, nestedDictionaries: { 'common': _1a2b3c } };
  * ```
  */
-declare const generateNestedDictionaryEntryPoint: (key: string, nestedKeys: string[], format?: 'cjs' | 'esm') => string;
+export declare const generateNestedDictionaryEntryPoint: (key: string, nestedKeys: string[], format?: 'cjs' | 'esm') => string;
 /**
  * Writes one companion module per dictionary holding `nest()` references.
  *
@@ -48,7 +48,6 @@ declare const generateNestedDictionaryEntryPoint: (key: string, nestedKeys: stri
  * @param configuration - The resolved intlayer configuration.
  * @param formats - Module formats to emit.
  */
-declare const writeNestedDictionaries: (nestedDictionaryGraph: Map<string, Set<string>>, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
+export declare const writeNestedDictionaries: (nestedDictionaryGraph: Map<string, Set<string>>, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
 //#endregion
-export { NESTED_DICTIONARIES_SUBDIR, generateNestedDictionaryEntryPoint, getNestedDictionaryPath, writeNestedDictionaries };
 //# sourceMappingURL=writeNestedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeNestedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeNestedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeNestedDictionary.ts"],"mappings":";;;;;;;;cAgBa;;;;;;;;;;;;cAoBA,0BAAuB,yBACX,aACZ;;;;;;;;;;;;;;;;;;;;;;cA0BA,qCAAkC,aAClC,sBACS;;;;;;;;cAkDT,0BAAuB,uBACX,YAAY,cAAY,eAChC,gBAAc,gCAE5B"}
+{"version":3,"file":"writeNestedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeNestedDictionary.ts"],"mappings":";;;;;;;;qBAgBa;;;;;;;;;;;;qBAoBA,0BAAuB,yBACX,aACZ;;;;;;;;;;;;;;;;;;;;;;qBA0BA,qCAAkC,aAClC,sBACS;;;;;;;;qBAkDT,0BAAuB,uBACX,YAAY,cAAY,eAChC,gBAAc,gCAE5B"}

package/dist/types/buildIntlayerDictionary/writeRemoteDictionary.d.ts

@@ -1,11 +1,11 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/buildIntlayerDictionary/writeRemoteDictionary.d.ts
-type RemoteDictionaryResult = {
+export type RemoteDictionaryResult = {
   dictionaryPath: string;
   dictionaries: Dictionary[];
 };
-type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;
+export type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -22,7 +22,6 @@ type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeRemoteDictionary: (remoteDictionaries: Dictionary[], configuration: IntlayerConfig) => Promise<RemoteDictionaryOutput>;
+export declare const writeRemoteDictionary: (remoteDictionaries: Dictionary[], configuration: IntlayerConfig) => Promise<RemoteDictionaryOutput>;
 //#endregion
-export { RemoteDictionaryOutput, RemoteDictionaryResult, writeRemoteDictionary };
 //# sourceMappingURL=writeRemoteDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeRemoteDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeRemoteDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"mappings":";;;KAeY;EACV;EACA,cAAc;;KAGJ,yBAAyB,eAAe;;;;;;;;;;;;;;;;;cAkBvC,wBAAqB,oBACZ,cAAY,eACjB,mBACd,QAAQ"}
+{"version":3,"file":"writeRemoteDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"mappings":";;;YAeY;EACV;EACA,cAAc;;YAGJ,yBAAyB,eAAe;;;;;;;;;;;;;;;;;qBAkBvC,wBAAqB,oBACZ,cAAY,eACjB,mBACd,QAAQ"}

package/dist/types/buildIntlayerDictionary/writeUnmergedDictionary.d.ts

@@ -1,12 +1,12 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, DictionaryKey } from "@intlayer/types/dictionary";
 //#region src/buildIntlayerDictionary/writeUnmergedDictionary.d.ts
-declare const groupDictionariesByKey: (dictionaries: Dictionary[]) => Record<string, Dictionary[]>;
-type UnmergedDictionaryResult = {
+export declare const groupDictionariesByKey: (dictionaries: Dictionary[]) => Record<string, Dictionary[]>;
+export type UnmergedDictionaryResult = {
   dictionaryPath: string;
   dictionaries: Dictionary[];
 };
-type UnmergedDictionaryOutput = Record<DictionaryKey, UnmergedDictionaryResult>;
+export type UnmergedDictionaryOutput = Record<DictionaryKey, UnmergedDictionaryResult>;
 /**
  * Write the unmerged dictionaries to the unmergedDictionariesDir
  * @param dictionaries - The dictionaries to write
@@ -27,7 +27,6 @@ type UnmergedDictionaryOutput = Record<DictionaryKey, UnmergedDictionaryResult>;
  * // }
  * ```
  */
-declare const writeUnmergedDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig, env: 'prod' | 'dev') => Promise<UnmergedDictionaryOutput>;
+export declare const writeUnmergedDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig, env: 'prod' | 'dev') => Promise<UnmergedDictionaryOutput>;
 //#endregion
-export { UnmergedDictionaryOutput, UnmergedDictionaryResult, groupDictionariesByKey, writeUnmergedDictionaries };
 //# sourceMappingURL=writeUnmergedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeUnmergedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeUnmergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeUnmergedDictionary.ts"],"mappings":";;;cAWa,yBAAsB,cACnB,iBACb,eAAe;KAaN;EACV;EACA,cAAc;;KAGJ,2BAA2B,OACrC,eACA;;;;;;;;;;;;;;;;;;;;;cAuBW,4BAAyB,cACtB,cAAY,eACX,gBAAc,wBAE5B,QAAQ"}
+{"version":3,"file":"writeUnmergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeUnmergedDictionary.ts"],"mappings":";;;qBAWa,yBAAsB,cACnB,iBACb,eAAe;YAaN;EACV;EACA,cAAc;;YAGJ,2BAA2B,OACrC,eACA;;;;;;;;;;;;;;;;;;;;;qBAuBW,4BAAyB,cACtB,cAAY,eACX,gBAAc,wBAE5B,QAAQ"}

package/dist/types/cleanOutputDir.d.ts

@@ -1,6 +1,5 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/cleanOutputDir.d.ts
-declare const cleanOutputDir: (configuration: IntlayerConfig) => Promise<void>;
+export declare const cleanOutputDir: (configuration: IntlayerConfig) => Promise<void>;
 //#endregion
-export { cleanOutputDir };
 //# sourceMappingURL=cleanOutputDir.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cleanOutputDir.d.ts","names":[],"sources":["../../src/cleanOutputDir.ts"],"mappings":";;cAKa,iBAAc,eAAyB,mBAAc"}
+{"version":3,"file":"cleanOutputDir.d.ts","names":[],"sources":["../../src/cleanOutputDir.ts"],"mappings":";;qBAKa,iBAAc,eAAyB,mBAAc"}

package/dist/types/cleanRemovedContentDeclaration.d.ts

@@ -1,10 +1,9 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/cleanRemovedContentDeclaration.d.ts
-declare const cleanRemovedContentDeclaration: (filePath: string, keysToKeep: string[], configuration: IntlayerConfig) => Promise<{
+export declare const cleanRemovedContentDeclaration: (filePath: string, keysToKeep: string[], configuration: IntlayerConfig) => Promise<{
   changedDictionariesLocalIds: string[];
   excludeKeys: string[];
   hasRebuilt: boolean;
 }>;
 //#endregion
-export { cleanRemovedContentDeclaration };
 //# sourceMappingURL=cleanRemovedContentDeclaration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cleanRemovedContentDeclaration.d.ts","names":[],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"mappings":";;cAea,iCAA8B,kBACzB,sBACI,eACL,mBACd;EACD;EACA;EACA"}
+{"version":3,"file":"cleanRemovedContentDeclaration.d.ts","names":[],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"mappings":";;qBAea,iCAA8B,kBACzB,sBACI,eACL,mBACd;EACD;EACA;EACA"}

package/dist/types/createDictionaryEntryPoint/createDictionaryEntryPoint.d.ts

@@ -1,12 +1,11 @@
 //#region src/createDictionaryEntryPoint/createDictionaryEntryPoint.d.ts
-type CreateDictionaryEntryPointOptions = {
+export type CreateDictionaryEntryPointOptions = {
   formats?: ('cjs' | 'esm')[];
   excludeKeys?: string[];
 };
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const createDictionaryEntryPoint: (configuration?: import("@intlayer/types").IntlayerConfig, options?: CreateDictionaryEntryPointOptions) => Promise<void>;
+export declare const createDictionaryEntryPoint: (configuration?: import("@intlayer/types").IntlayerConfig, options?: CreateDictionaryEntryPointOptions) => Promise<void>;
 //#endregion
-export { CreateDictionaryEntryPointOptions, createDictionaryEntryPoint };
 //# sourceMappingURL=createDictionaryEntryPoint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createDictionaryEntryPoint.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"mappings":";KAuCY;EACV;EACA;;;;;cAMW,6BAA0B,0CAAA,gBAAA,UAE5B,sCAAiC"}
+{"version":3,"file":"createDictionaryEntryPoint.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"mappings":";YAuCY;EACV;EACA;;;;;qBAMW,6BAA0B,0CAAA,gBAAA,UAE5B,sCAAiC"}

package/dist/types/createDictionaryEntryPoint/generateDictionaryListContent.d.ts

@@ -2,7 +2,6 @@
 /**
  * This function generates the content of the dictionary list file
  */
-declare const generateDictionaryListContent: (dictionaries: string[], functionName: string, importType: 'json' | 'javascript', format?: 'cjs' | 'esm', configuration?: import("@intlayer/types").IntlayerConfig) => string;
+export declare const generateDictionaryListContent: (dictionaries: string[], functionName: string, importType: 'json' | 'javascript', format?: 'cjs' | 'esm', configuration?: import("@intlayer/types").IntlayerConfig) => string;
 //#endregion
-export { generateDictionaryListContent };
 //# sourceMappingURL=generateDictionaryListContent.d.ts.map

package/dist/types/createDictionaryEntryPoint/generateDictionaryListContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateDictionaryListContent.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"mappings":";;;;cAQa,gCAA6B,wBAClB,sBACF,mCACa,wBACZ,0CAAA"}
+{"version":3,"file":"generateDictionaryListContent.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"mappings":";;;;qBAQa,gCAA6B,wBAClB,sBACF,mCACa,wBACZ,0CAAA"}

package/dist/types/createDictionaryEntryPoint/getBuiltDictionariesPath.d.ts

@@ -3,7 +3,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const getBuiltDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
+export declare const getBuiltDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
 //#endregion
-export { getBuiltDictionariesPath };
 //# sourceMappingURL=getBuiltDictionariesPath.d.ts.map

package/dist/types/createDictionaryEntryPoint/getBuiltDictionariesPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBuiltDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts"],"mappings":";;;;;cAUa,2BAAwB,eACpB,gBAAc,2BACR"}
+{"version":3,"file":"getBuiltDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts"],"mappings":";;;;;qBAUa,2BAAwB,eACpB,gBAAc,2BACR"}

package/dist/types/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.d.ts

@@ -3,7 +3,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const getBuiltDynamicDictionariesPath: (configuration: IntlayerConfig, format?: 'cjs' | 'esm', excludeKeys?: string[]) => Promise<string[]>;
+export declare const getBuiltDynamicDictionariesPath: (configuration: IntlayerConfig, format?: 'cjs' | 'esm', excludeKeys?: string[]) => Promise<string[]>;
 //#endregion
-export { getBuiltDynamicDictionariesPath };
 //# sourceMappingURL=getBuiltDynamicDictionariesPath.d.ts.map

package/dist/types/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBuiltDynamicDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts"],"mappings":";;;;;cAUa,kCAA+B,eAC3B,gBAAc,wBACR,2BACA"}
+{"version":3,"file":"getBuiltDynamicDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts"],"mappings":";;;;;qBAUa,kCAA+B,eAC3B,gBAAc,wBACR,2BACA"}

package/dist/types/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.d.ts

@@ -3,7 +3,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const getBuiltFetchDictionariesPath: (configuration: IntlayerConfig, format?: 'cjs' | 'esm', excludeKeys?: string[]) => Promise<string[]>;
+export declare const getBuiltFetchDictionariesPath: (configuration: IntlayerConfig, format?: 'cjs' | 'esm', excludeKeys?: string[]) => Promise<string[]>;
 //#endregion
-export { getBuiltFetchDictionariesPath };
 //# sourceMappingURL=getBuiltFetchDictionariesPath.d.ts.map

package/dist/types/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBuiltFetchDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts"],"mappings":";;;;;cAUa,gCAA6B,eACzB,gBAAc,wBACR,2BACA"}
+{"version":3,"file":"getBuiltFetchDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts"],"mappings":";;;;;qBAUa,gCAA6B,eACzB,gBAAc,wBACR,2BACA"}

package/dist/types/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.d.ts

@@ -3,7 +3,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const getBuiltRemoteDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
+export declare const getBuiltRemoteDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
 //#endregion
-export { getBuiltRemoteDictionariesPath };
 //# sourceMappingURL=getBuiltRemoteDictionariesPath.d.ts.map

package/dist/types/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBuiltRemoteDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.ts"],"mappings":";;;;;cAUa,iCAA8B,eAC1B,gBAAc,2BACR"}
+{"version":3,"file":"getBuiltRemoteDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.ts"],"mappings":";;;;;qBAUa,iCAA8B,eAC1B,gBAAc,2BACR"}

package/dist/types/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.d.ts

@@ -3,7 +3,6 @@ import { IntlayerConfig } from "@intlayer/types/config";
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const getBuiltUnmergedDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
+export declare const getBuiltUnmergedDictionariesPath: (configuration: IntlayerConfig, excludeKeys?: string[]) => Promise<string[]>;
 //#endregion
-export { getBuiltUnmergedDictionariesPath };
 //# sourceMappingURL=getBuiltUnmergedDictionariesPath.d.ts.map

package/dist/types/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBuiltUnmergedDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.ts"],"mappings":";;;;;cAUa,mCAAgC,eAC5B,gBAAc,2BACR"}
+{"version":3,"file":"getBuiltUnmergedDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.ts"],"mappings":";;;;;qBAUa,mCAAgC,eAC5B,gBAAc,2BACR"}

package/dist/types/createType/createModuleAugmentation.d.ts

@@ -1,6 +1,6 @@
 import { IntlayerConfig, RoutingConfig } from "@intlayer/types/config";
 //#region src/createType/createModuleAugmentation.d.ts
-declare const getTypeName: (key: string) => string;
+export declare const getTypeName: (key: string) => string;
 /**
  * Serializes the `url` rewrite rules as a type literal, so `getLocalizedPath`
  * and `getLocalizedUrl` can resolve a canonical path to its localized literal at
@@ -10,7 +10,7 @@ declare const getTypeName: (key: string) => string;
  * Rules are emitted in their normalized form (`:param`, no locale prefix), which
  * is exactly what the runtime matches against.
  */
-declare const formatRewriteRules: (rewrite: RoutingConfig['rewrite']) => string;
+export declare const formatRewriteRules: (rewrite: RoutingConfig['rewrite']) => string;
 /**
  * Serializes the `routing.domains` map as a type literal, so `getLocalizedUrl`
  * and `getLocalizedPath` can resolve the origin of a locale — and the
@@ -25,9 +25,8 @@ declare const formatRewriteRules: (rewrite: RoutingConfig['rewrite']) => string;
  *   ({@link isLocaleExclusiveOnDomain}), in which case the domain identifies the
  *   locale and no path prefix is emitted.
  */
-declare const formatDomains: (domains: RoutingConfig['domains']) => string;
+export declare const formatDomains: (domains: RoutingConfig['domains']) => string;
 /** Generate the index file merging all the types */
-declare const createModuleAugmentation: (configuration: IntlayerConfig) => Promise<void>;
+export declare const createModuleAugmentation: (configuration: IntlayerConfig) => Promise<void>;
 //#endregion
-export { createModuleAugmentation, formatDomains, formatRewriteRules, getTypeName };
 //# sourceMappingURL=createModuleAugmentation.d.ts.map

package/dist/types/createType/createModuleAugmentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createModuleAugmentation.d.ts","names":[],"sources":["../../../src/createType/createModuleAugmentation.ts"],"mappings":";;cAca,cAAW;;;;;;;;;;cAgBX,qBAAkB,SACpB;;;;;;;;;;;;;;;cAkCE,gBAAa,SAAa;;cAuM1B,2BAAwB,eACpB,mBAAc"}
+{"version":3,"file":"createModuleAugmentation.d.ts","names":[],"sources":["../../../src/createType/createModuleAugmentation.ts"],"mappings":";;qBAca,cAAW;;;;;;;;;;qBAgBX,qBAAkB,SACpB;;;;;;;;;;;;;;;qBAkCE,gBAAa,SAAa;;qBAuM1B,2BAAwB,eACpB,mBAAc"}

package/dist/types/createType/createType.d.ts

@@ -1,11 +1,10 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 //#region src/createType/createType.d.ts
-declare const generateTypeScriptType: (dictionary: Dictionary | QualifiedDictionaryGroup) => string;
+export declare const generateTypeScriptType: (dictionary: Dictionary | QualifiedDictionaryGroup) => string;
 /**
  * This function generates a TypeScript type definition from a JSON object
  */
-declare const createTypes: (dictionaries: (Dictionary | QualifiedDictionaryGroup)[], configuration: IntlayerConfig) => Promise<string[]>;
+export declare const createTypes: (dictionaries: (Dictionary | QualifiedDictionaryGroup)[], configuration: IntlayerConfig) => Promise<string[]>;
 //#endregion
-export { createTypes, generateTypeScriptType };
 //# sourceMappingURL=createType.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createType.d.ts","names":[],"sources":["../../../src/createType/createType.ts"],"mappings":";;;cAUa,yBAAsB,YACrB,aAAa;;;;cASd,cAAW,eACP,aAAa,6BAA2B,eACxC,mBACd"}
+{"version":3,"file":"createType.d.ts","names":[],"sources":["../../../src/createType/createType.ts"],"mappings":";;;qBAUa,yBAAsB,YACrB,aAAa;;;;qBASd,cAAW,eACP,aAAa,6BAA2B,eACxC,mBACd"}

package/dist/types/detectFormatCommand.d.ts

@@ -1,6 +1,5 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/detectFormatCommand.d.ts
-declare const detectFormatCommand: (configuration: IntlayerConfig, projectRequireProp?: NodeJS.Require) => string;
+export declare const detectFormatCommand: (configuration: IntlayerConfig, projectRequireProp?: NodeJS.Require) => string;
 //#endregion
-export { detectFormatCommand };
 //# sourceMappingURL=detectFormatCommand.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"detectFormatCommand.d.ts","names":[],"sources":["../../src/detectFormatCommand.ts"],"mappings":";;cAKa,sBAAmB,eACf,gBAAc,qBACR,OAAO"}
+{"version":3,"file":"detectFormatCommand.d.ts","names":[],"sources":["../../src/detectFormatCommand.ts"],"mappings":";;qBAKa,sBAAmB,eACf,gBAAc,qBACR,OAAO"}

package/dist/types/docReview/alignBlocks.d.ts

@@ -13,7 +13,6 @@ import { AlignmentPair, FingerprintedBlock } from "./types.js";
  * @param targetBlocks - Blocks of the target (translated) document.
  * @returns The ordered list of alignment pairs, including insertions and deletions.
  */
-declare const alignBaseAndTargetBlocks: (baseBlocks: FingerprintedBlock[], targetBlocks: FingerprintedBlock[]) => AlignmentPair[];
+export declare const alignBaseAndTargetBlocks: (baseBlocks: FingerprintedBlock[], targetBlocks: FingerprintedBlock[]) => AlignmentPair[];
 //#endregion
-export { alignBaseAndTargetBlocks };
 //# sourceMappingURL=alignBlocks.d.ts.map

package/dist/types/docReview/alignBlocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alignBlocks.d.ts","names":[],"sources":["../../../src/docReview/alignBlocks.ts"],"mappings":";;;;;;;;;;;;;;;cAgEa,2BAAwB,YACvB,sBAAoB,cAClB,yBACb"}
+{"version":3,"file":"alignBlocks.d.ts","names":[],"sources":["../../../src/docReview/alignBlocks.ts"],"mappings":";;;;;;;;;;;;;;;qBAgEa,2BAAwB,YACvB,sBAAoB,cAClB,yBACb"}

package/dist/types/docReview/computeSimilarity.d.ts

@@ -7,7 +7,7 @@
  * @param shingleLength - The length of each shingle.
  * @returns The set of unique shingles found in the text.
  */
-declare const generateCharacterShingles: (text: string, shingleLength: number) => Set<string>;
+export declare const generateCharacterShingles: (text: string, shingleLength: number) => Set<string>;
 /**
  * Compute the Jaccard similarity between two strings using character shingles.
  *
@@ -16,7 +16,6 @@ declare const generateCharacterShingles: (text: string, shingleLength: number) =
  * @param shingleLength - The shingle length (defaults to 3).
  * @returns A score between 0 (disjoint) and 1 (identical).
  */
-declare const computeJaccardSimilarity: (a: string, b: string, shingleLength?: number) => number;
+export declare const computeJaccardSimilarity: (a: string, b: string, shingleLength?: number) => number;
 //#endregion
-export { computeJaccardSimilarity, generateCharacterShingles };
 //# sourceMappingURL=computeSimilarity.d.ts.map

package/dist/types/docReview/computeSimilarity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeSimilarity.d.ts","names":[],"sources":["../../../src/docReview/computeSimilarity.ts"],"mappings":";;;;;;;;;cAQa,4BAAyB,cACxB,0BAEX;;;;;;;;;cAuBU,2BAAwB,WAC1B,WACA"}
+{"version":3,"file":"computeSimilarity.d.ts","names":[],"sources":["../../../src/docReview/computeSimilarity.ts"],"mappings":";;;;;;;;;qBAQa,4BAAyB,cACxB,0BAEX;;;;;;;;;qBAuBU,2BAAwB,WAC1B,WACA"}

package/dist/types/docReview/fingerprintBlock.d.ts

@@ -11,7 +11,6 @@ import { FingerprintedBlock, NormalizedBlock } from "./types.js";
  * @param nextBlock - The block immediately after, or `null` at the end.
  * @returns The block enriched with its digests.
  */
-declare const fingerprintBlock: (block: NormalizedBlock, previousBlock: NormalizedBlock | null, nextBlock: NormalizedBlock | null) => FingerprintedBlock;
+export declare const fingerprintBlock: (block: NormalizedBlock, previousBlock: NormalizedBlock | null, nextBlock: NormalizedBlock | null) => FingerprintedBlock;
 //#endregion
-export { fingerprintBlock };
 //# sourceMappingURL=fingerprintBlock.d.ts.map

package/dist/types/docReview/fingerprintBlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fingerprintBlock.d.ts","names":[],"sources":["../../../src/docReview/fingerprintBlock.ts"],"mappings":";;;;;;;;;;;;;cAiBa,mBAAgB,OACpB,iBAAe,eACP,wBAAsB,WAC1B,2BACV"}
+{"version":3,"file":"fingerprintBlock.d.ts","names":[],"sources":["../../../src/docReview/fingerprintBlock.ts"],"mappings":";;;;;;;;;;;;;qBAiBa,mBAAgB,OACpB,iBAAe,eACP,wBAAsB,WAC1B,2BACV"}

package/dist/types/docReview/mapChangedLinesToBlocks.d.ts

@@ -8,7 +8,6 @@ import { Block, LineChange } from "./types.js";
  * @param changedLines - 1-based line numbers that changed in the base document.
  * @returns The set of block indexes touched by at least one changed line.
  */
-declare const mapChangedLinesToBlocks: (blocks: Block[], changedLines: LineChange[]) => Set<number>;
+export declare const mapChangedLinesToBlocks: (blocks: Block[], changedLines: LineChange[]) => Set<number>;
 //#endregion
-export { mapChangedLinesToBlocks };
 //# sourceMappingURL=mapChangedLinesToBlocks.d.ts.map

package/dist/types/docReview/mapChangedLinesToBlocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapChangedLinesToBlocks.d.ts","names":[],"sources":["../../../src/docReview/mapChangedLinesToBlocks.ts"],"mappings":";;;;;;;;;;cAUa,0BAAuB,QAC1B,SAAO,cACD,iBACb"}
+{"version":3,"file":"mapChangedLinesToBlocks.d.ts","names":[],"sources":["../../../src/docReview/mapChangedLinesToBlocks.ts"],"mappings":";;;;;;;;;;qBAUa,0BAAuB,QAC1B,SAAO,cACD,iBACb"}

package/dist/types/docReview/normalizeBlock.d.ts

@@ -11,7 +11,6 @@ import { Block, NormalizedBlock } from "./types.js";
  * @param block - The block to normalize.
  * @returns The block enriched with its normalized texts.
  */
-declare const normalizeBlock: (block: Block) => NormalizedBlock;
+export declare const normalizeBlock: (block: Block) => NormalizedBlock;
 //#endregion
-export { normalizeBlock };
 //# sourceMappingURL=normalizeBlock.d.ts.map

package/dist/types/docReview/normalizeBlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeBlock.d.ts","names":[],"sources":["../../../src/docReview/normalizeBlock.ts"],"mappings":";;;;;;;;;;;;;cAmCa,iBAAc,OAAW,UAAQ"}
+{"version":3,"file":"normalizeBlock.d.ts","names":[],"sources":["../../../src/docReview/normalizeBlock.ts"],"mappings":";;;;;;;;;;;;;qBAmCa,iBAAc,OAAW,UAAQ"}