@conformetry/cli 0.0.1

package/dist/main.module-BIsov6qb.js

@@ -0,0 +1,709 @@
+import { ConsoleLogger as e, Global as t, Injectable as n, Module as r, Scope as i } from "@nestjs/common";
+import { ConfigModule as a } from "@nestjs/config";
+import { DiscoveryModule as o } from "@nestjs/core";
+import { existsSync as s, mkdirSync as c } from "node:fs";
+import l from "node:path";
+import u from "pino";
+import { z as ee } from "zod";
+import { ALL_TEMPLATES_SELECTION as d, ConfigurationModule as f, ConfigurationService as p, InputError as m } from "@conformetry/configuration";
+import { GenerationModule as h, GenerationService as g } from "@conformetry/generation";
+import { Command as _, CommandRunner as v, Option as y } from "nest-commander";
+import { InventoryModule as b, InventoryService as x, ReportingModule as te, ReportingService as S } from "@conformetry/output";
+import { ValidationModule as C, ValidationService as w } from "@conformetry/validation";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var T = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, E = /^([A-Za-z]+)/, D = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), O = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function k(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function A(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var j, M = class extends e {
+	static {
+		j = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = j.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return j.isProduction ? j.writesToStandardError ? u({ level: e }, u.destination(2)) : u({ level: e }) : u({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: j.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (j.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		j.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (j.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...j.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = E.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || D.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = T.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && O.has(e);
+	}
+	static get root() {
+		return j.rootLogger ??= j.createRootLogger(), j.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = l.join(process.cwd(), "output");
+		return s(t) || c(t, { recursive: !0 }), l.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = j.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+M = j = A([n({ scope: i.TRANSIENT }), k("design:paramtypes", [])], M);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var N = class {};
+N = A([t(), r({
+	controllers: [],
+	exports: [M],
+	imports: [],
+	providers: [M]
+})], N);
+var P = (e) => /* @__PURE__ */ Error(`Unknown template "${e.templateName}". Available: ${e.availableTemplateNames.join(", ")}`), F = () => /* @__PURE__ */ Error("--generator was removed. Pass --template instead: it is the word the configuration, the templates command, and the conformance report already use."), I = ee.object({}), L = (e) => new m(`No template was selected. Pass --template. Available: ${e.join(", ")}`), R, z = R = class extends v {
+	configurationService;
+	generationService;
+	logger;
+	constructor(e, t, n) {
+		super(), this.configurationService = e, this.generationService = t, this.logger = n, this.logger.setContext(R.name);
+	}
+	async generate(e, t) {
+		let n = [...e, ...process.argv.slice(2)];
+		this.rejectRemovedGeneratorOption(n);
+		let r = await this.configurationService.loadConformetryConfiguration(t.config ?? "configuration/conformetry.config.ts"), i = await this.resolveTemplateName({
+			configuration: r,
+			templateName: t.template
+		});
+		this.logger.debug("🏗 Generating a conformetry instance", void 0, { template: i });
+		let a = r.find((e) => e.name === i);
+		if (a === void 0) throw this.logger.error("🚫 Rejected an unknown template", void 0, { template: i }), P({
+			availableTemplateNames: r.map((e) => e.name),
+			templateName: i
+		});
+		let o = {
+			properties: a.inputs,
+			required: Object.keys(a.inputs)
+		}, s = await this.configurationService.resolveGeneratorInputs({
+			rawArguments: n,
+			schema: o
+		}), c = await this.generationService.runGenerator({
+			definition: {
+				name: a.name,
+				templateDirectoryPath: a.templatePath
+			},
+			inputs: s,
+			instancePath: t.directory ?? `generated/${a.name}`
+		});
+		process.stdout.write(`${c.generatedFilePaths.map((e) => `  ${e}`).join("\n")}\n`), this.logger.info("✨ Generated instance files", void 0, {
+			count: c.generatedFilePaths.length,
+			outputDirectoryPath: c.outputDirectoryPath
+		});
+	}
+	rejectCommandLine(e) {
+		this.logger.error("🚫 Rejected the command line", void 0, { reason: e.message }), process.exitCode = 1;
+	}
+	rejectRemovedGeneratorOption(e) {
+		if (e.some((e) => e === "--generator" || e.startsWith("--generator="))) throw this.logger.error("🚫 Rejected a removed option", void 0, { option: "--generator" }), F();
+	}
+	async resolveTemplateName(e) {
+		if (e.templateName !== void 0) return e.templateName;
+		let t = e.configuration.map((e) => e.name);
+		if (!this.configurationService.isAtTerminal()) throw L(t);
+		let n = await this.configurationService.promptForTemplate(e.configuration);
+		if (n === void 0) throw L(t);
+		return n;
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectory(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseTemplate(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t) {
+		try {
+			await this.generate(e, t);
+		} catch (e) {
+			if (!(e instanceof m)) throw e;
+			this.rejectCommandLine(e);
+		}
+	}
+};
+A([
+	y({
+		description: "Path to the conformetry configuration file",
+		flags: "--config [path]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], z.prototype, "parseConfig", null), A([
+	y({
+		description: "Directory to write generated files into",
+		flags: "--directory [path]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], z.prototype, "parseDirectory", null), A([
+	y({
+		description: "Name of the template to render",
+		flags: "--template [name]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], z.prototype, "parseTemplate", null), z = R = A([
+	_({
+		allowUnknownOptions: !0,
+		description: "Render a template into a new instance",
+		name: "generate"
+	}),
+	n(),
+	k("design:paramtypes", [
+		p === void 0 ? Object : p,
+		g === void 0 ? Object : g,
+		M === void 0 ? Object : M
+	])
+], z);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/generate/generate.module.ts
+var B = class {};
+B = A([r({
+	controllers: [],
+	exports: [z],
+	imports: [
+		f,
+		h,
+		N
+	],
+	providers: [z]
+})], B);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/instances/instances.constants.ts
+var ne = "No instances were found. Check the instance globs in the configuration.", V = "No instance is explained by those templates.", H, U = H = class extends v {
+	configurationService;
+	inventoryService;
+	logger;
+	constructor(e, t, n) {
+		super(), this.configurationService = e, this.inventoryService = t, this.logger = n, this.logger.setContext(H.name);
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseJson() {
+		return !0;
+	}
+	parseTemplates(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	async run(e, t) {
+		this.logger.debug("📋 Listing conformetry instances", void 0, { templateFilter: t.templates });
+		let n = process.cwd(), r = await this.configurationService.loadConformetryConfiguration(t.config ?? "configuration/conformetry.config.ts"), i = this.inventoryService.shortenInstancePaths({
+			instances: this.configurationService.resolveInventoriedInstances({
+				configuration: r,
+				...t.templates === void 0 ? {} : { templateNames: t.templates },
+				workingDirectory: n
+			}),
+			workingDirectory: n
+		});
+		if (t.json === !0) {
+			console.info(JSON.stringify(i, void 0, 2));
+			return;
+		}
+		if (i.length === 0) {
+			console.info(t.templates === void 0 ? ne : V);
+			return;
+		}
+		console.info(this.inventoryService.describeInstances(i).join("\n"));
+	}
+};
+A([
+	y({
+		description: "Path to the conformetry configuration file",
+		flags: "--config [path]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], U.prototype, "parseConfig", null), A([
+	y({
+		description: "Write the listing as JSON",
+		flags: "--json"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", []),
+	k("design:returntype", Boolean)
+], U.prototype, "parseJson", null), A([
+	y({
+		description: "Comma-separated template names; report only the instances they explain",
+		flags: "--templates [names]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], U.prototype, "parseTemplates", null), U = H = A([
+	_({
+		description: "List the generated code the configuration finds, and what explains it",
+		name: "instances"
+	}),
+	n(),
+	k("design:paramtypes", [
+		p === void 0 ? Object : p,
+		x === void 0 ? Object : x,
+		M === void 0 ? Object : M
+	])
+], U);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/instances/instances.module.ts
+var W = class {};
+W = A([r({
+	controllers: [],
+	exports: [U],
+	imports: [
+		f,
+		b,
+		N
+	],
+	providers: [U]
+})], W);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/templates/templates.constants.ts
+var G = "No templates are declared in the configuration.", K = "No template explains those paths. Either they are not generated code, or they have drifted past recognition.", q, J = q = class extends v {
+	configurationService;
+	inventoryService;
+	logger;
+	constructor(e, t, n) {
+		super(), this.configurationService = e, this.inventoryService = t, this.logger = n, this.logger.setContext(q.name);
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseInstances(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseJson() {
+		return !0;
+	}
+	async run(e, t) {
+		this.logger.debug("📋 Listing conformetry templates", void 0, { instanceFilter: t.instances });
+		let n = process.cwd(), r = await this.configurationService.loadConformetryConfiguration(t.config ?? "configuration/conformetry.config.ts"), i = this.inventoryService.shortenTemplatePairings({
+			templates: this.configurationService.resolveInventoriedTemplates({
+				configuration: r,
+				...t.instances === void 0 ? {} : { instancePatterns: t.instances },
+				workingDirectory: n
+			}),
+			workingDirectory: n
+		});
+		if (t.json === !0) {
+			console.info(JSON.stringify(i, void 0, 2));
+			return;
+		}
+		if (i.length === 0) {
+			console.info(t.instances === void 0 ? G : K);
+			return;
+		}
+		console.info(this.inventoryService.describeTemplates({
+			showInstances: t.instances !== void 0,
+			templates: i
+		}).join("\n"));
+	}
+};
+A([
+	y({
+		description: "Path to the conformetry configuration file",
+		flags: "--config [path]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], J.prototype, "parseConfig", null), A([
+	y({
+		description: "Comma-separated paths or globs; report only the templates that explain them",
+		flags: "--instances [globs]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], J.prototype, "parseInstances", null), A([
+	y({
+		description: "Write the listing as JSON",
+		flags: "--json"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", []),
+	k("design:returntype", Boolean)
+], J.prototype, "parseJson", null), J = q = A([
+	_({
+		description: "Name the templates the configuration declares, or which ones explain a path",
+		name: "templates"
+	}),
+	n(),
+	k("design:paramtypes", [
+		p === void 0 ? Object : p,
+		x === void 0 ? Object : x,
+		M === void 0 ? Object : M
+	])
+], J);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/templates/templates.module.ts
+var Y = class {};
+Y = A([r({
+	controllers: [],
+	exports: [J],
+	imports: [
+		f,
+		b,
+		N
+	],
+	providers: [J]
+})], Y);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/validate/validate.command.ts
+var X, Z = X = class extends v {
+	configurationService;
+	reportingService;
+	validationService;
+	logger;
+	constructor(e, t, n, r) {
+		super(), this.configurationService = e, this.reportingService = t, this.validationService = n, this.logger = r, this.logger.setContext(X.name);
+	}
+	describeFailure(e) {
+		return `Validation failed: ${[...e.scores.filter((e) => !e.ok).map((e) => `${e.instancePath} scored ${this.reportingService.formatPercentage(e.score)} against ${e.templateName} (threshold ${this.reportingService.formatPercentage(e.threshold)})`), ...e.unmatched.length === 0 ? [] : [`${String(e.unmatched.length)} instance(s) matched no template`]].join("; ")}.`;
+	}
+	findInstances(e) {
+		return this.configurationService.readWorkspaceGroups(e.groups).flatMap((t) => this.configurationService.findInstances({
+			patterns: t.patterns ?? [],
+			...t.substitutions === void 0 ? {} : { substitutions: t.substitutions },
+			...t.threshold === void 0 ? {} : { threshold: t.threshold },
+			workingDirectory: e.workingDirectory
+		}));
+	}
+	async promptForTemplateNames(e) {
+		if (this.configurationService.isAtTerminal()) return this.configurationService.promptForTemplates(e);
+	}
+	reportEmptySelection(e) {
+		let t = e.map((e) => e.name), n = e.filter((e) => e.instances.length > 0 && this.configurationService.readWorkspaceGroups(e.instances).length === 0).map((e) => e.name);
+		process.stdout.write([
+			`No instances belong to ${t.join(", ")}, so nothing was checked.`,
+			...n.length === 0 ? [] : [`${n.join(", ")} locates instances by project tag, which this host cannot resolve. Run validation through @conformetry/nx, or pass --instances with the paths to check.`],
+			""
+		].join("\n")), this.logger.info("🫙 Validated nothing", void 0, {
+			tagScopedNames: n,
+			templateNames: t
+		});
+	}
+	reportResult(e) {
+		process.stdout.write(`${this.reportingService.formatReport({
+			fileResults: e.result.fileResults,
+			scores: e.result.scores,
+			workingDirectory: e.workingDirectory
+		})}\n`);
+		let t = e.result.scores.filter((e) => !e.ok).length, n = e.result.unmatched.length;
+		if (this.logger.info("👔 Validated conformetry instances", void 0, {
+			count: e.result.checkedPaths.length,
+			failedCount: t,
+			unmatchedCount: n
+		}), !e.result.ok) throw process.exitCode = 1, this.logger.warn("⚠️ Rejected non-conforming instances", void 0, {
+			failedCount: t,
+			unmatchedCount: n
+		}), Error(this.describeFailure(e.result));
+	}
+	selectInstances(e) {
+		let t = this.findInstances({
+			groups: (e.selectedTemplates ?? e.configuration).flatMap((e) => e.instances),
+			workingDirectory: e.workingDirectory
+		});
+		if (e.instanceGlobs === void 0) return t;
+		let n = this.findInstances({
+			groups: [{ patterns: e.instanceGlobs }],
+			workingDirectory: e.workingDirectory
+		});
+		if (e.selectedTemplates === void 0) return n;
+		let r = new Set(t.map((e) => e.path));
+		return n.filter((e) => r.has(e.path));
+	}
+	async selectTemplates(e) {
+		let t = e.templateNames ?? await this.promptForTemplateNames(e.configuration);
+		if (!(t === void 0 || t.includes(d))) return t.map((t) => {
+			let n = e.configuration.find((e) => e.name === t);
+			if (n === void 0) throw this.logger.error("🚫 Rejected an unknown template", void 0, { template: t }), P({
+				availableTemplateNames: e.configuration.map((e) => e.name),
+				templateName: t
+			});
+			return n;
+		});
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseInstances(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseLanguages(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseTemplates(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseThreshold(e) {
+		return this.configurationService.parseThresholdOption(e);
+	}
+	async run(e, t) {
+		this.logger.debug("🔍 Validating conformetry instances", void 0, { instanceFilter: t.instances });
+		let n = process.cwd(), r = await this.configurationService.loadConformetryConfiguration(t.config ?? "configuration/conformetry.config.ts"), i = await this.selectTemplates({
+			configuration: r,
+			templateNames: t.templates
+		}), a = this.selectInstances({
+			configuration: r,
+			instanceGlobs: t.instances,
+			selectedTemplates: i,
+			workingDirectory: n
+		});
+		if (i !== void 0 && a.length === 0) {
+			this.reportEmptySelection(i);
+			return;
+		}
+		let o = this.validationService.validate({
+			instances: a,
+			...t.threshold === void 0 ? {} : { threshold: t.threshold },
+			...t.languages === void 0 ? {} : { languageNames: t.languages },
+			templates: this.configurationService.collectTemplates({
+				configuration: i ?? r,
+				workingDirectory: n
+			})
+		});
+		this.reportResult({
+			result: o,
+			workingDirectory: n
+		});
+	}
+};
+A([
+	y({
+		description: "Path to the conformetry configuration file",
+		flags: "--config [path]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], Z.prototype, "parseConfig", null), A([
+	y({
+		description: "Comma-separated glob patterns to validate, overriding the configuration",
+		flags: "--instances [globs]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], Z.prototype, "parseInstances", null), A([
+	y({
+		description: "Comma-separated language names to run",
+		flags: "--languages [languages]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], Z.prototype, "parseLanguages", null), A([
+	y({
+		description: `Comma-separated template names to validate, or "${d}" for every one`,
+		flags: "--templates [names]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], Z.prototype, "parseTemplates", null), A([
+	y({
+		description: "Lowest conformance score an instance may have, from 0 to 1. Overridden by a generator's own threshold and by an instance group's",
+		flags: "--threshold [ratio]"
+	}),
+	k("design:type", Function),
+	k("design:paramtypes", [Object]),
+	k("design:returntype", Object)
+], Z.prototype, "parseThreshold", null), Z = X = A([
+	_({
+		description: "Measure instances against their templates and report every difference",
+		name: "validate"
+	}),
+	n(),
+	k("design:paramtypes", [
+		p === void 0 ? Object : p,
+		S === void 0 ? Object : S,
+		w === void 0 ? Object : w,
+		M === void 0 ? Object : M
+	])
+], Z);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/modules/validate/validate.module.ts
+var Q = class {};
+Q = A([r({
+	controllers: [],
+	exports: [Z],
+	imports: [
+		f,
+		N,
+		te,
+		C
+	],
+	providers: [Z]
+})], Q);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-cli/src/main.module.ts
+var $ = class {};
+$ = A([r({ imports: [
+	a.forRoot({
+		envFilePath: ".env",
+		isGlobal: !0,
+		validate: (e) => I.parse(e)
+	}),
+	o,
+	N,
+	B,
+	W,
+	Y,
+	Q
+] })], $);
+//#endregion
+export { J as a, B as c, Y as i, z as l, Q as n, W as o, Z as r, U as s, $ as t, M as u };