@intlayer/engine 9.0.0-canary.12

package/dist/types/init/utils/githubActions.d.ts

@@ -0,0 +1,19 @@
+import { PackageManager } from "./packageManager.js";
+
+//#region src/init/utils/githubActions.d.ts
+/** A GitHub Actions workflow file to be written to the project. */
+type GithubWorkflowFile = {
+  /** Path relative to the project root, e.g. `.github/workflows/intlayer-fill.yml`. */filePath: string; /** Full YAML content of the workflow file. */
+  content: string;
+};
+/** Workflow file path constants, relative to the project root. */
+declare const GITHUB_FILL_WORKFLOW_PATH = ".github/workflows/intlayer-fill.yml";
+declare const GITHUB_TEST_WORKFLOW_PATH = ".github/workflows/intlayer-test.yml";
+/**
+ * Returns the two Intlayer GitHub Actions workflows (`fill` and `test`),
+ * generated with commands matching the detected package manager.
+ */
+declare const getGithubWorkflows: (packageManager: PackageManager) => GithubWorkflowFile[];
+//#endregion
+export { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, getGithubWorkflows };
+//# sourceMappingURL=githubActions.d.ts.map

package/dist/types/init/utils/githubActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"githubActions.d.ts","names":[],"sources":["../../../../src/init/utils/githubActions.ts"],"mappings":";;;;KAGY,kBAAA;EAAA,qFAEV,QAAA;EAEA,OAAA;AAAA;AAyKF;AAAA,cAAa,yBAAA;AAAA,cACA,yBAAA;;;AAAb;;cAMa,kBAAA,GACX,cAAA,EAAgB,cAAA,KACf,kBAAA"}

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

@@ -0,0 +1,9 @@
+import { CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, PackageManager, detectMissingIntlayerPackages, detectOutdatedIntlayerPackages, detectPackageManager, getInstalledPackageVersion, installPackages, isIntlayerPackageName, normalizeVersion, upgradePackages } from "./packageManager.js";
+import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, replaceViteConfigPluginImportSource, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
+import { ensureNamedImport, firstInsertIndex, isModuleScopeBinding } from "./astImports.js";
+import { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
+import { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, getGithubWorkflows } from "./githubActions.js";
+import { parseJSONWithComments } from "./jsonParser.js";
+import { NEXT_INTLAYER_BABEL_CONFIG_CONTENT, setupNextCompilerBabelConfig } from "./nextCompilerBabel.js";
+import { findTsConfigFiles } from "./tsConfig.js";
+export { CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, PackageManager, RoutingMode, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectOutdatedIntlayerPackages, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getInstalledPackageVersion, getMetroConfigTemplate, installPackages, isIntlayerPackageName, isModuleScopeBinding, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, setIntlayerConfigRoutingMode, setupNextCompilerBabelConfig, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, upgradePackages, writeFileToRoot };

package/dist/types/init/utils/jsonParser.d.ts

@@ -0,0 +1,8 @@
+//#region src/init/utils/jsonParser.d.ts
+/**
+ * Helper to parse JSON that may contain comments (tsconfig allows comments)
+ */
+declare const parseJSONWithComments: (jsonString: string) => any;
+//#endregion
+export { parseJSONWithComments };
+//# sourceMappingURL=jsonParser.d.ts.map

package/dist/types/init/utils/jsonParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonParser.d.ts","names":[],"sources":["../../../../src/init/utils/jsonParser.ts"],"mappings":";;AAGA;;cAAa,qBAAA,GAAyB,UAAA"}

package/dist/types/init/utils/nextCompilerBabel.d.ts

@@ -0,0 +1,53 @@
+import { PackageManager } from "./packageManager.js";
+
+//#region src/init/utils/nextCompilerBabel.d.ts
+/**
+ * `babel.config.js` wiring the full Intlayer compiler + build-optimization
+ * pipeline for Next.js.
+ *
+ * The four passes run in a fixed order — extract first (so dictionaries exist),
+ * optimize last (because it erases the dictionary key the previous passes rely
+ * on). `presets: ["next/babel"]` is required so Babel keeps compiling JSX/TS
+ * the way Next.js does; without it the build breaks.
+ */
+declare const NEXT_INTLAYER_BABEL_CONFIG_CONTENT = "const {\n  intlayerExtractBabelPlugin,\n  intlayerPurgeBabelPlugin,\n  intlayerMinifyBabelPlugin,\n  intlayerOptimizeBabelPlugin,\n  getExtractPluginOptions,\n  getPurgePluginOptions,\n  getMinifyPluginOptions,\n  getOptimizePluginOptions,\n} = require(\"@intlayer/babel\");\n\nmodule.exports = {\n  presets: [\"next/babel\"],\n  plugins: [\n    // Extract: compile .content.ts files \u2192 .intlayer/**/*.json\n    [intlayerExtractBabelPlugin, getExtractPluginOptions()],\n\n    // Purge: remove unused fields from .intlayer/**/*.json\n    //    (reads intlayer.config.ts build.purge flag)\n    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],\n\n    // Minify: rename field keys in JSON + source code\n    //    (reads intlayer.config.ts build.minify flag)\n    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],\n\n    // Optimize: rewrite useIntlayer('key') \u2192 useDictionary(hash)\n    //    Must come last because it erases the dictionary key.\n    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],\n  ],\n};\n";
+/**
+ * Wires the Intlayer compiler + build-optimization Babel plugins into a Next.js
+ * project that already uses Babel.
+ *
+ * Only acts when a Babel config is detected. A default Next.js project compiles
+ * with SWC, where the Intlayer optimize pass is injected automatically by
+ * `withIntlayer` once `@intlayer/swc` is installed — no Babel config is needed,
+ * so there is nothing to set up here. Writing a `babel.config.js` would in fact
+ * be harmful: Next.js falls back from SWC to Babel as soon as one exists, which
+ * disables both the project's SWC compiler and the `@intlayer/swc` plugin.
+ *
+ * When a Babel config is present it:
+ *
+ * 1. Installs `@intlayer/babel` as a dev dependency (unless already present or
+ *    `skipInstall` is set).
+ * 2. Leaves the existing config untouched and prints the plugins to add, since
+ *    arbitrary user configs cannot be safely merged.
+ *
+ * Idempotent: re-running detects the already-wired `@intlayer/babel` import and
+ * skips.
+ *
+ * @param rootDir - Project root directory.
+ * @param packageManager - Detected package manager used to install the package.
+ * @param allDeps - Combined prod + dev dependencies, used to skip a redundant install.
+ * @param skipInstall - When `true`, dependency installation is skipped.
+ */
+declare const setupNextCompilerBabelConfig: ({
+  rootDir,
+  packageManager,
+  allDeps,
+  skipInstall
+}: {
+  rootDir: string;
+  packageManager: PackageManager;
+  allDeps: Record<string, string>;
+  skipInstall: boolean;
+}) => Promise<void>;
+//#endregion
+export { NEXT_INTLAYER_BABEL_CONFIG_CONTENT, setupNextCompilerBabelConfig };
+//# sourceMappingURL=nextCompilerBabel.d.ts.map

package/dist/types/init/utils/nextCompilerBabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextCompilerBabel.d.ts","names":[],"sources":["../../../../src/init/utils/nextCompilerBabel.ts"],"mappings":";;;;;AAcA;;;;;AAwFA;;cAxFa,kCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwFA,4BAAA;EAAsC,OAAA;EAAA,cAAA;EAAA,OAAA;EAAA;AAAA;EAMjD,OAAA;EACA,cAAA,EAAgB,cAAA;EAChB,OAAA,EAAS,MAAA;EACT,WAAA;AAAA,MACE,OAAA"}

package/dist/types/init/utils/packageManager.d.ts

@@ -0,0 +1,149 @@
+//#region src/init/utils/packageManager.d.ts
+/** Package managers supported for dependency installation. */
+type PackageManager = 'bun' | 'pnpm' | 'yarn' | 'npm';
+/**
+ * Configuration for the syncJSON plugin injected into intlayer.config
+ * when a compat i18n library is detected.
+ */
+type CompatSyncConfig = {
+  /**
+   * Which sync plugin ingests the catalogs:
+   * - `'json'` → `syncJSON` from `@intlayer/sync-json-plugin` (default).
+   * - `'po'`   → `syncPO` from `@intlayer/sync-po-plugin` (lingui's default
+   *   format).
+   */
+  plugin?: 'json' | 'po';
+  /**
+   * JSON format matching the compat library's conventions. Ignored when
+   * `plugin` is `'po'` (PO catalogs are always serialized as gettext).
+   */
+  format: 'icu' | 'i18next' | 'vue-i18n';
+  /**
+   * Source path template using ${locale} and ${key} placeholders.
+   * Rendered as a template literal in the generated config.
+   */
+  sourceTemplate: string;
+  /**
+   * Force `splitKeys: true` in the generated `syncJSON(...)` call so each
+   * top-level key of a single per-locale file becomes its own dictionary.
+   *
+   * Set for libraries whose single `messages/${locale}.json` file groups
+   * namespaces by its first-level keys (`next-intl` / `use-intl`, where
+   * `useTranslations('Hero')` resolves to the `Hero` dictionary). Left
+   * undefined for libraries whose top-level keys are plain message keys
+   * (e.g. `i18next`, `react-intl`); for those, syncJSON's auto-detection
+   * (split only when the source has no `${key}` segment) stays in control.
+   *
+   * Only meaningful for flat templates (no `${key}` segment); it is dropped
+   * automatically when the resolved template addresses one namespace per file.
+   */
+  splitKeys?: boolean;
+};
+/**
+ * Configuration for injecting a compat vite plugin into vite.config.
+ * The plugin replaces the generic `intlayer` plugin for libraries that
+ * require alias injection (e.g. `vue-i18n` → `@intlayer/vue-i18n`).
+ */
+type CompatVitePluginConfig = {
+  /** Exported function name from the plugin package, e.g. `'vueI18nVitePlugin'`. */pluginFunctionName: string; /** Import path for the plugin package, e.g. `'@intlayer/vue-i18n/plugin'`. */
+  pluginPackageSource: string;
+  /**
+   * Set when the compat plugin is a drop-in replacement for an i18n library's
+   * own Vite plugin (e.g. lingui ships `@lingui/vite-plugin`). When the original
+   * import is present, init rewrites only that import's module source to
+   * `pluginPackageSource` — keeping the binding and its call site — instead of
+   * injecting a second import and appending another plugin to the array.
+   */
+  replacesVitePlugin?: {
+    /** Imported binding to keep, e.g. `'lingui'`. */importName: string; /** Original package source to rewrite, e.g. `'@lingui/vite-plugin'`. */
+    fromPackageSource: string;
+  };
+};
+/** Result of analyzing project dependencies for intlayer package gaps. */
+type IntlayerPackageAnalysis = {
+  /** Intlayer packages that are referenced but not yet installed. */packagesToInstall: string[]; /** Intlayer dev packages that are referenced but not yet installed. */
+  devPackagesToInstall: string[];
+  /**
+   * syncJSON plugin configuration to inject when a compat i18n library is
+   * detected. Undefined when no compat library is present or format is not
+   * yet implemented.
+   */
+  compatSyncConfig: CompatSyncConfig | undefined;
+  /**
+   * Vite config plugin to inject when a vite-based compat library is
+   * detected. Undefined for Next.js/Nuxt-only compat libs or when no compat
+   * library requires alias injection.
+   */
+  compatVitePluginConfig: CompatVitePluginConfig | undefined;
+};
+/**
+ * Detects the package manager in use by checking for lock files in the
+ * project root. Falls back to npm when no lock file is found.
+ */
+declare const detectPackageManager: (rootDir: string) => PackageManager;
+/**
+ * Analyzes existing project dependencies to determine which intlayer packages
+ * are missing and what syncJSON configuration to inject when compat i18n
+ * libraries are present.
+ */
+/** Extra signals (from a filesystem scan) that refine compat detection. */
+type DetectMissingPackagesOptions = {
+  /**
+   * Catalog format detected for a lingui project (`'po'` or `'json'`), or
+   * `null`/undefined when none was found. Decides which sync plugin + dev
+   * dependency the lingui compat setup uses.
+   */
+  linguiCatalogFormat?: 'po' | 'json' | null;
+  /**
+   * Extra package names injected by the interactive init prompt when the user
+   * selects a compat i18n library that is not yet in `package.json`.
+   * These are merged with the real dependency map before running detection so
+   * the correct sync plugin and compat adapter are scheduled for installation.
+   */
+  hintDependencies?: Record<string, string>;
+};
+declare const detectMissingIntlayerPackages: (allDependencies: Record<string, string>, options?: DetectMissingPackagesOptions) => IntlayerPackageAnalysis;
+/**
+ * Runs the package install command synchronously.
+ * Throws if the install process exits with a non-zero code.
+ */
+declare const installPackages: (rootDir: string, packages: string[], packageManager: PackageManager, isDev?: boolean) => void;
+/**
+ * Determines whether a dependency name belongs to the Intlayer ecosystem.
+ *
+ * Matches the core `intlayer` package, every scoped `@intlayer/*` package
+ * (including compat adapters such as `@intlayer/next-intl`) and the framework
+ * runtime integrations that follow the `<framework>-intlayer` convention
+ * (e.g. `next-intlayer`, `react-intlayer`, `express-intlayer`).
+ */
+declare const isIntlayerPackageName: (packageName: string) => boolean;
+/**
+ * Reduces a semver range or full version to its `major.minor.patch` core,
+ * stripping range prefixes (`^`, `~`), pre-release identifiers and build
+ * metadata. Returns `null` when no `major.minor.patch` can be extracted.
+ *
+ * @example normalizeVersion('^9.0.0-canary.3') // '9.0.0'
+ */
+declare const normalizeVersion: (version?: string) => string | null;
+/**
+ * Reads the installed version of a package from its `package.json` inside the
+ * project's `node_modules`. Returns `null` when the package is not installed or
+ * its manifest cannot be read.
+ */
+declare const getInstalledPackageVersion: (rootDir: string, packageName: string) => string | null;
+/**
+ * Returns the Intlayer packages from `dependencies` whose installed version is
+ * behind `targetVersion` (compared on `major.minor.patch`). Packages that are
+ * not installed yet are ignored — those are handled by
+ * {@link detectMissingIntlayerPackages}.
+ */
+declare const detectOutdatedIntlayerPackages: (rootDir: string, dependencies: Record<string, string>, targetVersion: string) => string[];
+/**
+ * Upgrades the given packages to `targetVersion` synchronously, preserving the
+ * dependency type via the `isDev` flag. Throws if the install process exits
+ * with a non-zero code.
+ */
+declare const upgradePackages: (rootDir: string, packages: string[], packageManager: PackageManager, targetVersion: string, isDev?: boolean) => void;
+//#endregion
+export { CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, PackageManager, detectMissingIntlayerPackages, detectOutdatedIntlayerPackages, detectPackageManager, getInstalledPackageVersion, installPackages, isIntlayerPackageName, normalizeVersion, upgradePackages };
+//# sourceMappingURL=packageManager.d.ts.map

package/dist/types/init/utils/packageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;KAMY,cAAA;;;;;KAMA,gBAAA;EAAgB;;;;;;EAO1B,MAAA;EAyBS;;AAQX;;EA5BE,MAAA;EA4BgC;;;;EAvBhC,cAAA;EAuCE;;;AAKJ;;;;;;;;;;;EA7BE,SAAA;AAAA;;;;;AA+FF;KAvFY,sBAAA;oFAEV,kBAAA,UA2FA;EAzFA,mBAAA;EAgGmB;;;AAGrB;;;;EA3FE,kBAAA;IA8FC,iDA5FC,UAAA,UAwZH;IAtZG,iBAAA;EAAA;AAAA;;KAKQ,uBAAA;EAiZX,mEA/YC,iBAAA,YAqZW;EAnZX,oBAAA;;;;;;EAMA,gBAAA,EAAkB,gBAAA;EAiZlB;;;AAcF;;EAzZE,sBAAA,EAAwB,sBAAA;AAAA;;AAqa1B;;;cA9Za,oBAAA,GAAwB,OAAA,aAAkB,cAAA;;AAyavD;;;;;KA9XY,4BAAA;EAyaX;;;;;EAnaC,mBAAA;EAoZA;;;AAsBF;;;EAnaE,gBAAA,GAAmB,MAAA;AAAA;AAAA,cAGR,6BAAA,GACX,eAAA,EAAiB,MAAA,kBACjB,OAAA,GAAS,4BAAA,KACR,uBAAA;;;;;cAkUU,eAAA,GACX,OAAA,UACA,QAAA,YACA,cAAA,EAAgB,cAAA,EAChB,KAAA;;;;;;;;;cAcW,qBAAA,GAAyB,WAAA;;;;;;;;cAYzB,gBAAA,GAAoB,OAAA;;;;;;cAWpB,0BAAA,GACX,OAAA,UACA,WAAA;;;;;;;cAuBW,8BAAA,GACX,OAAA,UACA,YAAA,EAAc,MAAA,kBACd,aAAA;;;;;;cAsBW,eAAA,GACX,OAAA,UACA,QAAA,YACA,cAAA,EAAgB,cAAA,EAChB,aAAA,UACA,KAAA"}

package/dist/types/init/utils/tsConfig.d.ts

@@ -0,0 +1,8 @@
+//#region src/init/utils/tsConfig.d.ts
+/**
+ * Helper to find all tsconfig files (tsconfig.json, tsconfig.*.json)
+ */
+declare const findTsConfigFiles: (rootDir: string) => Promise<string[]>;
+//#endregion
+export { findTsConfigFiles };
+//# sourceMappingURL=tsConfig.d.ts.map

package/dist/types/init/utils/tsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsConfig.d.ts","names":[],"sources":["../../../../src/init/utils/tsConfig.ts"],"mappings":";;AAKA;;cAAa,iBAAA,GAA2B,OAAA,aAAkB,OAAA"}

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

@@ -0,0 +1,10 @@
+import { configurationFilesCandidates } from "@intlayer/config/node";
+
+//#region src/initConfig/index.d.ts
+/**
+ * Initialize the Intlayer configuration file
+ */
+declare const initConfig: (format: (typeof configurationFilesCandidates)[number], baseDir: string, locales?: string[]) => Promise<void>;
+//#endregion
+export { initConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/initConfig/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/initConfig/index.ts"],"mappings":";;;;;AAwCA;cAAa,UAAA,GACX,MAAA,UAAgB,4BAAA,WAChB,OAAA,UACA,OAAA,gBAAkB,OAAA"}

package/dist/types/installLSP.d.ts

@@ -0,0 +1,12 @@
+//#region src/installLSP.d.ts
+/**
+ * Writes the Intlayer LSP configuration to `.vscode/settings.json`.
+ * Creates the file (and the `.vscode/` directory) if they don't exist.
+ * Does not overwrite keys that are already present.
+ *
+ * Returns a human-readable summary of what was done plus next-step instructions.
+ */
+declare const installLSP: (projectRoot: string) => Promise<string>;
+//#endregion
+export { installLSP };
+//# sourceMappingURL=installLSP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installLSP.d.ts","names":[],"sources":["../../src/installLSP.ts"],"mappings":";;AAkBA;;;;;;cAAa,UAAA,GAAoB,WAAA,aAAsB,OAAA"}

package/dist/types/installMCP/installMCP.d.ts

@@ -0,0 +1,11 @@
+import { Platform } from "../installSkills/index.js";
+
+//#region src/installMCP/installMCP.d.ts
+type MCPTransport = 'stdio' | 'sse';
+/**
+ * Installs the Intlayer MCP server configuration for a specific platform.
+ */
+declare const installMCP: (projectRoot: string, platform: Platform, transport: MCPTransport) => Promise<string>;
+//#endregion
+export { MCPTransport, installMCP };
+//# sourceMappingURL=installMCP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installMCP.d.ts","names":[],"sources":["../../../src/installMCP/installMCP.ts"],"mappings":";;;KAKY,YAAA;;AAAZ;;cAsBa,UAAA,GACX,WAAA,UACA,QAAA,EAAU,QAAA,EACV,SAAA,EAAW,YAAA,KACV,OAAA"}

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

@@ -0,0 +1,42 @@
+//#region src/installSkills/index.d.ts
+/**
+ * Metadata for each available documentation skill.
+ */
+declare const SKILLS_METADATA: {
+  readonly Config: "Intlayer configuration documentation";
+  readonly Content: "Reference for all Intlayer content node types (t, enu, etc.)";
+  readonly Usage: "How to use Intlayer in your project";
+  readonly CLI: "Intlayer CLI commands and usage";
+  readonly Compiler: "Intlayer Compiler setup and usage for automatic content extraction without .content files";
+  readonly RemoteContent: "How to use Intlayer with Remote/CMS/Server-side content";
+  readonly NextJS: "Next.js-specific usage (Server & Client components)";
+  readonly React: "React-specific syntax and hooks usage";
+  readonly Vue: "Vue-specific composables and syntax";
+  readonly Svelte: "Svelte-specific stores and syntax";
+  readonly Angular: "Angular-specific syntax and Injectable Function usage";
+  readonly Preact: "Preact-specific syntax and hooks usage";
+  readonly Solid: "Integrates Intlayer internationalization with SolidJS components. Use when the user asks to \"setup SolidJS i18n\", use the \"useIntlayer\" hook in Solid, or manage locales in a SolidJS application.";
+  readonly Astro: "Astro-specific usage and getIntlayer";
+};
+type Skill = keyof typeof SKILLS_METADATA;
+declare const SKILLS: Skill[];
+declare const getInitialSkills: (deps: Record<string, string>) => (keyof typeof SKILLS_METADATA)[];
+interface PlatformMetadata {
+  label: string;
+  dir: string;
+  check?: () => boolean;
+}
+/**
+ * Metadata and configuration for each supported platform.
+ */
+declare const PLATFORMS_METADATA: Record<string, PlatformMetadata>;
+type Platform = keyof typeof PLATFORMS_METADATA;
+declare const PLATFORMS: Platform[];
+/**
+ * Installs skills using the "Agent Skills" directory standard.
+ * Standard: <PROJECT_ROOT>/<CONFIG_DIR>/skills/<SKILL_NAME>/SKILL.md
+ */
+declare const installSkills: (projectRoot: string, platform: Platform, skills: Skill[]) => Promise<string>;
+//#endregion
+export { PLATFORMS, PLATFORMS_METADATA, Platform, PlatformMetadata, SKILLS, SKILLS_METADATA, Skill, getInitialSkills, installSkills };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/installSkills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/installSkills/index.ts"],"mappings":";;AASA;;cAAa,eAAA;EAAA;;;;;;;;;;;;;;;KAmBD,KAAA,gBAAqB,eAAA;AAAA,cAEpB,MAAA,EAAyC,KAAA;AAAA,cAEzC,gBAAA,GACX,IAAA,EAAM,MAAA,mCACS,eAAA;AAAA,UAoBA,gBAAA;EACf,KAAA;EACA,GAAA;EACA,KAAA;AAAA;;;;cAMW,kBAAA,EAAoB,MAAA,SAAe,gBAAA;AAAA,KA6JpC,QAAA,gBAAwB,kBAAA;AAAA,cAEvB,SAAA,EAA+C,QAAA;;;;;cAkE/C,aAAA,GACX,WAAA,UACA,QAAA,EAAU,QAAA,EACV,MAAA,EAAQ,KAAA,OACP,OAAA"}

package/dist/types/listDictionariesPath.d.ts

@@ -0,0 +1,17 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import * as _$node_fs0 from "node:fs";
+
+//#region src/listDictionariesPath.d.ts
+/**
+ * List all dictionaries absolute paths in the project
+ * @param configuration - The configuration object
+ * @returns An array of dictionary paths
+ */
+declare const listDictionaries: (configuration: IntlayerConfig) => Promise<string[]>;
+declare const listDictionariesWithStats: (configuration: IntlayerConfig) => Promise<{
+  path: string;
+  stats: _$node_fs0.Stats;
+}[]>;
+//#endregion
+export { listDictionaries, listDictionariesWithStats };
+//# sourceMappingURL=listDictionariesPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listDictionariesPath.d.ts","names":[],"sources":["../../src/listDictionariesPath.ts"],"mappings":";;;;;;;AAUA;;cAAa,gBAAA,GACX,aAAA,EAAe,cAAA,KACd,OAAA;AAAA,cAgDU,yBAAA,GACX,aAAA,EAAe,cAAA,KAAc,OAAA;;SAAA,UAAA,CAAA,KAAA;AAAA"}

package/dist/types/listGitFiles.d.ts

@@ -0,0 +1,27 @@
+//#region src/listGitFiles.d.ts
+type DiffMode = 'gitDiff' | 'uncommitted' | 'unpushed' | 'untracked';
+type ListGitFilesOptions = {
+  mode: DiffMode[];
+  baseRef?: string;
+  currentRef?: string;
+  absolute?: boolean;
+};
+declare const listGitFiles: ({
+  mode,
+  baseRef,
+  currentRef,
+  absolute
+}: ListGitFilesOptions) => Promise<string[]>;
+type ListGitLinesOptions = {
+  mode: DiffMode[];
+  baseRef?: string;
+  currentRef?: string;
+};
+declare const listGitLines: (filePath: string, {
+  mode,
+  baseRef,
+  currentRef
+}: ListGitLinesOptions) => Promise<number[]>;
+//#endregion
+export { DiffMode, ListGitFilesOptions, ListGitLinesOptions, listGitFiles, listGitLines };
+//# sourceMappingURL=listGitFiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listGitFiles.d.ts","names":[],"sources":["../../src/listGitFiles.ts"],"mappings":";KAMY,QAAA;AAAA,KAgBA,mBAAA;EACV,IAAA,EAAM,QAAA;EACN,OAAA;EACA,UAAA;EACA,QAAA;AAAA;AAAA,cAGW,YAAA;EAAsB,IAAA;EAAA,OAAA;EAAA,UAAA;EAAA;AAAA,GAKhC,mBAAA,KAAmB,OAAA;AAAA,KAiEV,mBAAA;EACV,IAAA,EAAM,QAAA;EACN,OAAA;EACA,UAAA;AAAA;AAAA,cAGW,YAAA,GACX,QAAA;EACA,IAAA;EAAA,OAAA;EAAA;AAAA,GAIG,mBAAA,KACF,OAAA"}

package/dist/types/listProjects.d.ts

@@ -0,0 +1,26 @@
+//#region src/listProjects.d.ts
+type ListProjectsOptions = {
+  /**
+   * Base directory to search from
+   * @default process.cwd()
+   */
+  baseDir?: string;
+  /**
+   * If true, search from the git root directory instead of baseDir
+   * @default false
+   */
+  gitRoot?: boolean;
+};
+/**
+ * List all Intlayer projects by searching for configuration files
+ *
+ * @param options - Options for listing projects
+ * @returns Array of absolute paths to project directories containing Intlayer config
+ */
+declare const listProjects: (options?: ListProjectsOptions) => Promise<{
+  searchDir: string;
+  projectsPath: string[];
+}>;
+//#endregion
+export { ListProjectsOptions, listProjects };
+//# sourceMappingURL=listProjects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listProjects.d.ts","names":[],"sources":["../../src/listProjects.ts"],"mappings":";KAKY,mBAAA;EAAA;;;;EAKV,OAAA;EA2BW;;;;EAtBX,OAAA;AAAA;;;;;;;cAsBW,YAAA,GACX,OAAA,GAAU,mBAAA,KACT,OAAA;EAAU,SAAA;EAAmB,YAAA;AAAA"}

package/dist/types/loadDictionaries/getIntlayerBundle.d.ts

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

package/dist/types/loadDictionaries/getIntlayerBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIntlayerBundle.d.ts","names":[],"sources":["../../../src/loadDictionaries/getIntlayerBundle.ts"],"mappings":";;;cA8Ca,iBAAA,GAA2B,aAAA,EAAe,cAAA,KAAc,OAAA"}

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

@@ -0,0 +1,5 @@
+import { DictionariesStatus, loadDictionaries } from "./loadDictionaries.js";
+import { ensureIntlayerBundle, formatLocalDictionaries, loadContentDeclaration, loadContentDeclarations } from "./loadContentDeclaration.js";
+import { loadLocalDictionaries } from "./loadLocalDictionaries.js";
+import { formatDistantDictionaries, loadRemoteDictionaries } from "./loadRemoteDictionaries.js";
+export { DictionariesStatus, ensureIntlayerBundle, formatDistantDictionaries, formatLocalDictionaries, loadContentDeclaration, loadContentDeclarations, loadDictionaries, loadLocalDictionaries, loadRemoteDictionaries };

package/dist/types/loadDictionaries/loadContentDeclaration.d.ts

@@ -0,0 +1,15 @@
+import { DictionariesStatus } from "./loadDictionaries.js";
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/loadDictionaries/loadContentDeclaration.d.ts
+declare const formatLocalDictionaries: (dictionariesRecord: Record<string, Dictionary>, configuration: IntlayerConfig) => Dictionary[];
+declare const ensureIntlayerBundle: (configuration: IntlayerConfig) => Promise<string>;
+type LoadContentDeclarationOptions = {
+  logError?: boolean;
+};
+declare const loadContentDeclaration: (path: string, configuration: IntlayerConfig, bundleFilePath?: string, options?: LoadContentDeclarationOptions) => Promise<Dictionary | undefined>;
+declare const loadContentDeclarations: (contentDeclarationFilePath: string[], configuration: IntlayerConfig, onStatusUpdate?: (status: DictionariesStatus[]) => void, options?: LoadContentDeclarationOptions) => Promise<Dictionary[]>;
+//#endregion
+export { ensureIntlayerBundle, formatLocalDictionaries, loadContentDeclaration, loadContentDeclarations };
+//# sourceMappingURL=loadContentDeclaration.d.ts.map

package/dist/types/loadDictionaries/loadContentDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadContentDeclaration.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadContentDeclaration.ts"],"mappings":";;;;;cAmBa,uBAAA,GACX,kBAAA,EAAoB,MAAA,SAAe,UAAA,GACnC,aAAA,EAAe,cAAA,KACd,UAAA;AAAA,cAQU,oBAAA,GACX,aAAA,EAAe,cAAA,KACd,OAAA;AAAA,KAmBE,6BAAA;EACH,QAAA;AAAA;AAAA,cA+CW,sBAAA,GACX,IAAA,UACA,aAAA,EAAe,cAAA,EACf,cAAA,WACA,OAAA,GAAU,6BAAA,KACT,OAAA,CAAQ,UAAA;AAAA,cAuDE,uBAAA,GACX,0BAAA,YACA,aAAA,EAAe,cAAA,EACf,cAAA,IAAkB,MAAA,EAAQ,kBAAA,aAC1B,OAAA,GAAU,6BAAA,KACT,OAAA,CAAQ,UAAA"}

package/dist/types/loadDictionaries/loadDictionaries.d.ts

@@ -0,0 +1,23 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/loadDictionaries/loadDictionaries.d.ts
+type DictionariesStatus = {
+  dictionaryKey: string;
+  type: 'local' | 'remote';
+  status: 'pending' | 'fetching' | 'fetched' | 'error' | 'imported' | 'found' | 'building' | 'built';
+  error?: string;
+};
+declare const loadDictionaries: (contentDeclarationsPaths: string[] | string, configuration: IntlayerConfig) => Promise<{
+  localDictionaries: Dictionary[];
+  remoteDictionaries: Dictionary[];
+  pluginDictionaries: Dictionary[];
+  time: {
+    localDictionaries: number;
+    remoteDictionaries: number;
+    pluginDictionaries: number;
+  };
+}>;
+//#endregion
+export { DictionariesStatus, loadDictionaries };
+//# sourceMappingURL=loadDictionaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadDictionaries.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadDictionaries.ts"],"mappings":";;;;KAeY,kBAAA;EACV,aAAA;EACA,IAAA;EACA,MAAA;EASA,KAAA;AAAA;AAAA,cAiIW,gBAAA,GACX,wBAAA,qBACA,aAAA,EAAe,cAAA,KACd,OAAA;EACD,iBAAA,EAAmB,UAAA;EACnB,kBAAA,EAAoB,UAAA;EACpB,kBAAA,EAAoB,UAAA;EACpB,IAAA;IACE,iBAAA;IACA,kBAAA;IACA,kBAAA;EAAA;AAAA"}

package/dist/types/loadDictionaries/loadLocalDictionaries.d.ts

@@ -0,0 +1,8 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/loadDictionaries/loadLocalDictionaries.d.ts
+declare const loadLocalDictionaries: (contentDeclarationsPaths: string[] | string, configuration: IntlayerConfig) => Promise<Dictionary[]>;
+//#endregion
+export { loadLocalDictionaries };
+//# sourceMappingURL=loadLocalDictionaries.d.ts.map

package/dist/types/loadDictionaries/loadLocalDictionaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLocalDictionaries.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadLocalDictionaries.ts"],"mappings":";;;;cAMa,qBAAA,GACX,wBAAA,qBACA,aAAA,EAAe,cAAA,KACd,OAAA,CAAQ,UAAA"}

package/dist/types/loadDictionaries/loadMarkdownContentDeclaration.d.ts

@@ -0,0 +1,7 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/loadDictionaries/loadMarkdownContentDeclaration.d.ts
+declare const loadMarkdownContentDeclaration: (path: string) => Promise<Dictionary | undefined>;
+//#endregion
+export { loadMarkdownContentDeclaration };
+//# sourceMappingURL=loadMarkdownContentDeclaration.d.ts.map

package/dist/types/loadDictionaries/loadMarkdownContentDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadMarkdownContentDeclaration.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadMarkdownContentDeclaration.ts"],"mappings":";;;cAoBa,8BAAA,GACX,IAAA,aACC,OAAA,CAAQ,UAAA"}

package/dist/types/loadDictionaries/loadRemoteDictionaries.d.ts

@@ -0,0 +1,15 @@
+import { DictionariesStatus } from "./loadDictionaries.js";
+import { Dictionary } from "@intlayer/types/dictionary";
+import * as _$_intlayer_types0 from "@intlayer/types";
+import { DictionaryAPI } from "@intlayer/backend";
+
+//#region src/loadDictionaries/loadRemoteDictionaries.d.ts
+declare const formatDistantDictionaries: (dictionaries: (DictionaryAPI | Dictionary)[]) => Dictionary[];
+declare const loadRemoteDictionaries: (configuration?: _$_intlayer_types0.IntlayerConfig, onStatusUpdate?: (status: DictionariesStatus[]) => void, options?: {
+  onStartRemoteCheck?: () => void;
+  onStopRemoteCheck?: () => void;
+  onError?: (error: Error) => void;
+}) => Promise<Dictionary[]>;
+//#endregion
+export { formatDistantDictionaries, loadRemoteDictionaries };
+//# sourceMappingURL=loadRemoteDictionaries.d.ts.map

package/dist/types/loadDictionaries/loadRemoteDictionaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRemoteDictionaries.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadRemoteDictionaries.ts"],"mappings":";;;;;;cAea,yBAAA,GACX,YAAA,GAAe,aAAA,GAAgB,UAAA,QAC9B,UAAA;AAAA,cAOU,sBAAA,GACX,aAAA,GAqID,kBAAA,CArIC,cAAA,EACA,cAAA,IAAkB,MAAA,EAAQ,kBAAA,aAC1B,OAAA;EACE,kBAAA;EACA,iBAAA;EACA,OAAA,IAAW,KAAA,EAAO,KAAA;AAAA,MAEnB,OAAA,CAAQ,UAAA"}

package/dist/types/loadDictionaries/loadYamlContentDeclaration.d.ts

@@ -0,0 +1,7 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/loadDictionaries/loadYamlContentDeclaration.d.ts
+declare const loadYamlContentDeclaration: (path: string) => Promise<Dictionary | undefined>;
+//#endregion
+export { loadYamlContentDeclaration };
+//# sourceMappingURL=loadYamlContentDeclaration.d.ts.map

package/dist/types/loadDictionaries/loadYamlContentDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadYamlContentDeclaration.d.ts","names":[],"sources":["../../../src/loadDictionaries/loadYamlContentDeclaration.ts"],"mappings":";;;cAIa,0BAAA,GACX,IAAA,aACC,OAAA,CAAQ,UAAA"}

package/dist/types/loadDictionaries/log.d.ts

@@ -0,0 +1,36 @@
+import { DictionariesStatus } from "./loadDictionaries.js";
+
+//#region src/loadDictionaries/log.d.ts
+declare class DictionariesLogger {
+  private statuses;
+  private spinnerTimer;
+  private spinnerIndex;
+  private renderedLines;
+  private readonly spinnerFrames;
+  private isFinished;
+  private readonly prefix;
+  private lastRenderedState;
+  private remoteCheckInProgress;
+  private expectRemote;
+  private remoteError;
+  private pluginTotal;
+  private pluginDone;
+  private pluginError;
+  constructor();
+  setExpectRemote(expect: boolean): void;
+  startRemoteCheck(): void;
+  stopRemoteCheck(): void;
+  update(newStatuses: DictionariesStatus[]): void;
+  finish(): void;
+  private startSpinner;
+  private stopSpinner;
+  setRemoteError: (error?: Error) => void;
+  setPluginTotal(total: number): void;
+  setPluginDone(done: number): void;
+  setPluginError(error?: Error): void;
+  private render;
+  private computeProgress;
+}
+//#endregion
+export { DictionariesLogger };
+//# sourceMappingURL=log.d.ts.map

package/dist/types/loadDictionaries/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/loadDictionaries/log.ts"],"mappings":";;;cAYa,kBAAA;EAAA,QACH,QAAA;EAAA,QACA,YAAA;EAAA,QACA,YAAA;EAAA,QACA,aAAA;EAAA,iBACS,aAAA;EAAA,QACT,UAAA;EAAA,iBACS,MAAA;EAAA,QACT,iBAAA;EAAA,QACA,qBAAA;EAAA,QACA,YAAA;EAAA,QACA,WAAA;EAAA,QACA,WAAA;EAAA,QACA,UAAA;EAAA,QACA,WAAA;;EAMR,eAAA,CAAgB,MAAA;EAIhB,gBAAA,CAAA;EAOA,eAAA,CAAA;EAIA,MAAA,CAAO,WAAA,EAAa,kBAAA;EAyBpB,MAAA,CAAA;EAAA,QAOQ,YAAA;EAAA,QAQA,WAAA;EAMD,cAAA,GAAkB,KAAA,GAAQ,KAAA;EAQjC,cAAA,CAAe,KAAA;EASf,aAAA,CAAc,IAAA;EAMd,cAAA,CAAe,KAAA,GAAQ,KAAA;EAAA,QAMf,MAAA;EAAA,QAqGA,eAAA;AAAA"}