@intlayer/engine 9.4.3 → 9.5.0

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"}

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

@@ -1,7 +1,7 @@
 import { AlignmentPlan, FingerprintedBlock } from "./types.js";
 import { SegmentToReview, mergeReviewedSegments } from "./rebuildDocument.js";
 //#region src/docReview/pipeline.d.ts
-type BuildAlignmentPlanInput = {
+export type BuildAlignmentPlanInput = {
   /** The base (source) document, used as the translation reference. */
   baseText: string;
   /** The existing target (translated) document, possibly empty. */
@@ -15,7 +15,7 @@ type BuildAlignmentPlanInput = {
    */
   changedLines: number[] | undefined;
 };
-type BuildAlignmentPlanOutput = {
+export type BuildAlignmentPlanOutput = {
   baseBlocks: FingerprintedBlock[];
   targetBlocks: FingerprintedBlock[];
   plan: AlignmentPlan;
@@ -50,7 +50,7 @@ type BuildAlignmentPlanOutput = {
  * @param input - The base/target texts and optional changed lines.
  * @returns The (flattened) blocks, the plan, and the segments that need translation.
  */
-declare const buildAlignmentPlan: ({ baseText, targetText, changedLines }: BuildAlignmentPlanInput) => BuildAlignmentPlanOutput;
+export declare const buildAlignmentPlan: ({ baseText, targetText, changedLines }: BuildAlignmentPlanInput) => BuildAlignmentPlanOutput;
 //#endregion
-export { BuildAlignmentPlanInput, BuildAlignmentPlanOutput, type SegmentToReview, buildAlignmentPlan, mergeReviewedSegments };
+export { type SegmentToReview, mergeReviewedSegments };
 //# sourceMappingURL=pipeline.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","names":[],"sources":["../../../src/docReview/pipeline.ts"],"mappings":";;;KAiBY;;EAEV;;EAEA;;;;;;;;EAQA;;KAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;EACN,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DP,uBAAkB,UAAA,YAAA,gBAI5B,4BAA0B"}
+{"version":3,"file":"pipeline.d.ts","names":[],"sources":["../../../src/docReview/pipeline.ts"],"mappings":";;;YAiBY;;EAEV;;EAEA;;;;;;;;EAQA;;YAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;EACN,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4DP,uBAAkB,UAAA,YAAA,gBAI5B,4BAA0B"}

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

@@ -11,7 +11,6 @@ import { AlignmentPair, AlignmentPlan } from "./types.js";
  * @param changedBaseBlockIndexes - Indexes of base blocks reported as changed.
  * @returns The plan of actions to merge the documents.
  */
-declare const planAlignmentActions: (alignment: AlignmentPair[], changedBaseBlockIndexes: Set<number>) => AlignmentPlan;
+export declare const planAlignmentActions: (alignment: AlignmentPair[], changedBaseBlockIndexes: Set<number>) => AlignmentPlan;
 //#endregion
-export { planAlignmentActions };
 //# sourceMappingURL=planActions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"planActions.d.ts","names":[],"sources":["../../../src/docReview/planActions.ts"],"mappings":";;;;;;;;;;;;;cAaa,uBAAoB,WACpB,iBAAe,yBACD,gBACxB"}
+{"version":3,"file":"planActions.d.ts","names":[],"sources":["../../../src/docReview/planActions.ts"],"mappings":";;;;;;;;;;;;;qBAaa,uBAAoB,WACpB,iBAAe,yBACD,gBACxB"}

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

@@ -4,7 +4,7 @@ import { AlignmentPlan, FingerprintedBlock } from "./types.js";
  * A block that needs to be translated or re-translated by an external consumer
  * (an AI client, a human, or an agent).
  */
-type SegmentToReview = {
+export type SegmentToReview = {
   /** The base block to translate. */
   baseBlock: FingerprintedBlock;
   /** Existing target translation, or `null` when the block is new. */
@@ -12,12 +12,12 @@ type SegmentToReview = {
   /** Index of the originating action within {@link AlignmentPlan.actions}. */
   actionIndex: number;
 };
-type RebuildInput = {
+export type RebuildInput = {
   baseBlocks: FingerprintedBlock[];
   targetBlocks: FingerprintedBlock[];
   plan: AlignmentPlan;
 };
-type RebuildResult = {
+export type RebuildResult = {
   segmentsToReview: SegmentToReview[];
 };
 /**
@@ -28,7 +28,7 @@ type RebuildResult = {
  * @param input - The base/target blocks and the alignment plan.
  * @returns The list of segments that require translation.
  */
-declare const identifySegmentsToReview: ({ baseBlocks, targetBlocks, plan }: RebuildInput) => RebuildResult;
+export declare const identifySegmentsToReview: ({ baseBlocks, targetBlocks, plan }: RebuildInput) => RebuildResult;
 /**
  * Merge reviewed translations back into the final document following the
  * alignment plan, reusing untouched target blocks as-is.
@@ -38,7 +38,6 @@ declare const identifySegmentsToReview: ({ baseBlocks, targetBlocks, plan }: Reb
  * @param reviewedSegments - Map of action index to its reviewed translation.
  * @returns The rebuilt target document.
  */
-declare const mergeReviewedSegments: (plan: AlignmentPlan, targetBlocks: FingerprintedBlock[], reviewedSegments: Map<number, string>) => string;
+export declare const mergeReviewedSegments: (plan: AlignmentPlan, targetBlocks: FingerprintedBlock[], reviewedSegments: Map<number, string>) => string;
 //#endregion
-export { RebuildInput, RebuildResult, SegmentToReview, identifySegmentsToReview, mergeReviewedSegments };
 //# sourceMappingURL=rebuildDocument.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;KAMY;;EAEV,WAAW;;EAEX;;EAEA;;KAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;KAGI;EACV,kBAAkB;;;;;;;;;;cAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;cAmDL,wBAAqB,MAC1B,eAAa,cACL,sBAAoB,kBAChB"}
+{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;;YAMY;;EAEV,WAAW;;EAEX;;EAEA;;YAGU;EACV,YAAY;EACZ,cAAc;EACd,MAAM;;YAGI;EACV,kBAAkB;;;;;;;;;;qBAWP,6BAAwB,YAAA,cAAA,QAIlC,iBAAe;;;;;;;;;;qBAmDL,wBAAqB,MAC1B,eAAa,cACL,sBAAoB,kBAChB"}

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

@@ -7,9 +7,9 @@
  * - `insert_new`: the base block has no translation yet and must be added.
  * - `delete`: the target block no longer exists in the base and should be removed.
  */
-type ReviewBlockAction = 'review' | 'insert_new' | 'delete';
+export type ReviewBlockAction = 'review' | 'insert_new' | 'delete';
 /** A 1-based, inclusive line range within a document. */
-type LineRange = {
+export type LineRange = {
   start: number;
   end: number;
 };
@@ -20,7 +20,7 @@ type LineRange = {
  * act on: it carries the base content to translate, the existing translation to
  * update, and where each lives so the change can be located in the file.
  */
-type ReviewReportBlock = {
+export type ReviewReportBlock = {
   /** What should happen to this block. */
   action: ReviewBlockAction;
   /** Line range of the block in the base document (omitted for pure deletions). */
@@ -32,7 +32,7 @@ type ReviewReportBlock = {
   /** Existing translation of the block (omitted for new insertions). */
   targetContent?: string;
 };
-type ReviewReportSummary = {
+export type ReviewReportSummary = {
   /** Number of blocks reused as-is (unchanged translation). */
   reuse: number;
   /** Number of blocks whose translation must be updated. */
@@ -42,13 +42,13 @@ type ReviewReportSummary = {
   /** Number of stale target blocks to delete. */
   delete: number;
 };
-type ReviewReport = {
+export type ReviewReport = {
   /** Only the blocks that diverge (review, insert_new, delete). */
   blocks: ReviewReportBlock[];
   /** Counts per action over the whole document, including reused blocks. */
   summary: ReviewReportSummary;
 };
-type BuildReviewReportInput = {
+export type BuildReviewReportInput = {
   /** The base (source) document, used as the translation reference. */
   baseText: string;
   /** The existing target (translated) document, possibly empty. */
@@ -74,7 +74,7 @@ type BuildReviewReportInput = {
  * @param input - The base/target texts and optional changed lines.
  * @returns The divergent blocks and a per-action summary.
  */
-declare const buildReviewReport: ({ baseText, targetText, changedLines }: BuildReviewReportInput) => ReviewReport;
+export declare const buildReviewReport: ({ baseText, targetText, changedLines }: BuildReviewReportInput) => ReviewReport;
 /**
  * Render a {@link ReviewReport} as a human and agent readable log.
  *
@@ -85,10 +85,9 @@ declare const buildReviewReport: ({ baseText, targetText, changedLines }: BuildR
  * @param options - Optional labels for the base and target locales.
  * @returns A multi-line string describing every block that needs attention.
  */
-declare const formatReviewReport: (report: ReviewReport, options?: {
+export declare const formatReviewReport: (report: ReviewReport, options?: {
   baseLabel?: string;
   targetLabel?: string;
 }) => string;
 //#endregion
-export { BuildReviewReportInput, LineRange, ReviewBlockAction, ReviewReport, ReviewReportBlock, ReviewReportSummary, buildReviewReport, formatReviewReport };
 //# sourceMappingURL=reviewReport.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reviewReport.d.ts","names":[],"sources":["../../../src/docReview/reviewReport.ts"],"mappings":";;;;;;;;;KAYY;;KAGA;EACV;EACA;;;;;;;;;KAUU;;EAEV,QAAQ;;EAER,gBAAgB;;EAEhB,kBAAkB;;EAElB;;EAEA;;KAGU;;EAEV;;EAEA;;EAEA;;EAEA;;KAGU;;EAEV,QAAQ;;EAER,SAAS;;KAGC;;EAEV;;EAEA;;;;;;;;;EASA;;;;;;;;;;;;;cAcW,sBAAiB,UAAA,YAAA,gBAI3B,2BAAyB;;;;;;;;;;;cAgJf,qBAAkB,QACrB,cAAY;EACR;EAAoB"}
+{"version":3,"file":"reviewReport.d.ts","names":[],"sources":["../../../src/docReview/reviewReport.ts"],"mappings":";;;;;;;;;YAYY;;YAGA;EACV;EACA;;;;;;;;;YAUU;;EAEV,QAAQ;;EAER,gBAAgB;;EAEhB,kBAAkB;;EAElB;;EAEA;;YAGU;;EAEV;;EAEA;;EAEA;;EAEA;;YAGU;;EAEV,QAAQ;;EAER,SAAS;;YAGC;;EAEV;;EAEA;;;;;;;;;EASA;;;;;;;;;;;;;qBAcW,sBAAiB,UAAA,YAAA,gBAI3B,2BAAyB;;;;;;;;;;;qBAgJf,qBAAkB,QACrB,cAAY;EACR;EAAoB"}

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

@@ -14,7 +14,7 @@ import { Block } from "./types.js";
  * @param text - The full markdown document.
  * @returns The ordered list of blocks with their 1-based line ranges.
  */
-declare const segmentDocument: (text: string) => Block[];
+export declare const segmentDocument: (text: string) => Block[];
 /**
  * Split a markdown document into coarse, heading-anchored sections.
  *
@@ -33,7 +33,6 @@ declare const segmentDocument: (text: string) => Block[];
  * @param text - The full markdown document.
  * @returns The ordered list of sections with their 1-based line ranges.
  */
-declare const segmentSections: (text: string) => Block[];
+export declare const segmentSections: (text: string) => Block[];
 //#endregion
-export { segmentDocument, segmentSections };
 //# sourceMappingURL=segmentDocument.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;;;;;;;;;;;;cAoDa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;cAuIlC,kBAAe,iBAAmB"}
+{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;;;;;;;;;;;;qBAoDa,kBAAe,iBAAmB;;;;;;;;;;;;;;;;;;;qBAuIlC,kBAAe,iBAAmB"}

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

@@ -4,11 +4,11 @@
  *
  * Used to weight the alignment between a base document and its translation.
  */
-type BlockType = 'heading' | 'paragraph' | 'list_item' | 'code_block' | 'blockquote' | 'table' | 'horizontal_rule' | 'html' | 'unknown';
+export type BlockType = 'heading' | 'paragraph' | 'list_item' | 'code_block' | 'blockquote' | 'table' | 'horizontal_rule' | 'html' | 'unknown';
 /**
  * A raw markdown block extracted from a document, with its line range.
  */
-type Block = {
+export type Block = {
   type: BlockType;
   content: string;
   /**
@@ -28,7 +28,7 @@ type Block = {
 /**
  * A {@link Block} enriched with normalized text used for similarity matching.
  */
-type NormalizedBlock = Block & {
+export type NormalizedBlock = Block & {
   /** Lower-cased, markdown-stripped text used for semantic comparison. */
   semanticText: string;
   /** Non-letter characters (digits, punctuation, symbols) kept as a structural anchor. */
@@ -37,7 +37,7 @@ type NormalizedBlock = Block & {
 /**
  * A {@link NormalizedBlock} enriched with content digests used to detect reuse.
  */
-type FingerprintedBlock = NormalizedBlock & {
+export type FingerprintedBlock = NormalizedBlock & {
   semanticDigest: string;
   anchorDigest: string;
   compositeKey: string;
@@ -49,7 +49,7 @@ type FingerprintedBlock = NormalizedBlock & {
  * `baseIndex === -1` means the target block has no base counterpart (deletion).
  * `targetIndex === null` means the base block has no target counterpart (insertion).
  */
-type AlignmentPair = {
+export type AlignmentPair = {
   baseIndex: number;
   targetIndex: number | null;
   similarityScore: number;
@@ -57,7 +57,7 @@ type AlignmentPair = {
 /**
  * An action the merge step should take for a given aligned pair of blocks.
  */
-type PlannedAction = {
+export type PlannedAction = {
   kind: 'reuse';
   baseIndex: number;
   targetIndex: number;
@@ -72,17 +72,16 @@ type PlannedAction = {
   kind: 'delete';
   targetIndex: number;
 };
-type AlignmentPlan = {
+export type AlignmentPlan = {
   actions: PlannedAction[];
 };
 /** A 1-based line number that changed in the base document. */
-type LineChange = number;
-type SimilarityOptions = {
+export type LineChange = number;
+export type SimilarityOptions = {
   /** Minimum anchor similarity to consider two blocks identical (for example 0.90). */
   minimumMatchForReuse: number;
   /** Minimum anchor similarity to consider two blocks near-duplicates (for example 0.80). */
   minimumMatchForNearDuplicate: number;
 };
 //#endregion
-export { AlignmentPair, AlignmentPlan, Block, BlockType, FingerprintedBlock, LineChange, NormalizedBlock, PlannedAction, SimilarityOptions };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/docReview/types.ts"],"mappings":";;;;;;KAKY;;;;KAcA;EACV,MAAM;EACN;;;;;;;;;EASA;;EAEA;;EAEA;;;;;KAMU,kBAAkB;;EAE5B;;EAEA;;;;;KAMU,qBAAqB;EAC/B;EACA;EACA;EACA;;;;;;;;KASU;EACV;EACA;EACA;;;;;KAMU;EACN;EAAe;EAAmB;;EAClC;EAAgB;EAAmB;;EACnC;EAAoB;;EACpB;EAAgB;;KAEV;EACV,SAAS;;;KAIC;KAEA;;EAEV;;EAEA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/docReview/types.ts"],"mappings":";;;;;;YAKY;;;;YAcA;EACV,MAAM;EACN;;;;;;;;;EASA;;EAEA;;EAEA;;;;;YAMU,kBAAkB;;EAE5B;;EAEA;;;;;YAMU,qBAAqB;EAC/B;EACA;EACA;EACA;;;;;;;;YASU;EACV;EACA;EACA;;;;;YAMU;EACN;EAAe;EAAmB;;EAClC;EAAgB;EAAmB;;EACnC;EAAoB;;EACpB;EAAgB;;YAEV;EACV,SAAS;;;YAIC;YAEA;;EAEV;;EAEA"}

package/dist/types/fetchDistantDictionaries.d.ts

@@ -36,7 +36,6 @@ type FetchDistantDictionariesOptions = {
  * as soon as its request settles, so no batch waits for the whole wave.
  * Failing requests are retried before their keys are reported as errors.
  */
-declare const fetchDistantDictionaries: (options: FetchDistantDictionariesOptions, onStatusUpdate?: (status: DictionariesStatus[]) => void) => Promise<DictionaryAPI[]>;
+export declare const fetchDistantDictionaries: (options: FetchDistantDictionariesOptions, onStatusUpdate?: (status: DictionariesStatus[]) => void) => Promise<DictionaryAPI[]>;
 //#endregion
-export { fetchDistantDictionaries };
 //# sourceMappingURL=fetchDistantDictionaries.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KAqDK;EACH;EACA;EACA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;cAYW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}
+{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KAqDK;EACH;EACA;EACA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;qBAYW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}

package/dist/types/filterInvalidDictionaries.d.ts

@@ -4,8 +4,7 @@ import { Dictionary } from "@intlayer/types/dictionary";
 type IsInvalidDictionaryOptions = {
   checkSchema: boolean;
 };
-declare const isInvalidDictionary: (dictionary: Dictionary | undefined, configuration?: IntlayerConfig, options?: IsInvalidDictionaryOptions) => boolean;
-declare const filterInvalidDictionaries: (dictionaries: (Dictionary | undefined)[] | undefined, configuration: IntlayerConfig, options?: IsInvalidDictionaryOptions) => Dictionary[];
+export declare const isInvalidDictionary: (dictionary: Dictionary | undefined, configuration?: IntlayerConfig, options?: IsInvalidDictionaryOptions) => boolean;
+export declare const filterInvalidDictionaries: (dictionaries: (Dictionary | undefined)[] | undefined, configuration: IntlayerConfig, options?: IsInvalidDictionaryOptions) => Dictionary[];
 //#endregion
-export { filterInvalidDictionaries, isInvalidDictionary };
 //# sourceMappingURL=filterInvalidDictionaries.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"filterInvalidDictionaries.d.ts","names":[],"sources":["../../src/filterInvalidDictionaries.ts"],"mappings":";;;KAaK;EAA+B;;cAEvB,sBAAmB,YAClB,wBAAsB,gBAClB,gBAAc,UACpB;cA2GC,4BAAyB,eACrB,uCAAqC,eACrC,gBAAc,UACnB,+BACT"}
+{"version":3,"file":"filterInvalidDictionaries.d.ts","names":[],"sources":["../../src/filterInvalidDictionaries.ts"],"mappings":";;;KAaK;EAA+B;;qBAEvB,sBAAmB,YAClB,wBAAsB,gBAClB,gBAAc,UACpB;qBA2GC,4BAAyB,eACrB,uCAAqC,eACrC,gBAAc,UACnB,+BACT"}

package/dist/types/formatDictionary.d.ts

@@ -1,9 +1,8 @@
-import { LocalesValues } from "./intlayer/dist/types/index.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/formatDictionary.d.ts
-declare const formatDictionary: (dictionary: Dictionary) => Dictionary;
-declare const formatDictionaries: (dictionaries: Dictionary[]) => Promise<Dictionary[]>;
-declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionary['format']) => {
+export declare const formatDictionary: (dictionary: Dictionary) => Dictionary;
+export declare const formatDictionaries: (dictionaries: Dictionary[]) => Promise<Dictionary[]>;
+export declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionary['format']) => {
   $schema?: "https://intlayer.org/schema.json";
   id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
@@ -19,7 +18,7 @@ declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionar
   tags?: string[];
   item?: number;
   variant?: import("@intlayer/types").DictionaryVariantValue | import("@intlayer/types").DictionaryVariantValue[];
-  locale?: LocalesValues;
+  locale?: import("@intlayer/types").LocalesValues;
   contentAutoTransformation?: import("@intlayer/types").ContentAutoTransformation;
   fill?: import("@intlayer/types").Fill;
   filled?: true;
@@ -30,7 +29,7 @@ declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionar
   format: string;
   content: import("@intlayer/core/messageFormat").JsonValue;
 } | Dictionary;
-declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dictionary['format']) => ({
+export declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dictionary['format']) => ({
   $schema?: "https://intlayer.org/schema.json";
   id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
@@ -46,7 +45,7 @@ declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dic
   tags?: string[];
   item?: number;
   variant?: import("@intlayer/types").DictionaryVariantValue | import("@intlayer/types").DictionaryVariantValue[];
-  locale?: LocalesValues;
+  locale?: import("@intlayer/types").LocalesValues;
   contentAutoTransformation?: import("@intlayer/types").ContentAutoTransformation;
   fill?: import("@intlayer/types").Fill;
   filled?: true;
@@ -58,5 +57,4 @@ declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dic
   content: import("@intlayer/core/messageFormat").JsonValue;
 } | Dictionary)[];
 //#endregion
-export { formatDictionaries, formatDictionariesOutput, formatDictionary, formatDictionaryOutput };
 //# sourceMappingURL=formatDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;;cAYa,mBAAgB,YAAgB,eAAa;cAoC7C,qBAAkB,cACf,iBACb,QAAQ;cAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;cAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}
+{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;qBAYa,mBAAgB,YAAgB,eAAa;qBAoC7C,qBAAkB,cACf,iBACb,QAAQ;qBAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;qBAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}