@intlayer/engine 9.0.0-canary.12

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

@@ -0,0 +1,77 @@
+import { PlainMergedDictionaryOutput } from "./writeMergedDictionary.js";
+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 = {
+  dictionaryPath: string;
+  dictionary: Dictionary;
+};
+type LocalizedDictionaryResult = Partial<Record<Locale, DictionaryResult>>;
+type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
+/**
+ * Generates the content of a dictionary entry point file.
+ */
+declare const generateDictionaryEntryPoint: (key: string, locales: string[], format?: "cjs" | "esm") => string;
+/**
+ * One entry of a qualified loader map.
+ *
+ * `treeSegments` is where the entry lives in the loader tree (its composite id
+ * segments); `chunkSegments` is the chunk path it loads. They differ when the
+ * entry aliases another entry with identical content (e.g. array-variant
+ * 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 = {
+  treeSegments: string[];
+  chunkSegments: string[];
+};
+/**
+ * Generates the entry point of a qualified dictionary (collection / variant,
+ * possibly combined). Under each locale the loader map nests one
+ * level per declared dimension (canonical order) and carries a marker listing
+ * those dimensions so the runtime can walk the tree.
+ *
+ * One static `import()` is emitted per leaf `(locale, …segments)` chunk, which
+ * keeps the output compatible with bundlers that reject template-literal
+ * 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;
+/**
+ * Write the localized dictionaries to the dictionariesDir
+ * @param mergedDictionaries - The merged dictionaries
+ * @param configuration - The configuration
+ * @returns The final dictionaries
+ *
+ * @example
+ * ```ts
+ * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+ * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+ * console.log(finalDictionaries);
+ *
+ * // .intlayer/dynamic_dictionary/dictionaries/en_home.json
+ * // .intlayer/dynamic_dictionary/dictionaries/fr_home.json
+ * ```
+ */
+declare const writeDynamicDictionary: (mergedDictionaries: PlainMergedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+type QualifiedMergedDictionaryResult = {
+  dictionaryPath: string;
+  dictionary: QualifiedDictionaryGroup;
+};
+type QualifiedMergedDictionaryOutput = Record<string, QualifiedMergedDictionaryResult>;
+/**
+ * Writes the dynamic chunks and entry points of qualified dictionaries
+ * (collections, variants — possibly combined) in
+ * `importMode: 'dynamic'`.
+ *
+ * Each entry is reduced to one per-locale chunk written to a path nested by
+ * dimension — `json/{key}/{seg1}/{seg2}/{locale}.json` — and a single
+ * `{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>;
+//#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

@@ -0,0 +1 @@
+{"version":3,"file":"writeDynamicDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeDynamicDictionary.ts"],"mappings":";;;;;;KAuBY,gBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,yBAAA,GAA4B,OAAA,CACtC,MAAA,CAAO,MAAA,EAAQ,gBAAA;AAAA,KAGL,yBAAA,GAA4B,MAAA,SAEtC,yBAAA;;;;cAgBW,4BAAA,GACX,GAAA,UACA,OAAA,YACA,MAAA;;AAzBF;;;;;;;;KAkEY,sBAAA;EACV,YAAA;EACA,aAAA;AAAA;;;;AAhEF;;;;;AAkBA;;;cA4Ha,qCAAA,GACX,GAAA,UACA,cAAA,EAAgB,uBAAA,IAChB,OAAA,EAAS,sBAAA,IACT,OAAA,YACA,MAAA;;;;;;AArFF;;;;;AAgFA;;;;;;cA6Ca,sBAAA,GACX,kBAAA,EAAoB,2BAAA,EACpB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA;AAAA,KAyEC,+BAAA;EACV,cAAA;EACA,UAAA,EAAY,wBAAA;AAAA;AAAA,KAGF,+BAAA,GAAkC,MAAA,SAE5C,+BAAA;;AApFF;;;;;;;;;cAiGa,iCAAA,GACX,qBAAA,EAAuB,+BAAA,EACvB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA"}

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

@@ -0,0 +1,25 @@
+import { LocalizedDictionaryOutput } from "./writeDynamicDictionary.js";
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/buildIntlayerDictionary/writeFetchDictionary.d.ts
+declare const generateDictionaryEntryPoint: (key: string, locales: string[], relativePrefix: string, format?: "cjs" | "esm") => string;
+/**
+ * Write the localized dictionaries to the dictionariesDir
+ * @param mergedDictionaries - The merged dictionaries
+ * @param configuration - The configuration
+ * @returns The final dictionaries
+ *
+ * @example
+ * ```ts
+ * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+ * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+ * console.log(finalDictionaries);
+ *
+ * // .intlayer/fetch_dictionary/home.mjs
+ * // .intlayer/fetch_dictionary/home.cjs
+ * ```
+ */
+declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration: IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+//#endregion
+export { generateDictionaryEntryPoint, writeFetchDictionary };
+//# sourceMappingURL=writeFetchDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeFetchDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeFetchDictionary.ts"],"mappings":";;;;cAUa,4BAAA,GACX,GAAA,UACA,OAAA,YACA,cAAA,UACA,MAAA;;AAJF;;;;;;;;;;AAsDA;;;;;cAAa,oBAAA,GACX,mBAAA,EAAqB,yBAAA,EACrB,aAAA,EAAe,cAAA,EACf,OAAA,yBACC,OAAA,CAAQ,yBAAA"}

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

@@ -0,0 +1,40 @@
+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 = {
+  dictionaryPath: string;
+  dictionary: Dictionary | QualifiedDictionaryGroup;
+};
+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 = {
+  dictionaryPath: string;
+  dictionary: Dictionary;
+};
+type PlainMergedDictionaryOutput = Record<string, PlainMergedDictionaryResult>;
+/**
+ * Write the merged dictionaries to the dictionariesDir
+ * @param groupedDictionaries - The grouped dictionaries
+ * @param configuration - The configuration
+ * @returns The merged dictionaries
+ *
+ * @example
+ * ```ts
+ * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+ * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+ * console.log(finalDictionaries);
+ *
+ * // .intlayer/dictionary/home.json
+ * // { key: 'home', content: { ... } },
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"writeMergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeMergedDictionary.ts"],"mappings":";;;;;KAiBY,sBAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA,GAAa,wBAAA;AAAA;AAAA,KAGf,sBAAA,GAAyB,MAAA,SAAe,sBAAA;;;;;;KAOxC,2BAAA;EACV,cAAA;EACA,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,2BAAA,GAA8B,MAAA,SAExC,2BAAA;;;AAPF;;;;;;;;;AAKA;;;;;cAqBa,uBAAA,GACX,mBAAA,EAAqB,wBAAA,EACrB,aAAA,EAAe,cAAA,KACd,OAAA,CAAQ,sBAAA"}

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

@@ -0,0 +1,29 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/buildIntlayerDictionary/writeRemoteDictionary.d.ts
+type RemoteDictionaryResult = {
+  dictionaryPath: string;
+  dictionaries: Dictionary[];
+};
+type RemoteDictionaryOutput = Record<string, RemoteDictionaryResult>;
+/**
+ * Write the localized dictionaries to the dictionariesDir
+ * @param mergedDictionaries - The merged dictionaries
+ * @param configuration - The configuration
+ * @returns The final dictionaries
+ *
+ * @example
+ * ```ts
+ * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+ * const finalDictionaries = await writeFinalDictionaries(unmergedDictionaries);
+ * console.log(finalDictionaries);
+ *
+ * // .intlayer/fetch_dictionaries/home.json
+ * // { key: 'home', content: { ... } },
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"writeRemoteDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeRemoteDictionary.ts"],"mappings":";;;;KAeY,sBAAA;EACV,cAAA;EACA,YAAA,EAAc,UAAA;AAAA;AAAA,KAGJ,sBAAA,GAAyB,MAAA,SAAe,sBAAA;;;;;;;AAApD;;;;;AAkBA;;;;;cAAa,qBAAA,GACX,kBAAA,EAAoB,UAAA,IACpB,aAAA,EAAe,cAAA,KACd,OAAA,CAAQ,sBAAA"}

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

@@ -0,0 +1,34 @@
+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 = {
+  dictionaryPath: string;
+  dictionaries: Dictionary[];
+};
+type UnmergedDictionaryOutput = Record<DictionaryKey, UnmergedDictionaryResult>;
+/**
+ * Write the unmerged dictionaries to the unmergedDictionariesDir
+ * @param dictionaries - The dictionaries to write
+ * @param configuration - The configuration
+ * @returns The grouped dictionaries
+ *
+ * @example
+ * ```ts
+ * const unmergedDictionaries = await writeUnmergedDictionaries(dictionaries);
+ * console.log(unmergedDictionaries);
+ *
+ * // .intlayer/unmerged_dictionaries/home.json
+ * // {
+ * //   [
+ * //     { key: 'home', content: { ... } },
+ * //     { key: 'home', content: { ... } },
+ * //   ],
+ * // }
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"writeUnmergedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeUnmergedDictionary.ts"],"mappings":";;;;cAWa,sBAAA,GACX,YAAA,EAAc,UAAA,OACb,MAAA,SAAe,UAAA;AAAA,KAaN,wBAAA;EACV,cAAA;EACA,YAAA,EAAc,UAAA;AAAA;AAAA,KAGJ,wBAAA,GAA2B,MAAA,CACrC,aAAA,EACA,wBAAA;;;;;;;;;;;AAPF;;;;;;;;;AAKA;cAyBa,yBAAA,GACX,YAAA,EAAc,UAAA,IACd,aAAA,EAAe,cAAA,EACf,GAAA,qBACC,OAAA,CAAQ,wBAAA"}

package/dist/types/cleanOutputDir.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"cleanOutputDir.d.ts","names":[],"sources":["../../src/cleanOutputDir.ts"],"mappings":";;;cAKa,cAAA,GAAwB,aAAA,EAAe,cAAA,KAAc,OAAA"}

package/dist/types/cleanRemovedContentDeclaration.d.ts

@@ -0,0 +1,11 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/cleanRemovedContentDeclaration.d.ts
+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

@@ -0,0 +1 @@
+{"version":3,"file":"cleanRemovedContentDeclaration.d.ts","names":[],"sources":["../../src/cleanRemovedContentDeclaration.ts"],"mappings":";;;cAea,8BAAA,GACX,QAAA,UACA,UAAA,YACA,aAAA,EAAe,cAAA,KACd,OAAA;EACD,2BAAA;EACA,WAAA;EACA,UAAA;AAAA"}

package/dist/types/cli.d.ts

@@ -0,0 +1,21 @@
+import { prepareIntlayer } from "./prepareIntlayer.js";
+import { detectExportedComponentName } from "./writeContentDeclaration/detectExportedComponentName.js";
+import { DictionaryStatus } from "./writeContentDeclaration/dictionaryStatus.js";
+import { transformJSFile } from "./writeContentDeclaration/transformJSFile.js";
+import { writeContentDeclaration } from "./writeContentDeclaration/writeContentDeclaration.js";
+import { writeJSFile } from "./writeContentDeclaration/writeJSFile.js";
+import { detectFormatCommand } from "./detectFormatCommand.js";
+import { getContentDeclarationFileTemplate } from "./getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.js";
+import { PackageManager, detectPackageManager, installPackages } from "./init/utils/packageManager.js";
+import { RoutingMode } from "./init/utils/configManipulation.js";
+import { CmsCredentials, enableEditorInConfig, setupCmsCredentials, writeCmsCredentialsToEnv } from "./init/cms.js";
+import { NEXT_INTLAYER_BABEL_CONFIG_CONTENT } from "./init/utils/nextCompilerBabel.js";
+import { InitOptions, initIntlayer } from "./init/index.js";
+import { installLSP } from "./installLSP.js";
+import { PLATFORMS, PLATFORMS_METADATA, Platform, PlatformMetadata, SKILLS, SKILLS_METADATA, Skill, getInitialSkills, installSkills } from "./installSkills/index.js";
+import { MCPTransport, installMCP } from "./installMCP/installMCP.js";
+import { listDictionaries, listDictionariesWithStats } from "./listDictionariesPath.js";
+import { DiffMode, ListGitFilesOptions, ListGitLinesOptions, listGitFiles, listGitLines } from "./listGitFiles.js";
+import { ListProjectsOptions, listProjects } from "./listProjects.js";
+import { logConfigDetails } from "./logConfigDetails.js";
+export { type CmsCredentials, DictionaryStatus, DiffMode, InitOptions, ListGitFilesOptions, ListGitLinesOptions, ListProjectsOptions, MCPTransport, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, PLATFORMS, PLATFORMS_METADATA, type PackageManager, Platform, PlatformMetadata, type RoutingMode, SKILLS, SKILLS_METADATA, Skill, detectExportedComponentName, detectFormatCommand, detectPackageManager, enableEditorInConfig, getContentDeclarationFileTemplate, getInitialSkills, initIntlayer, installLSP, installMCP, installPackages, installSkills, listDictionaries, listDictionariesWithStats, listGitFiles, listGitLines, listProjects, logConfigDetails, prepareIntlayer, setupCmsCredentials, transformJSFile, writeCmsCredentialsToEnv, writeContentDeclaration, writeJSFile };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDictionaryEntryPoint.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/createDictionaryEntryPoint.ts"],"mappings":";;;KAuCY,iCAAA;EACV,OAAA;EACA,WAAA;AAAA;;;;cAMW,0BAAA,GACX,aAAA,GAkFD,kBAAA,CAlFC,cAAA,EACA,OAAA,GAAS,iCAAA,KAAsC,OAAA"}

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

@@ -0,0 +1,10 @@
+import * as _$_intlayer_types0 from "@intlayer/types";
+
+//#region src/createDictionaryEntryPoint/generateDictionaryListContent.d.ts
+/**
+ * This function generates the content of the dictionary list file
+ */
+declare const generateDictionaryListContent: (dictionaries: string[], functionName: string, importType: "json" | "javascript", format?: "cjs" | "esm", configuration?: _$_intlayer_types0.IntlayerConfig) => string;
+//#endregion
+export { generateDictionaryListContent };
+//# sourceMappingURL=generateDictionaryListContent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateDictionaryListContent.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/generateDictionaryListContent.ts"],"mappings":";;;;;;cAQa,6BAAA,GACX,YAAA,YACA,YAAA,UACA,UAAA,yBACA,MAAA,kBACA,aAAA,GA0CD,kBAAA,CA1CC,cAAA"}

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

@@ -0,0 +1,10 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createDictionaryEntryPoint/getBuiltDictionariesPath.d.ts
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDictionariesPath.ts"],"mappings":";;;;;AAUA;cAAa,wBAAA,GACX,aAAA,EAAe,cAAA,EACf,WAAA,gBAA0B,OAAA"}

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

@@ -0,0 +1,10 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.d.ts
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltDynamicDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltDynamicDictionariesPath.ts"],"mappings":";;;;;AAUA;cAAa,+BAAA,GACX,aAAA,EAAe,cAAA,EACf,MAAA,kBACA,WAAA,gBAA0B,OAAA"}

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

@@ -0,0 +1,10 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.d.ts
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltFetchDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltFetchDictionariesPath.ts"],"mappings":";;;;;AAUA;cAAa,6BAAA,GACX,aAAA,EAAe,cAAA,EACf,MAAA,kBACA,WAAA,gBAA0B,OAAA"}

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

@@ -0,0 +1,10 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.d.ts
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltRemoteDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltRemoteDictionariesPath.ts"],"mappings":";;;;;AAUA;cAAa,8BAAA,GACX,aAAA,EAAe,cAAA,EACf,WAAA,gBAA0B,OAAA"}

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

@@ -0,0 +1,10 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.d.ts
+/**
+ * This function generates a list of dictionaries in the main directory
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"getBuiltUnmergedDictionariesPath.d.ts","names":[],"sources":["../../../src/createDictionaryEntryPoint/getBuiltUnmergedDictionariesPath.ts"],"mappings":";;;;;AAUA;cAAa,gCAAA,GACX,aAAA,EAAe,cAAA,EACf,WAAA,gBAA0B,OAAA"}

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

@@ -0,0 +1,8 @@
+import { CreateDictionaryEntryPointOptions, createDictionaryEntryPoint } from "./createDictionaryEntryPoint.js";
+import { generateDictionaryListContent } from "./generateDictionaryListContent.js";
+import { getBuiltDictionariesPath } from "./getBuiltDictionariesPath.js";
+import { getBuiltDynamicDictionariesPath } from "./getBuiltDynamicDictionariesPath.js";
+import { getBuiltFetchDictionariesPath } from "./getBuiltFetchDictionariesPath.js";
+import { getBuiltRemoteDictionariesPath } from "./getBuiltRemoteDictionariesPath.js";
+import { getBuiltUnmergedDictionariesPath } from "./getBuiltUnmergedDictionariesPath.js";
+export { CreateDictionaryEntryPointOptions, createDictionaryEntryPoint, generateDictionaryListContent, getBuiltDictionariesPath, getBuiltDynamicDictionariesPath, getBuiltFetchDictionariesPath, getBuiltRemoteDictionariesPath, getBuiltUnmergedDictionariesPath };

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

@@ -0,0 +1,9 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/createType/createModuleAugmentation.d.ts
+declare const getTypeName: (key: string) => string;
+/** Generate the index file merging all the types */
+declare const createModuleAugmentation: (configuration: IntlayerConfig) => Promise<void>;
+//#endregion
+export { createModuleAugmentation, getTypeName };
+//# sourceMappingURL=createModuleAugmentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModuleAugmentation.d.ts","names":[],"sources":["../../../src/createType/createModuleAugmentation.ts"],"mappings":";;;cASa,WAAA,GAAe,GAAA;;cA0Lf,wBAAA,GACX,aAAA,EAAe,cAAA,KAAc,OAAA"}

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

@@ -0,0 +1,12 @@
+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;
+/**
+ * This function generates a TypeScript type definition from a JSON object
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"createType.d.ts","names":[],"sources":["../../../src/createType/createType.ts"],"mappings":";;;;cASa,sBAAA,GACX,UAAA,EAAY,UAAA,GAAa,wBAAA;;AAD3B;;cAUa,WAAA,GACX,YAAA,GAAe,UAAA,GAAa,wBAAA,KAC5B,aAAA,EAAe,cAAA,KACd,OAAA"}

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

@@ -0,0 +1,3 @@
+import { createModuleAugmentation, getTypeName } from "./createModuleAugmentation.js";
+import { createTypes, generateTypeScriptType } from "./createType.js";
+export { createModuleAugmentation, createTypes, generateTypeScriptType, getTypeName };

package/dist/types/detectFormatCommand.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"detectFormatCommand.d.ts","names":[],"sources":["../../src/detectFormatCommand.ts"],"mappings":";;;cAKa,mBAAA,GACX,aAAA,EAAe,cAAA,EACf,kBAAA,GAAqB,MAAA,CAAO,OAAA"}

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

@@ -0,0 +1,18 @@
+import { AlignmentPair, FingerprintedBlock } from "./types.js";
+
+//#region src/docReview/alignBlocks.d.ts
+/**
+ * Align the blocks of a base document with the blocks of its translation using a
+ * Needleman–Wunsch global alignment over anchor similarity and block type.
+ *
+ * Because prose differs across languages, the score is weighted toward the
+ * structural anchor (digits and symbols) rather than the words themselves.
+ *
+ * @param baseBlocks - Blocks of the base (source) document.
+ * @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[];
+//#endregion
+export { alignBaseAndTargetBlocks };
+//# sourceMappingURL=alignBlocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alignBlocks.d.ts","names":[],"sources":["../../../src/docReview/alignBlocks.ts"],"mappings":";;;;;AAcA;;;;;;;;;cAAa,wBAAA,GACX,UAAA,EAAY,kBAAA,IACZ,YAAA,EAAc,kBAAA,OACb,aAAA"}

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

@@ -0,0 +1,22 @@
+//#region src/docReview/computeSimilarity.d.ts
+/**
+ * Generate the set of character shingles (substrings of a fixed length) for a
+ * piece of text. Whitespace is collapsed so the result is language agnostic.
+ *
+ * @param text - The text to shingle.
+ * @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>;
+/**
+ * Compute the Jaccard similarity between two strings using character shingles.
+ *
+ * @param a - First string.
+ * @param b - Second string.
+ * @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;
+//#endregion
+export { computeJaccardSimilarity, generateCharacterShingles };
+//# sourceMappingURL=computeSimilarity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"computeSimilarity.d.ts","names":[],"sources":["../../../src/docReview/computeSimilarity.ts"],"mappings":";;AAQA;;;;;;;cAAa,yBAAA,GACX,IAAA,UACA,aAAA,aACC,GAAA;;AAuBH;;;;;;;cAAa,wBAAA,GACX,CAAA,UACA,CAAA,UACA,aAAA"}

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

@@ -0,0 +1,18 @@
+import { FingerprintedBlock, NormalizedBlock } from "./types.js";
+
+//#region src/docReview/fingerprintBlock.d.ts
+/**
+ * Compute content and context digests for a normalized block.
+ *
+ * The context key (digest of the surrounding blocks) lets the planner tell apart
+ * two blocks that share the same content but live in different sections.
+ *
+ * @param block - The block to fingerprint.
+ * @param previousBlock - The block immediately before, or `null` at the start.
+ * @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;
+//#endregion
+export { fingerprintBlock };
+//# sourceMappingURL=fingerprintBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprintBlock.d.ts","names":[],"sources":["../../../src/docReview/fingerprintBlock.ts"],"mappings":";;;;;AAiBA;;;;;;;;;cAAa,gBAAA,GACX,KAAA,EAAO,eAAA,EACP,aAAA,EAAe,eAAA,SACf,SAAA,EAAW,eAAA,YACV,kBAAA"}

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

@@ -0,0 +1,12 @@
+import { AlignmentPair, AlignmentPlan, Block, BlockType, FingerprintedBlock, LineChange, NormalizedBlock, PlannedAction, SimilarityOptions } from "./types.js";
+import { alignBaseAndTargetBlocks } from "./alignBlocks.js";
+import { computeJaccardSimilarity, generateCharacterShingles } from "./computeSimilarity.js";
+import { fingerprintBlock } from "./fingerprintBlock.js";
+import { mapChangedLinesToBlocks } from "./mapChangedLinesToBlocks.js";
+import { normalizeBlock } from "./normalizeBlock.js";
+import { SegmentToReview, identifySegmentsToReview, mergeReviewedSegments } from "./rebuildDocument.js";
+import { BuildAlignmentPlanInput, BuildAlignmentPlanOutput, buildAlignmentPlan } from "./pipeline.js";
+import { planAlignmentActions } from "./planActions.js";
+import { BuildReviewReportInput, LineRange, ReviewBlockAction, ReviewReport, ReviewReportBlock, ReviewReportSummary, buildReviewReport, formatReviewReport } from "./reviewReport.js";
+import { segmentDocument } from "./segmentDocument.js";
+export { type AlignmentPair, type AlignmentPlan, type Block, type BlockType, type BuildAlignmentPlanInput, type BuildAlignmentPlanOutput, type BuildReviewReportInput, type FingerprintedBlock, type LineChange, type LineRange, type NormalizedBlock, type PlannedAction, type ReviewBlockAction, type ReviewReport, type ReviewReportBlock, type ReviewReportSummary, type SegmentToReview, type SimilarityOptions, alignBaseAndTargetBlocks, buildAlignmentPlan, buildReviewReport, computeJaccardSimilarity, fingerprintBlock, formatReviewReport, generateCharacterShingles, identifySegmentsToReview, mapChangedLinesToBlocks, mergeReviewedSegments, normalizeBlock, planAlignmentActions, segmentDocument };

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

@@ -0,0 +1,15 @@
+import { Block, LineChange } from "./types.js";
+
+//#region src/docReview/mapChangedLinesToBlocks.d.ts
+/**
+ * Map a set of changed line numbers onto the indexes of the blocks that contain
+ * them.
+ *
+ * @param blocks - The ordered blocks of the base document.
+ * @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>;
+//#endregion
+export { mapChangedLinesToBlocks };
+//# sourceMappingURL=mapChangedLinesToBlocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapChangedLinesToBlocks.d.ts","names":[],"sources":["../../../src/docReview/mapChangedLinesToBlocks.ts"],"mappings":";;;;;AAUA;;;;;;cAAa,uBAAA,GACX,MAAA,EAAQ,KAAA,IACR,YAAA,EAAc,UAAA,OACb,GAAA"}

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

@@ -0,0 +1,18 @@
+import { Block, NormalizedBlock } from "./types.js";
+
+//#region src/docReview/normalizeBlock.d.ts
+/**
+ * Derive the normalized representations of a block used for matching.
+ *
+ * - `semanticText`: markdown-stripped, lower-cased text (used to detect identical
+ *   content across versions of the same language).
+ * - `anchorText`: only digits/symbols (used to align blocks across languages, as
+ *   prose differs but structure such as numbers and punctuation is preserved).
+ *
+ * @param block - The block to normalize.
+ * @returns The block enriched with its normalized texts.
+ */
+declare const normalizeBlock: (block: Block) => NormalizedBlock;
+//#endregion
+export { normalizeBlock };
+//# sourceMappingURL=normalizeBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeBlock.d.ts","names":[],"sources":["../../../src/docReview/normalizeBlock.ts"],"mappings":";;;;;AAmCA;;;;;;;;;cAAa,cAAA,GAAkB,KAAA,EAAO,KAAA,KAAQ,eAAA"}