@saykit/config 0.0.0-beta-20260330102339 → 0.0.0-beta-20260418203312

package/dist/commands/index.mjs

@@ -1,139 +1,10 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
+import { t as resolveConfig } from "../resolve-BifzXxrw.mjs";
+import { t as generateHash } from "../hash-CA-PhXGF.mjs";
 import { Command, program } from "@commander-js/extra-typings";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import picomatch from "picomatch";
-import * as z from "zod";
-import { access, glob, mkdir, readFile, rm, watch, writeFile } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
+import { dirname, join, relative, resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { collectMessages, generateHash } from "@saykit/babel-plugin/core";
-
-//#region src/shapes.ts
-const Message = z.object({
-	message: z.string(),
-	translation: z.string().optional(),
-	id: z.string().optional(),
-	context: z.string().optional(),
-	comments: z.string().array(),
-	references: z.string().array()
-});
-const Formatter = z.object({
-	extension: z.templateLiteral([".", z.string()]),
-	parse: z.custom((v) => typeof v === "function"),
-	stringify: z.custom((v) => typeof v === "function")
-});
-const Bucket = z.object({
-	include: z.array(z.string()),
-	exclude: z.array(z.string()).optional(),
-	output: z.templateLiteral([
-		z.string(),
-		"{locale}",
-		z.string(),
-		".{extension}"
-	]),
-	formatter: Formatter
-}).transform((v) => ({
-	...v,
-	match: picomatch(v.include, { ignore: v.exclude })
-}));
-const Configuration = z.object({
-	sourceLocale: z.string(),
-	locales: z.tuple([z.string()], z.string()),
-	fallbackLocales: z.record(z.string(), z.array(z.string())).optional(),
-	buckets: z.array(Bucket)
-}).refine((c) => c.sourceLocale === c.locales[0], "sourceLocale must be the same as locales[0]");
-
-//#endregion
-//#region src/features/loader/explorer.ts
-function getFilesToTry(name) {
-	return [
-		`${name}.config.js`,
-		`${name}.config.cjs`,
-		`${name}.config.mjs`,
-		`${name}.config.ts`,
-		`${name}.config.mts`,
-		`${name}.config.cts`
-	];
-}
-async function findConfigFile(moduleName, projectDir) {
-	for (const fileName of getFilesToTry(moduleName)) try {
-		const id = join(projectDir, fileName);
-		await access(id);
-		return {
-			id,
-			content: await readFile(id, "utf8")
-		};
-	} catch {}
-	return null;
-}
-
-//#endregion
-//#region src/features/loader/loaders.ts
-const js = async (path, _content) => {
-	try {
-		const { href } = pathToFileURL(path);
-		return (await import(href)).default;
-	} catch (importError) {
-		try {
-			const require = globalThis.require ?? createRequire(path);
-			const module = require(path);
-			delete require.cache[require.resolve(path)];
-			return module?.default ?? module;
-		} catch (requireError) {
-			throw new Error("Failed to import module", { cause: [importError, requireError] });
-		}
-	}
-};
-const ts = async (path, content) => {
-	const ts = await import("typescript");
-	const outputPath = `${path}.${Date.now()}.js`;
-	try {
-		const tsConfigPath = ts.findConfigFile(dirname(path), ts.sys.fileExists) || "tsconfig.json";
-		const { config: tsConfig, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-		if (error) throw error;
-		tsConfig.compilerOptions = {
-			...tsConfig.compilerOptions,
-			module: ts.ModuleKind.ES2022,
-			moduleResolution: ts.ModuleResolutionKind.Bundler,
-			target: ts.ScriptTarget.ES2022,
-			noEmit: false
-		};
-		const transpiledContent = ts.transpileModule(content, tsConfig).outputText;
-		await writeFile(outputPath, transpiledContent);
-		return await js(outputPath, transpiledContent);
-	} catch (error) {
-		throw new Error("Failed to import module", { cause: error });
-	} finally {
-		if (ts.sys.fileExists(outputPath)) await rm(outputPath);
-	}
-};
-var loaders_default = Object.freeze({
-	".js": js,
-	".mjs": js,
-	".cjs": js,
-	".ts": ts,
-	".mts": ts,
-	".cts": ts
-});
-
-//#endregion
-//#region src/features/loader/resolve.ts
-async function useConfig(name = "saykit") {
-	const file = await findConfigFile(name, process.cwd());
-	if (!file) throw new Error(`Could not find config file for "${name}"`);
-	const ext = extname(file.id).toLowerCase();
-	const loader = ext in loaders_default ? loaders_default[ext] : null;
-	if (!loader) throw new Error(`Unsupported config file type "${ext}" for "${name}"`);
-	let config = await loader(file.id, file.content);
-	if (!config || typeof config !== "object") throw new Error(`Invalid config file for "${name}"`);
-	if (config && typeof config === "object" && "saykit" in config) config = config.saykit;
-	const result = await Configuration.safeParseAsync(config);
-	if (result.error) throw new Error(`Invalid config file for "${name}"`, { cause: result.error });
-	return result.data;
-}
-
-//#endregion
+import { glob, mkdir, readFile, watch, writeFile } from "node:fs/promises";
 //#region src/features/logger.ts
 const RESET = "\x1B[0m";
 const DIM = "\x1B[2m";
@@ -171,108 +42,7 @@ var Logger = class {
 		if (this.#verbose) this.log(` ${DIM}→ ${message}${RESET}`);
 	}
 };
-const loggerStorage = new AsyncLocalStorage({ defaultValue: new Logger() });
-
-//#endregion
-//#region src/features/extract.ts
-async function extractMessages(path) {
-	return collectMessages(path, await readFile(path, "utf8").catch(() => "")).map((m) => ({
-		message: m.toICUString(),
-		translation: m.toICUString(),
-		id: m.descriptor.id,
-		context: m.descriptor.context,
-		comments: m.comments,
-		references: m.references.map((r) => relative(process.cwd(), r).replaceAll("\\", "/"))
-	}));
-}
-function mergeUnique(...items) {
-	return Array.from(new Set(items.flat()));
-}
-function mergeMessages(messages) {
-	const mergedMessages = messages.reduce((map, message) => {
-		const key = message.id ?? generateHash(message.message, message.context);
-		const existing = map.get(key) ?? message;
-		map.set(key, {
-			...existing,
-			comments: mergeUnique(...existing.comments, ...message.comments),
-			references: mergeUnique(...existing.references, ...message.references)
-		});
-		return map;
-	}, /* @__PURE__ */ new Map());
-	return Array.from(mergedMessages.values());
-}
-function reconcileMessages(existingMessages, newMessages) {
-	const existingMessagesMap = existingMessages.reduce((map, message) => {
-		const key = message.id ?? generateHash(message.message, message.context);
-		map.set(key, message);
-		return map;
-	}, /* @__PURE__ */ new Map());
-	const updatedMessagesMap = newMessages.reduce((map, message) => {
-		const key = message.id ?? generateHash(message.message, message.context);
-		const existingMessage = existingMessagesMap.get(key);
-		map.set(key, {
-			message: message.message,
-			translation: void 0,
-			...existingMessage,
-			id: message.id,
-			context: message.context,
-			comments: message.comments,
-			references: message.references
-		});
-		return map;
-	}, /* @__PURE__ */ new Map());
-	return Array.from(updatedMessagesMap.values());
-}
-function expandOutputPath(bucket, locale, extension = bucket.formatter.extension) {
-	return resolve(bucket.output.replaceAll("{locale}", locale).replaceAll("{extension}", extension.slice(1)));
-}
-async function readMessagesFromDisk(bucket, locale, path = expandOutputPath(bucket, locale)) {
-	const content = await readFile(path, "utf8").catch(() => "");
-	if (!content) return [];
-	return await bucket.formatter.parse(content, { locale });
-}
-async function writeMessagesToDisk(bucket, locale, messages, path = expandOutputPath(bucket, locale)) {
-	const content = await bucket.formatter.stringify(messages, { locale });
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content);
-}
-
-//#endregion
-//#region src/features/compile.ts
-async function hydrateTranslations(cache, config, bucket, locale, messages) {
-	if (cache.has(locale)) return cache.get(locale);
-	const translations = await applyFallbackTranslations(cache, config, bucket, locale, messages);
-	cache.set(locale, translations);
-	return translations;
-}
-function getFallbackChain(config, locale) {
-	return [...config.fallbackLocales?.[locale] ?? [], config.sourceLocale];
-}
-async function applyFallbackTranslations(cache, config, bucket, locale, messages) {
-	const fallbacks = getFallbackChain(config, locale);
-	const translations = {};
-	for (const message of messages) {
-		const key = message.id ?? generateHash(message.message, message.context);
-		if (message.translation) {
-			translations[key] = message.translation;
-			continue;
-		}
-		for (const fallback of fallbacks) {
-			const fallbackMessages = await hydrateTranslations(cache, config, bucket, fallback, messages);
-			if (fallbackMessages[key]) {
-				translations[key] = fallbackMessages[key];
-				break;
-			}
-		}
-	}
-	return translations;
-}
-async function writeTranslationsToDisk(bucket, locale, translations, path = expandOutputPath(bucket, locale, ".json")) {
-	const content = JSON.stringify(translations, null, 2);
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content);
-}
-
+new AsyncLocalStorage({ defaultValue: new Logger() });
 //#endregion
 //#region src/features/watch.ts
 /**
@@ -316,10 +86,61 @@ async function* watchDebounced(path, options, delay = 300) {
 		yield next;
 	} else await new Promise((r) => setTimeout(r, 10));
 }
-
 //#endregion
-//#region src/features/worker.ts
-function normalisePath(path) {
+//#region src/features/catalogue/path.ts
+function expandBucketOutputPath(bucket, locale, extension = bucket.formatter.extension) {
+	return resolve(bucket.output.replaceAll("{locale}", locale).replaceAll("{extension}", extension.slice(1)));
+}
+//#endregion
+//#region src/features/catalogue/storage.ts
+async function readCatalogueMessages(bucket, locale, path = expandBucketOutputPath(bucket, locale)) {
+	const content = await readFile(path, "utf8").catch(() => "");
+	if (!content) return [];
+	return bucket.formatter.parse(content, { locale });
+}
+async function writeCatalogueMessages(bucket, locale, messages, path = expandBucketOutputPath(bucket, locale)) {
+	const content = bucket.formatter.stringify(messages, { locale });
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+//#endregion
+//#region src/features/runtime/translations.ts
+function getFallbackLocaleChain(config, locale) {
+	return [...config.fallbackLocales?.[locale] ?? [], config.sourceLocale];
+}
+async function hydrateTranslations(cache, config, bucket, locale, messages) {
+	if (cache.has(locale)) return cache.get(locale);
+	const translations = await applyFallbackTranslations(cache, config, bucket, locale, messages);
+	cache.set(locale, translations);
+	return translations;
+}
+async function applyFallbackTranslations(cache, config, bucket, locale, messages) {
+	const fallbackLocales = getFallbackLocaleChain(config, locale);
+	const translations = {};
+	for (const message of messages) {
+		const key = message.id ?? generateHash(message.message, message.context);
+		if (message.translation) {
+			translations[key] = message.translation;
+			continue;
+		}
+		for (const fallbackLocale of fallbackLocales) {
+			const fallbackTranslations = await hydrateTranslations(cache, config, bucket, fallbackLocale, await readCatalogueMessages(bucket, fallbackLocale));
+			if (fallbackTranslations[key]) {
+				translations[key] = fallbackTranslations[key];
+				break;
+			}
+		}
+	}
+	return translations;
+}
+async function writeRuntimeTranslations(bucket, locale, translations, path = expandBucketOutputPath(bucket, locale, ".json")) {
+	const content = JSON.stringify(translations, null, 2);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+//#endregion
+//#region src/features/workers/shared.ts
+function normalisePathForLogs(path) {
 	return relative(process.cwd(), path).replaceAll("\\", "/");
 }
 var BucketWorker = class {
@@ -332,66 +153,137 @@ var BucketWorker = class {
 		this.logger = logger;
 	}
 };
+//#endregion
+//#region src/features/workers/compile-worker.ts
+var BucketCompileWorker = class extends BucketWorker {
+	#translationsByLocale = /* @__PURE__ */ new Map();
+	async compileAll() {
+		this.logger.info(`Compiling bucket: ${this.bucket.include}`);
+		for (const locale of this.config.locales) await this.compileLocale(locale);
+		this.logger.success(`Compilation complete for bucket: ${this.bucket.include}`);
+	}
+	async compileLocale(locale) {
+		this.logger.step(`Compiling locale: ${locale}`);
+		const messages = await readCatalogueMessages(this.bucket, locale);
+		const translations = await hydrateTranslations(this.#translationsByLocale, this.config, this.bucket, locale, messages);
+		this.logger.step(`Writing runtime file for ${locale}`);
+		await writeRuntimeTranslations(this.bucket, locale, translations);
+	}
+};
+//#endregion
+//#region src/features/catalogue/extractor.ts
+async function extractMessagesFromFile(path, bucket) {
+	const content = await readFile(path, "utf8").catch(() => "");
+	if (!content) return [];
+	return bucket.transformer.extract(content, path).map((message) => ({
+		...message,
+		translation: message.translation ?? message.message,
+		references: message.references.map((reference) => relative(process.cwd(), reference).replaceAll("\\", "/"))
+	}));
+}
+//#endregion
+//#region src/features/catalogue/merge.ts
+function mergeUnique(...items) {
+	return Array.from(new Set(items.flat()));
+}
+function getMessageKey(message) {
+	return message.id ?? generateHash(message.message, message.context);
+}
+function mergeExtractedMessages(messages) {
+	const mergedMessages = messages.reduce((map, message) => {
+		const key = getMessageKey(message);
+		const existing = map.get(key) ?? message;
+		map.set(key, {
+			...existing,
+			comments: mergeUnique(...existing.comments, ...message.comments),
+			references: mergeUnique(...existing.references, ...message.references)
+		});
+		return map;
+	}, /* @__PURE__ */ new Map());
+	return Array.from(mergedMessages.values());
+}
+function reconcileLocaleMessages(existingMessages, nextMessages) {
+	const existingMessagesByKey = existingMessages.reduce((map, message) => {
+		map.set(getMessageKey(message), message);
+		return map;
+	}, /* @__PURE__ */ new Map());
+	const reconciledMessages = nextMessages.reduce((map, message) => {
+		const key = getMessageKey(message);
+		const existingMessage = existingMessagesByKey.get(key);
+		map.set(key, {
+			message: message.message,
+			translation: void 0,
+			...existingMessage,
+			id: message.id,
+			context: message.context,
+			comments: message.comments,
+			references: message.references
+		});
+		return map;
+	}, /* @__PURE__ */ new Map());
+	return Array.from(reconciledMessages.values());
+}
+//#endregion
+//#region src/features/workers/extract-worker.ts
 var BucketExtractWorker = class extends BucketWorker {
-	index = /* @__PURE__ */ new Map();
+	#indexedMessagesByPath = /* @__PURE__ */ new Map();
 	get messages() {
-		return Array.from(this.index.values()).flat();
+		return Array.from(this.#indexedMessagesByPath.values()).flat();
 	}
-	async indexPath(path) {
-		const rp = normalisePath(path);
-		this.logger.step(`Processing ${rp}`);
-		const messages = await extractMessages(path);
-		if (!messages.length) return false;
-		this.index.set(path, messages);
-		this.logger.step(`Found ${messages.length} messages(s) in ${rp}`);
+	async #indexPath(path) {
+		const relativePath = normalisePathForLogs(path);
+		this.logger.step(`Processing ${relativePath}`);
+		const messages = await extractMessagesFromFile(path, this.bucket);
+		if (!messages.length) {
+			if (this.#indexedMessagesByPath.has(path)) {
+				this.#indexedMessagesByPath.delete(path);
+				this.logger.step(`Removed stale entries for ${relativePath}`);
+				return true;
+			}
+			return false;
+		}
+		this.#indexedMessagesByPath.set(path, messages);
+		this.logger.step(`Found ${messages.length} message(s) in ${relativePath}`);
 		return true;
 	}
 	async scanAll() {
 		this.logger.info(`Scanning bucket: ${this.bucket.include}`);
 		const paths = await globBucket(this.bucket);
 		this.logger.step(`Found ${paths.length} file(s)`);
-		await Promise.all(paths.map((p) => this.indexPath(p)));
+		await Promise.all(paths.map((path) => this.#indexPath(path)));
 		this.logger.info(`Total extracted messages: ${this.messages.length}`);
 	}
 	async writeAll() {
-		const newMessages = mergeMessages(this.messages);
-		this.logger.info(`Writing ${newMessages.length} messages to locales`);
+		const mergedMessages = mergeExtractedMessages(this.messages);
+		this.logger.info(`Writing ${mergedMessages.length} messages to locales`);
 		for (const locale of this.config.locales) {
 			this.logger.step(`Writing locale file for ${locale} to disk`);
-			const existingMessages = await readMessagesFromDisk(this.bucket, locale);
-			const updatedMessages = locale === this.config.sourceLocale ? newMessages : reconcileMessages(existingMessages, newMessages);
-			await writeMessagesToDisk(this.bucket, locale, updatedMessages);
+			const existingMessages = await readCatalogueMessages(this.bucket, locale);
+			const nextMessages = locale === this.config.sourceLocale ? mergedMessages : reconcileLocaleMessages(existingMessages, mergedMessages);
+			await writeCatalogueMessages(this.bucket, locale, nextMessages);
 		}
 		this.logger.success(`Extraction complete for bucket: ${this.bucket.include}`);
 	}
 	async updatePath(path) {
-		const changed = await this.indexPath(path);
+		const changed = await this.#indexPath(path);
 		if (changed) await this.writeAll();
 		return changed;
 	}
 };
-var BucketCompileWorker = class extends BucketWorker {
-	cache = /* @__PURE__ */ new Map();
-	async compileAll() {
-		this.logger.info(`Compiling bucket: ${this.bucket.include}`);
-		for (const locale of this.config.locales) await this.compileLocale(locale);
-		this.logger.success(`Compilation complete for bucket: ${this.bucket.include}`);
-	}
-	async compileLocale(locale) {
-		this.logger.step(`Compiling locale: ${locale}`);
-		const messages = await readMessagesFromDisk(this.bucket, locale);
-		const translations = await hydrateTranslations(this.cache, this.config, this.bucket, locale, messages);
-		this.logger.step(`Writing runtime file for ${locale}`);
-		await writeTranslationsToDisk(this.bucket, locale, translations);
-	}
-};
+//#endregion
+//#region src/features/workers/build-worker.ts
 var BucketBuildWorker = class extends BucketWorker {
 	extract;
 	compile;
 	constructor(config, bucket, logger) {
-		super(config, bucket, logger);
-		this.extract = new BucketExtractWorker(config, bucket, logger);
-		this.compile = new BucketCompileWorker(config, bucket, logger);
+		const parameters = [
+			config,
+			bucket,
+			logger
+		];
+		super(...parameters);
+		this.extract = new BucketExtractWorker(...parameters);
+		this.compile = new BucketCompileWorker(...parameters);
 	}
 	async buildAll() {
 		await this.extract.scanAll();
@@ -404,41 +296,38 @@ var BucketBuildWorker = class extends BucketWorker {
 			if (!event.filename || !this.bucket.match(event.filename)) continue;
 			const filePath = join(process.cwd(), event.filename);
 			if (await this.extract.updatePath(filePath)) {
-				this.logger.info(`Recompiling due to changes in ${normalisePath(filePath)}`);
+				this.logger.info(`Recompiling due to changes in ${normalisePathForLogs(filePath)}`);
 				await this.compile.compileAll();
 			}
 		}
 	}
 };
-
 //#endregion
 //#region src/commands/build.ts
 var build_default = new Command().name("build").description("").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
-	const config = await useConfig("saykit");
+	const config = await resolveConfig("saykit");
 	const logger = new Logger(options);
 	logger.header("🏗 Building Messages");
 	const tasks = config.buckets.map(async (bucket) => {
 		await new BucketBuildWorker(config, bucket, logger).buildAll();
 	});
-	await Promise.allSettled(tasks);
+	await Promise.all(tasks);
 });
-
 //#endregion
 //#region src/commands/compile.ts
 var compile_default = new Command("compile").description("Compile translations into runtime-ready locale files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
-	const config = await useConfig("saykit");
+	const config = await resolveConfig("saykit");
 	const logger = new Logger(options);
 	logger.header("🛠 Compiling Translations");
 	const tasks = config.buckets.map(async (bucket) => {
 		await new BucketCompileWorker(config, bucket, logger).compileAll();
 	});
-	await Promise.allSettled(tasks);
+	await Promise.all(tasks);
 });
-
 //#endregion
 //#region src/commands/extract.ts
 var extract_default = new Command("extract").description("Extract messages from source files").option("-v, --verbose", "enable verbose logging", false).option("-q, --quiet", "suppress all logging", false).action(async (options) => {
-	const config = await useConfig("saykit");
+	const config = await resolveConfig("saykit");
 	const logger = new Logger(options);
 	logger.header("🛠 Extracting Messages");
 	const tasks = config.buckets.map(async (bucket) => {
@@ -446,13 +335,14 @@ var extract_default = new Command("extract").description("Extract messages from
 		await worker.scanAll();
 		await worker.writeAll();
 	});
-	await Promise.allSettled(tasks);
+	const rejections = (await Promise.allSettled(tasks)).filter((r) => r.status === "rejected");
+	if (rejections.length > 0) {
+		const errors = rejections.map((r) => r.reason).join("\n");
+		throw new Error(`Bucket extraction failed:\n${errors}`);
+	}
 });
-
 //#endregion
 //#region src/commands/index.ts
 program.name("saykit").helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").addCommand(extract_default).addCommand(compile_default).addCommand(build_default).parse();
-
 //#endregion
-export {  };
-//# sourceMappingURL=index.mjs.map
+export {};

package/dist/features/loader/index.d.mts

@@ -0,0 +1,37 @@
+import { i as Message } from "../../shapes-B0roKIQa.mjs";
+
+//#region src/features/loader/resolve.d.ts
+declare function resolveConfig(name?: string): {
+  sourceLocale: string;
+  locales: [string, ...string[]];
+  buckets: {
+    match: (id: string) => boolean;
+    include: string[];
+    output: `${string}{locale}${string}.{extension}`;
+    formatter: {
+      extension: `.${string}`;
+      parse: (content: string, context: {
+        locale: string;
+      }) => Message[];
+      stringify: (messages: Message[], context: {
+        locale: string;
+      }) => string;
+    };
+    transformer: {
+      match: (id: string) => boolean;
+      extract: (code: string, id: string) => {
+        message: string;
+        comments: string[];
+        references: string[];
+        translation?: string | undefined;
+        id?: string | undefined;
+        context?: string | undefined;
+      }[];
+      transform: (code: string, id: string) => string;
+    };
+    exclude?: string[] | undefined;
+  }[];
+  fallbackLocales?: Record<string, string[]> | undefined;
+};
+//#endregion
+export { resolveConfig };

package/dist/features/loader/index.mjs

@@ -0,0 +1,2 @@
+import { t as resolveConfig } from "../../resolve-BifzXxrw.mjs";
+export { resolveConfig };

package/dist/features/messages/index.d.mts

@@ -0,0 +1,62 @@
+//#region src/features/messages/identifier.d.ts
+declare const AUTO_INCREMENT_IDENTIFIER: unique symbol;
+declare function assignSequenceIdentifiers(message: Message, sequence?: {
+  current: number;
+}): void;
+//#endregion
+//#region src/features/messages/types.d.ts
+declare abstract class Base {
+  toICUString(this: Message): string;
+  toHashString(this: Message): string;
+}
+declare class LiteralMessage extends Base {
+  readonly text: string;
+  constructor(text: string);
+}
+declare class ArgumentMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, expression: any);
+}
+declare class ElementMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly children: Message[];
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, children: Message[], expression: any);
+}
+declare class ChoiceMessage extends Base {
+  readonly kind: string;
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[];
+  readonly expression: any;
+  constructor(kind: string, identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[], expression: any);
+}
+declare class CompositeMessage extends Base {
+  readonly descriptor: {
+    id?: string;
+    context?: string;
+  };
+  readonly comments: string[];
+  readonly references: string[];
+  readonly children: Message[];
+  readonly accessor: any;
+  constructor(descriptor: {
+    id?: string;
+    context?: string;
+  }, comments: string[], references: string[], children: Message[], accessor: any);
+}
+type Message = LiteralMessage | ArgumentMessage | ElementMessage | ChoiceMessage | CompositeMessage;
+//#endregion
+//#region src/features/messages/convert.d.ts
+declare function convertMessageToIcu(message: Message): string;
+//#endregion
+//#region src/features/messages/hash.d.ts
+declare function generateHash(input: string, context?: string): string;
+//#endregion
+export { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, assignSequenceIdentifiers, convertMessageToIcu, generateHash };