@intlayer/engine 9.0.0-canary.12

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

@@ -0,0 +1,46 @@
+import { FingerprintedBlock } from "./types.js";
+import { SegmentToReview, mergeReviewedSegments } from "./rebuildDocument.js";
+
+//#region src/docReview/pipeline.d.ts
+type BuildAlignmentPlanInput = {
+  /** The base (source) document, used as the translation reference. */baseText: string; /** The existing target (translated) document, possibly empty. */
+  targetText: string; /** 1-based line numbers that changed in the base document, when known. */
+  changedLines: number[] | undefined;
+};
+type BuildAlignmentPlanOutput = {
+  baseBlocks: FingerprintedBlock[];
+  targetBlocks: FingerprintedBlock[];
+  plan: AlignmentPlan;
+  segmentsToReview: SegmentToReview[];
+};
+/**
+ * Build the block-aware alignment plan between a base document and its
+ * translation, in two levels.
+ *
+ * 1. **Sections** (heading-anchored) are aligned first. Because a document and
+ *    its translation share the same heading structure, this alignment is robust
+ *    and never drops a section just because the prose was split into a different
+ *    number of paragraphs.
+ * 2. Only the sections **touched by a changed line** are then re-segmented into
+ *    fine blocks (paragraphs, code fences) and aligned within the section, so a
+ *    small edit re-translates only the affected paragraph(s) instead of the
+ *    whole section. Within a changed section a target block with no base
+ *    counterpart is **kept as-is** (reused) rather than deleted, so a translation
+ *    that has extra paragraphs never loses content.
+ *
+ * Section-level insertions and deletions stay whole: a brand-new section is
+ * translated as one unit, and a target section with no base counterpart is
+ * reported as `delete` for visibility but never dropped by the merge (see
+ * {@link mergeReviewedSegments}), so a review can never lose translated content.
+ *
+ * @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;
+//#endregion
+export { BuildAlignmentPlanInput, BuildAlignmentPlanOutput, type SegmentToReview, buildAlignmentPlan, mergeReviewedSegments };
+//# sourceMappingURL=pipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","names":[],"sources":["../../../src/docReview/pipeline.ts"],"mappings":";;;;KAYY,uBAAA;uEAEV,QAAA,UAFiC;EAIjC,UAAA,UAJiC;EAMjC,YAAA;AAAA;AAAA,KAGU,wBAAA;EACV,UAAA,EAAY,kBAAA;EACZ,YAAA,EAAc,kBAAA;EACd,IAAA,EAAM,aAAA;EACN,gBAAA,EAAkB,eAAA;AAAA;;;;;;;;;;;;;;;;;AAsDpB;;;;;;;cAAa,kBAAA;EAAsB,QAAA;EAAA,UAAA;EAAA;AAAA,GAIhC,uBAAA,KAA0B,wBAAA"}

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

@@ -0,0 +1,18 @@
+import { AlignmentPair, AlignmentPlan } from "./types.js";
+
+//#region src/docReview/planActions.d.ts
+/**
+ * Turn raw alignment pairs into an ordered list of merge actions.
+ *
+ * A block aligned in both documents is reused when its base counterpart is not
+ * marked as changed, and reviewed otherwise. Blocks present only in the base are
+ * inserted, blocks present only in the target are deleted.
+ *
+ * @param alignment - The alignment pairs produced by the aligner.
+ * @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;
+//#endregion
+export { planAlignmentActions };
+//# sourceMappingURL=planActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planActions.d.ts","names":[],"sources":["../../../src/docReview/planActions.ts"],"mappings":";;;;;AAaA;;;;;;;;;cAAa,oBAAA,GACX,SAAA,EAAW,aAAA,IACX,uBAAA,EAAyB,GAAA,aACxB,aAAA"}

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

@@ -0,0 +1,46 @@
+import { AlignmentPlan, FingerprintedBlock } from "./types.js";
+
+//#region src/docReview/rebuildDocument.d.ts
+/**
+ * A block that needs to be translated or re-translated by an external consumer
+ * (an AI client, a human, or an agent).
+ */
+type SegmentToReview = {
+  /** The base block to translate. */baseBlock: FingerprintedBlock; /** Existing target translation, or `null` when the block is new. */
+  targetBlockText: string | null; /** Index of the originating action within {@link AlignmentPlan.actions}. */
+  actionIndex: number;
+};
+type RebuildInput = {
+  baseBlocks: FingerprintedBlock[];
+  targetBlocks: FingerprintedBlock[];
+  plan: AlignmentPlan;
+};
+type RebuildResult = {
+  segmentsToReview: SegmentToReview[];
+};
+/**
+ * Analyze the alignment plan and return only the segments that need
+ * review/translation. Does not generate output text - that is done by
+ * {@link mergeReviewedSegments} once the translations are available.
+ *
+ * @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;
+/**
+ * Merge reviewed translations back into the final document following the
+ * alignment plan, reusing untouched target blocks as-is.
+ *
+ * @param plan - The alignment plan.
+ * @param targetBlocks - Blocks of the existing target document.
+ * @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;
+//#endregion
+export { RebuildInput, RebuildResult, SegmentToReview, identifySegmentsToReview, mergeReviewedSegments };
+//# sourceMappingURL=rebuildDocument.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildDocument.d.ts","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"mappings":";;;;;AAMA;;KAAY,eAAA;EAEmB,mCAA7B,SAAA,EAAW,kBAAA,EAAA;EAEX,eAAA,iBAEA;EAAA,WAAA;AAAA;AAAA,KAGU,YAAA;EACV,UAAA,EAAY,kBAAA;EACZ,YAAA,EAAc,kBAAA;EACd,IAAA,EAAM,aAAA;AAAA;AAAA,KAGI,aAAA;EACV,gBAAA,EAAkB,eAAA;AAAA;;;;;;;;;cAWP,wBAAA;EAA4B,UAAA;EAAA,YAAA;EAAA;AAAA,GAItC,YAAA,KAAe,aAAA;;;;;AAJlB;;;;;cAuCa,qBAAA,GACX,IAAA,EAAM,aAAA,EACN,YAAA,EAAc,kBAAA,IACd,gBAAA,EAAkB,GAAA"}

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

@@ -0,0 +1,82 @@
+//#region src/docReview/reviewReport.d.ts
+/**
+ * The kind of change detected for a block when reviewing a translation against
+ * its base document.
+ *
+ * - `review`: the base block changed and its translation must be updated.
+ * - `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';
+/** A 1-based, inclusive line range within a document. */
+type LineRange = {
+  start: number;
+  end: number;
+};
+/**
+ * A single block that diverges between the base document and its translation.
+ *
+ * This is the unit an external translator (AI client, human, or agent) needs to
+ * 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 = {
+  /** What should happen to this block. */action: ReviewBlockAction; /** Line range of the block in the base document (omitted for pure deletions). */
+  baseLineRange?: LineRange; /** Line range of the block in the target document (omitted for new insertions). */
+  targetLineRange?: LineRange; /** Raw markdown of the base block (omitted for pure deletions). */
+  baseContent?: string; /** Existing translation of the block (omitted for new insertions). */
+  targetContent?: string;
+};
+type ReviewReportSummary = {
+  /** Number of blocks reused as-is (unchanged translation). */reuse: number; /** Number of blocks whose translation must be updated. */
+  review: number; /** Number of blocks missing a translation. */
+  insertNew: number; /** Number of stale target blocks to delete. */
+  delete: number;
+};
+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 = {
+  /** The base (source) document, used as the translation reference. */baseText: string; /** The existing target (translated) document, possibly empty. */
+  targetText: string;
+  /**
+   * 1-based line numbers that changed in the base document. When omitted, only
+   * inserted and deleted blocks are reported (no aligned block is flagged for
+   * review since there is no way to know which ones changed).
+   */
+  changedLines?: number[];
+};
+/**
+ * Compare a base markdown document with its translation and report only the
+ * blocks that need attention, with their line ranges and content.
+ *
+ * Reusable across the CLI (`doc review --log`), the backend (comparing two
+ * translation contents stored in database), and agents that generate the
+ * missing translations.
+ *
+ * @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;
+/**
+ * Render a {@link ReviewReport} as a human and agent readable log.
+ *
+ * Each divergent block is printed with its action, the base/target line ranges,
+ * the base content to translate, and the existing translation to update.
+ *
+ * @param report - The report to format.
+ * @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?: {
+  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

@@ -0,0 +1 @@
+{"version":3,"file":"reviewReport.d.ts","names":[],"sources":["../../../src/docReview/reviewReport.ts"],"mappings":";;AAYA;;;;;AAGA;;KAHY,iBAAA;;KAGA,SAAA;EACV,KAAA;EACA,GAAA;AAAA;;;;;;;;KAUU,iBAAA;EAIM,wCAFhB,MAAA,EAAQ,iBAAA,EAIU;EAFlB,aAAA,GAAgB,SAAA,EAMhB;EAJA,eAAA,GAAkB,SAAA,EAIL;EAFb,WAAA,WAK6B;EAH7B,aAAA;AAAA;AAAA,KAGU,mBAAA;EAIV,6DAFA,KAAA,UAMA;EAJA,MAAA,UAIM;EAFN,SAAA,UAKsB;EAHtB,MAAA;AAAA;AAAA,KAGU,YAAA;EAEF,iEAAR,MAAA,EAAQ,iBAAA,IAEC;EAAT,OAAA,EAAS,mBAAA;AAAA;AAAA,KAGC,sBAAA;EAAsB,qEAEhC,QAAA,UAFgC;EAIhC,UAAA;EAAA;;;;AAoBF;EAdE,YAAA;AAAA;;;;;;;;;;;;cAcW,iBAAA;EAAqB,QAAA;EAAA,UAAA;EAAA;AAAA,GAI/B,sBAAA,KAAyB,YAAA;;;;;;AAgJ5B;;;;;cAAa,kBAAA,GACX,MAAA,EAAQ,YAAA,EACR,OAAA;EAAY,SAAA;EAAoB,WAAA;AAAA"}

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

@@ -0,0 +1,40 @@
+import { Block } from "./types.js";
+
+//#region src/docReview/segmentDocument.d.ts
+/**
+ * Split a markdown document into fine-grained blocks.
+ *
+ * Boundaries are drawn at headings, blank lines (paragraph breaks) and fenced
+ * code blocks, while frontmatter and the inside of code fences are kept intact.
+ * Each blank-line run is appended to the block that precedes it, so the blocks
+ * form an exact partition of the document: concatenating every `content` (in
+ * order) yields the original text unchanged. This is what lets the block-aware
+ * review re-translate only the paragraphs/snippets that actually changed instead
+ * of the whole heading section.
+ *
+ * @param text - The full markdown document.
+ * @returns The ordered list of blocks with their 1-based line ranges.
+ */
+declare const segmentDocument: (text: string) => Block[];
+/**
+ * Split a markdown document into coarse, heading-anchored sections.
+ *
+ * Built by grouping the fine blocks of {@link segmentDocument}: frontmatter and
+ * each heading open a new section, and the following non-heading blocks are
+ * folded into it. Because it only concatenates adjacent fine blocks, the result
+ * is still an exact partition of the document (sections concatenate back to the
+ * source unchanged).
+ *
+ * Sections are the robust alignment unit between a base document and its
+ * translation — both share the same heading structure, so they align almost
+ * perfectly and a translation that splits its prose into a different number of
+ * paragraphs never causes a section to be dropped. Fine-grained review happens
+ * within a section once it is known to have changed.
+ *
+ * @param text - The full markdown document.
+ * @returns The ordered list of sections with their 1-based line ranges.
+ */
+declare const segmentSections: (text: string) => Block[];
+//#endregion
+export { segmentDocument, segmentSections };
+//# sourceMappingURL=segmentDocument.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segmentDocument.d.ts","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"mappings":";;;;;AAmCA;;;;;AAgHA;;;;;;;cAhHa,eAAA,GAAmB,IAAA,aAAe,KAAA;;;;;;;;;;;;;;;;;;;cAgHlC,eAAA,GAAmB,IAAA,aAAe,KAAA"}

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

@@ -0,0 +1,73 @@
+//#region src/docReview/types.d.ts
+/**
+ * Semantic category a markdown block can belong to.
+ *
+ * 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';
+/**
+ * A raw markdown block extracted from a document, with its line range.
+ */
+type Block = {
+  type: BlockType;
+  content: string; /** 1-based line number where the block starts (inclusive). */
+  lineStart: number; /** 1-based line number where the block ends (inclusive). */
+  lineEnd: number;
+};
+/**
+ * A {@link Block} enriched with normalized text used for similarity matching.
+ */
+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. */
+  anchorText: string;
+};
+/**
+ * A {@link NormalizedBlock} enriched with content digests used to detect reuse.
+ */
+type FingerprintedBlock = NormalizedBlock & {
+  semanticDigest: string;
+  anchorDigest: string;
+  compositeKey: string;
+  contextKey?: string;
+};
+/**
+ * A single alignment between a base block and an (optional) target block.
+ *
+ * `baseIndex === -1` means the target block has no base counterpart (deletion).
+ * `targetIndex === null` means the base block has no target counterpart (insertion).
+ */
+type AlignmentPair = {
+  baseIndex: number;
+  targetIndex: number | null;
+  similarityScore: number;
+};
+/**
+ * An action the merge step should take for a given aligned pair of blocks.
+ */
+type PlannedAction = {
+  kind: 'reuse';
+  baseIndex: number;
+  targetIndex: number;
+} | {
+  kind: 'review';
+  baseIndex: number;
+  targetIndex: number | null;
+} | {
+  kind: 'insert_new';
+  baseIndex: number;
+} | {
+  kind: 'delete';
+  targetIndex: number;
+};
+type AlignmentPlan = {
+  actions: PlannedAction[];
+};
+/** A 1-based line number that changed in the base document. */
+type LineChange = number;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/docReview/types.ts"],"mappings":";;AAKA;;;;KAAY,SAAA;AAcZ;;;AAAA,KAAY,KAAA;EACV,IAAA,EAAM,SAAA;EACN,OAAA;EAEA,SAAA,UAEA;EAAA,OAAA;AAAA;AAMF;;;AAAA,KAAY,eAAA,GAAkB,KAAA;EAAA,wEAE5B,YAAA,UAEA;EAAA,UAAA;AAAA;AAMF;;;AAAA,KAAY,kBAAA,GAAqB,eAAA;EAC/B,cAAA;EACA,YAAA;EACA,YAAA;EACA,UAAA;AAAA;;;AASF;;;;KAAY,aAAA;EACV,SAAA;EACA,WAAA;EACA,eAAA;AAAA;AAMF;;;AAAA,KAAY,aAAA;EACN,IAAA;EAAe,SAAA;EAAmB,WAAA;AAAA;EAClC,IAAA;EAAgB,SAAA;EAAmB,WAAA;AAAA;EACnC,IAAA;EAAoB,SAAA;AAAA;EACpB,IAAA;EAAgB,WAAA;AAAA;AAAA,KAEV,aAAA;EACV,OAAA,EAAS,aAAA;AAAA;AAIX;AAAA,KAAY,UAAA;AAAA,KAEA,iBAAA;EAFU,qFAIpB,oBAAA,UAFU;EAIV,4BAAA;AAAA"}

package/dist/types/fetchDistantDictionaries.d.ts

@@ -0,0 +1,16 @@
+import { DictionariesStatus } from "./loadDictionaries/loadDictionaries.js";
+import { DictionaryAPI } from "@intlayer/backend";
+
+//#region src/fetchDistantDictionaries.d.ts
+type FetchDistantDictionariesOptions = {
+  dictionaryKeys: string[];
+  newDictionariesPath?: string;
+  logPrefix?: string;
+};
+/**
+ * Fetch distant dictionaries and update the logger with their statuses.
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KASK,+BAAA;EACH,cAAA;EACA,mBAAA;EACA,SAAA;AAAA;;;;cAMW,wBAAA,GACX,OAAA,EAAS,+BAAA,EACT,cAAA,IAAkB,MAAA,EAAQ,kBAAA,gBACzB,OAAA,CAAQ,aAAA"}

package/dist/types/filterInvalidDictionaries.d.ts

@@ -0,0 +1,12 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/filterInvalidDictionaries.d.ts
+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[];
+//#endregion
+export { filterInvalidDictionaries, isInvalidDictionary };
+//# sourceMappingURL=filterInvalidDictionaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filterInvalidDictionaries.d.ts","names":[],"sources":["../../src/filterInvalidDictionaries.ts"],"mappings":";;;;KAaK,0BAAA;EAA+B,WAAA;AAAA;AAAA,cAEvB,mBAAA,GACX,UAAA,EAAY,UAAA,cACZ,aAAA,GAAgB,cAAA,EAChB,OAAA,GAAU,0BAAA;AAAA,cA2GC,yBAAA,GACX,YAAA,GAAe,UAAA,6BACf,aAAA,EAAe,cAAA,EACf,OAAA,GAAU,0BAAA,KACT,UAAA"}

package/dist/types/formatDictionary.d.ts

@@ -0,0 +1,62 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+import * as _$_intlayer_types0 from "@intlayer/types";
+import * as _$_intlayer_core_messageFormat0 from "@intlayer/core/messageFormat";
+
+//#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"]) => Dictionary | {
+  format: string;
+  content: _$_intlayer_core_messageFormat0.JsonValue;
+  $schema?: "https://intlayer.org/schema.json";
+  id?: _$_intlayer_types0.DictionaryId;
+  projectIds?: string[];
+  localId?: _$_intlayer_types0.LocalDictionaryId;
+  localIds?: _$_intlayer_types0.LocalDictionaryId[];
+  key: _$_intlayer_types0.DictionaryKey;
+  title?: string;
+  description?: string;
+  versions?: string[];
+  version?: string;
+  filePath?: string;
+  tags?: string[];
+  item?: number;
+  variant?: _$_intlayer_types0.DictionaryVariantValue | _$_intlayer_types0.DictionaryVariantValue[];
+  locale?: _$_intlayer_types0.LocalesValues;
+  contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
+  fill?: _$_intlayer_types0.Fill;
+  filled?: true;
+  priority?: number;
+  importMode?: _$_intlayer_types0.ImportMode;
+  location?: _$_intlayer_types0.DictionaryLocation;
+  schema: undefined;
+};
+declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dictionary["format"]) => (Dictionary | {
+  format: string;
+  content: _$_intlayer_core_messageFormat0.JsonValue;
+  $schema?: "https://intlayer.org/schema.json";
+  id?: _$_intlayer_types0.DictionaryId;
+  projectIds?: string[];
+  localId?: _$_intlayer_types0.LocalDictionaryId;
+  localIds?: _$_intlayer_types0.LocalDictionaryId[];
+  key: _$_intlayer_types0.DictionaryKey;
+  title?: string;
+  description?: string;
+  versions?: string[];
+  version?: string;
+  filePath?: string;
+  tags?: string[];
+  item?: number;
+  variant?: _$_intlayer_types0.DictionaryVariantValue | _$_intlayer_types0.DictionaryVariantValue[];
+  locale?: _$_intlayer_types0.LocalesValues;
+  contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
+  fill?: _$_intlayer_types0.Fill;
+  filled?: true;
+  priority?: number;
+  importMode?: _$_intlayer_types0.ImportMode;
+  location?: _$_intlayer_types0.DictionaryLocation;
+  schema: undefined;
+})[];
+//#endregion
+export { formatDictionaries, formatDictionariesOutput, formatDictionary, formatDictionaryOutput };
+//# sourceMappingURL=formatDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;;;;cAYa,gBAAA,GAAoB,UAAA,EAAY,UAAA,KAAa,UAAA;AAAA,cAoC7C,kBAAA,GACX,YAAA,EAAc,UAAA,OACb,OAAA,CAAQ,UAAA;AAAA,cAEE,sBAAA,GACX,UAAA,EAAY,UAAA,EACZ,MAAA,EAAQ,UAAA,eAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;cAqCjB,wBAAA,GACX,YAAA,EAAc,UAAA,IACd,MAAA,EAAQ,UAAA,gBAAoB,UAAA;;WAAA,+BAAA,CAAA,SAAA"}

package/dist/types/getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.d.ts

@@ -0,0 +1,7 @@
+import { Format } from "../utils/getFormatFromExtension.js";
+
+//#region src/getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.d.ts
+declare const getContentDeclarationFileTemplate: (key: string, format: Format, fileParams?: Record<string, any>, noMetadata?: boolean) => Promise<string>;
+//#endregion
+export { getContentDeclarationFileTemplate };
+//# sourceMappingURL=getContentDeclarationFileTemplate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getContentDeclarationFileTemplate.d.ts","names":[],"sources":["../../../src/getContentDeclarationFileTemplate/getContentDeclarationFileTemplate.ts"],"mappings":";;;cAGa,iCAAA,GACX,GAAA,UACA,MAAA,EAAQ,MAAA,EACR,UAAA,GAAY,MAAA,eACZ,UAAA,eAAoB,OAAA"}

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

@@ -0,0 +1,2 @@
+import { getContentDeclarationFileTemplate } from "./getContentDeclarationFileTemplate.js";
+export { getContentDeclarationFileTemplate };

package/dist/types/handleAdditionalContentDeclarationFile.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleAdditionalContentDeclarationFile.d.ts","names":[],"sources":["../../src/handleAdditionalContentDeclarationFile.ts"],"mappings":";;;cAQa,sCAAA,GACX,QAAA,UACA,MAAA,EAAQ,cAAA,KAAc,OAAA"}

package/dist/types/handleContentDeclarationFileChange.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleContentDeclarationFileChange.d.ts","names":[],"sources":["../../src/handleContentDeclarationFileChange.ts"],"mappings":";;;cAca,kCAAA,GACX,QAAA,UACA,MAAA,EAAQ,cAAA,KAAc,OAAA"}

package/dist/types/handleContentDeclarationFileMoved.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleContentDeclarationFileMoved.d.ts","names":[],"sources":["../../src/handleContentDeclarationFileMoved.ts"],"mappings":";;;cAOa,iCAAA,GACX,WAAA,UACA,WAAA,UACA,MAAA,EAAQ,cAAA,KAAc,OAAA"}

package/dist/types/handleUnlinkedContentDeclarationFile.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleUnlinkedContentDeclarationFile.d.ts","names":[],"sources":["../../src/handleUnlinkedContentDeclarationFile.ts"],"mappings":";;;cAWa,oCAAA,GACX,QAAA,UACA,MAAA,EAAQ,cAAA,KAAc,OAAA"}

package/dist/types/init/cms.d.ts

@@ -0,0 +1,51 @@
+import { RoutingMode } from "./utils/configManipulation.js";
+
+//#region src/init/cms.d.ts
+/**
+ * Intlayer configuration file candidates, ordered by the precedence used when
+ * resolving which file to mutate.
+ */
+declare const INTLAYER_CONFIG_FILE_CANDIDATES: readonly ["intlayer.config.ts", "intlayer.config.mjs", "intlayer.config.js", "intlayer.config.cjs", "intlayer.config.json"];
+/** Credentials returned by the CMS login flow (access key pair). */
+type CmsCredentials = {
+  clientId: string;
+  clientSecret: string;
+};
+/**
+ * Locates the environment file the CMS credentials should be written to. Uses
+ * `fast-glob` to detect an existing dotenv file at the project root, preferring
+ * a plain `.env`; falls back to `.env` (to be created) when none exist.
+ */
+declare const findEnvFile: (rootDir: string) => Promise<string>;
+/**
+ * Persists the CMS access-key credentials to the project's environment file as
+ * `INTLAYER_CLIENT_ID` / `INTLAYER_CLIENT_SECRET`. The target file is detected
+ * with {@link findEnvFile} and created when missing. Returns the relative path
+ * of the file that was written.
+ */
+declare const writeCmsCredentialsToEnv: (rootDir: string, {
+  clientId,
+  clientSecret
+}: CmsCredentials) => Promise<string>;
+/**
+ * Enables the Intlayer visual editor in the project's configuration file:
+ * flips `editor.enabled` to `true` and wires `clientId` / `clientSecret` to the
+ * matching environment variables. JSON configs cannot reference `process.env`,
+ * so they are skipped with a warning. Returns the config file that was updated,
+ * or `undefined` when no editable config was found.
+ */
+declare const enableEditorInConfig: (rootDir: string) => Promise<string | undefined>;
+/**
+ * Sets `routing.mode` in the project's Intlayer configuration file. Returns the
+ * config file that was updated, or `undefined` when none was found.
+ */
+declare const setRoutingModeInConfig: (rootDir: string, mode: RoutingMode) => Promise<string | undefined>;
+/**
+ * Completes the CMS setup once credentials are received from the login flow:
+ * writes them to the environment file and enables the editor in the Intlayer
+ * configuration file.
+ */
+declare const setupCmsCredentials: (rootDir: string, credentials: CmsCredentials) => Promise<void>;
+//#endregion
+export { CmsCredentials, INTLAYER_CONFIG_FILE_CANDIDATES, enableEditorInConfig, findEnvFile, setRoutingModeInConfig, setupCmsCredentials, writeCmsCredentialsToEnv };
+//# sourceMappingURL=cms.d.ts.map

package/dist/types/init/cms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cms.d.ts","names":[],"sources":["../../../src/init/cms.ts"],"mappings":";;;;;AAcA;;cAAa,+BAAA;;KAgBD,cAAA;EACV,QAAA;EACA,YAAA;AAAA;;;AAwBF;;;cAAa,WAAA,GAAqB,OAAA,aAAkB,OAAA;;AA0CpD;;;;;cAAa,wBAAA,GACX,OAAA;EACA,QAAA;EAAA;AAAA,GAA4B,cAAA,KAC3B,OAAA;;;;;;;;cAmCU,oBAAA,GACX,OAAA,aACC,OAAA;;;;;cAwCU,sBAAA,GACX,OAAA,UACA,IAAA,EAAM,WAAA,KACL,OAAA;;;;;AAHH;cA2Ba,mBAAA,GACX,OAAA,UACA,WAAA,EAAa,cAAA,KACZ,OAAA"}

package/dist/types/init/frameworkSetup/index.d.ts

@@ -0,0 +1,13 @@
+import { FrameworkAdapter, FrameworkSetupContext } from "./types.js";
+
+//#region src/init/frameworkSetup/index.d.ts
+/**
+ * Runs framework-specific scaffolding (middleware/proxy, providers in
+ * layout/page, example content) for the first adapter that matches the project.
+ * No-ops when no adapter recognizes the project. Each adapter is idempotent and
+ * non-destructive, so this is safe to run on existing applications.
+ */
+declare const setupFramework: (context: FrameworkSetupContext) => Promise<void>;
+//#endregion
+export { type FrameworkAdapter, type FrameworkSetupContext, setupFramework };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/init/frameworkSetup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/index.ts"],"mappings":";;;;AAsBA;;;;;cAAa,cAAA,GACX,OAAA,EAAS,qBAAA,KACR,OAAA"}

package/dist/types/init/frameworkSetup/nextAppRouter/detect.d.ts

@@ -0,0 +1,25 @@
+//#region src/init/frameworkSetup/nextAppRouter/detect.d.ts
+/** Location of the Next.js App Router directory within the project. */
+type NextAppDirInfo = {
+  /** App Router directory relative to the root, e.g. `src/app` or `app`. */appDir: string; /** `src` when the project uses a `src/` directory, otherwise `''`. */
+  srcDir: string;
+};
+/**
+ * Detects the Next.js App Router directory, preferring `src/app` over `app`.
+ * Returns `null` when neither exists (e.g. a Pages Router project).
+ */
+declare const detectNextAppDir: (rootDir: string) => Promise<NextAppDirInfo | null>;
+/**
+ * Finds an existing App Router convention file (e.g. `layout`, `page`) within
+ * `dir`, trying each known script extension. Returns the matching relative path
+ * or `null`.
+ */
+declare const findAppFile: (rootDir: string, dir: string, baseName: string) => Promise<string | null>;
+/**
+ * Returns true when the dependency `version` range targets a major >= `major`.
+ * Tolerant of leading range characters, e.g. `^16.0.0`, `~16`, `16.1.0`.
+ */
+declare const isVersionAtLeast: (version: string | undefined, major: number) => boolean;
+//#endregion
+export { NextAppDirInfo, detectNextAppDir, findAppFile, isVersionAtLeast };
+//# sourceMappingURL=detect.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/detect.ts"],"mappings":";;KAOY,cAAA;EAAc,0EAExB,MAAA;EAEA,MAAA;AAAA;;;;;cAOW,gBAAA,GACX,OAAA,aACC,OAAA,CAAQ,cAAA;;;;AAeX;;cAAa,WAAA,GACX,OAAA,UACA,GAAA,UACA,QAAA,aACC,OAAA;;;;;cAcU,gBAAA,GACX,OAAA,sBACA,KAAA"}

package/dist/types/init/frameworkSetup/nextAppRouter/index.d.ts

@@ -0,0 +1,12 @@
+import { FrameworkAdapter } from "../types.js";
+
+//#region src/init/frameworkSetup/nextAppRouter/index.d.ts
+/**
+ * Next.js App Router adapter. Scaffolds the locale proxy/middleware, restructures
+ * the app into a `[locale]` segment, and wraps the layout/page with the Intlayer
+ * providers — all idempotently and without overwriting recognizable user code.
+ */
+declare const nextAppRouterAdapter: FrameworkAdapter;
+//#endregion
+export { nextAppRouterAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/index.ts"],"mappings":";;;;;AA6HA;;;cAAa,oBAAA,EAAsB,gBAAA"}