@ahoo-wang/wow-generator 9.2.0-rc.0

package/dist/codeGenerator-kyY9eLML.js

@@ -0,0 +1,2583 @@
+import { CodeBlockWriter as e, IndentationText as t, Node as n, Project as r, QuoteKind as i, Scope as a, StructureKind as o, SyntaxKind as s, VariableDeclarationKind as c, ts as l } from "ts-morph";
+import { isAbsolute as u, join as d, relative as f, resolve as p, sep as m } from "path";
+import { parse as ee } from "yaml";
+import { readFile as te } from "fs";
+//#region src/api/configuration.ts
+var h = "./wow-generator.config.json", ne = {
+	success: 0,
+	internal: 1,
+	input: 2,
+	configuration: 3,
+	specification: 4,
+	output: 5,
+	interrupted: 130
+}, g = class extends Error {
+	kind;
+	constructor(e, t, n) {
+		super(t, n), this.kind = e, this.name = "GeneratorError";
+	}
+	get exitCode() {
+		return ne[this.kind];
+	}
+};
+function _(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+//#endregion
+//#region src/api/logger.ts
+function re() {
+	return !!process.stdout?.isTTY && !process.env.NO_COLOR;
+}
+var ie = class {
+	level;
+	decorate;
+	constructor(e = {}) {
+		this.level = e.level ?? "normal", this.decorate = e.decorate ?? re();
+	}
+	format(e, t, n) {
+		let r = this.decorate ? `${e} ` : t ? `${t}: ` : "";
+		return `${this.level === "verbose" ? `[${(/* @__PURE__ */ new Date()).toTimeString().slice(0, 8)}] ` : ""}${r}${n}`;
+	}
+	debug(e, ...t) {
+		this.level === "verbose" && console.log(this.format("ℹ️ ", "", e), ...t);
+	}
+	info(e, ...t) {
+		this.level !== "quiet" && console.log(this.format("✅", "", e), ...t);
+	}
+	warn(e, ...t) {
+		console.warn(this.format("⚠️ ", "warning", e), ...t);
+	}
+	error(e, ...t) {
+		console.error(this.format("❌", "error", e), ...t);
+	}
+}, ae = class {
+	debug() {}
+	info() {}
+	warn() {}
+	error() {}
+}, oe = /[^\p{L}\p{N}$]+/u, se = /* @__PURE__ */ new Set(/* @__PURE__ */ "arguments.await.break.case.catch.class.const.continue.debugger.default.delete.do.else.enum.eval.export.extends.false.finally.for.function.if.implements.import.in.instanceof.interface.let.new.null.package.private.protected.public.return.static.super.switch.this.throw.true.try.typeof.var.void.while.with.yield".split("."));
+function v(e) {
+	return /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/u.test(e) && !se.has(e);
+}
+function ce(e) {
+	return /^\p{N}/u.test(e) ? `_${e}` : e;
+}
+function le(e) {
+	if (v(e)) return e;
+	let t = ce(y(e) || "_");
+	return se.has(t) ? `${t}_` : t;
+}
+function ue(e) {
+	return /^\p{Lu}[\p{L}\p{N}$]*$/u.test(e) && v(e);
+}
+function de(e) {
+	return ce((Array.isArray(e) ? e : [e]).map((e) => ue(e) ? e : he(e)).join("") || "_");
+}
+function fe(e) {
+	return e.split(oe);
+}
+function pe(e) {
+	return Array.isArray(e) ? e.flatMap((e) => me(fe(e))) : me(fe(e));
+}
+function me(e) {
+	return e.flatMap((e) => {
+		if (e.length === 0) return [];
+		let t = [], n = "";
+		for (let r = 0; r < e.length; r++) {
+			let i = e[r], a = /[A-Z]/.test(i), o = r > 0 && /[a-z]/.test(e[r - 1]);
+			a && o && n ? (t.push(n), n = i) : n += i;
+		}
+		return n && t.push(n), t;
+	});
+}
+function he(e) {
+	return e === "" || e.length === 0 ? "" : pe(e).filter((e) => e.length > 0).map((e) => {
+		let t = e.charAt(0), n = e.slice(1);
+		return (/[a-zA-Z]/.test(t) ? t.toUpperCase() : t) + n.toLowerCase();
+	}).join("");
+}
+function y(e) {
+	let t = he(e);
+	return t.charAt(0).toLowerCase() + t.slice(1);
+}
+function ge(e) {
+	return e === "" || Array.isArray(e) && e.length === 0 ? "" : pe(e).filter((e) => e.length > 0).map((e) => e.toUpperCase()).join("_");
+}
+function b(e) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(e) ? e : x(e);
+}
+function _e(e) {
+	return /^\d+$/.test(e) ? `NUM_${e}` : ge(e) || e;
+}
+function x(e) {
+	return `'${JSON.stringify(e).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+//#endregion
+//#region src/naming/order.ts
+var ve = new Intl.Collator("en-US");
+function S(e, t) {
+	return ve.compare(e, t);
+}
+//#endregion
+//#region src/openapi/references.ts
+function C(e) {
+	return !!(e && typeof e == "object" && "$ref" in e);
+}
+function ye(e, t) {
+	let n = t.slice(1);
+	try {
+		n = decodeURIComponent(n);
+	} catch {}
+	if (n === "") return e;
+	let r = e;
+	for (let e of n.slice(1).split("/")) {
+		if (typeof r != "object" || !r) return;
+		let t = e.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (!Object.hasOwn(r, t)) return;
+		r = r[t];
+	}
+	return r;
+}
+function be(e) {
+	let t = [], n = /* @__PURE__ */ new Set(), r = (i, a) => {
+		if (typeof i != "object" || !i || n.has(i)) return;
+		if (n.add(i), Array.isArray(i)) {
+			i.forEach((e, t) => r(e, `${a}/${t}`));
+			return;
+		}
+		let o = i.$ref;
+		typeof o == "string" && o.startsWith("#/components/") && ye(e, o) === void 0 && t.push({
+			ref: o,
+			location: a || "/"
+		});
+		for (let [e, t] of Object.entries(i)) r(t, `${a}/${e.replace(/~/g, "~0").replace(/\//g, "~1")}`);
+	};
+	return r(e, ""), t;
+}
+//#endregion
+//#region src/openapi/components.ts
+var w = "#/components/", xe = `${w}parameters/`, Se = `${w}requestBodies/`, T = `${w}responses/`, Ce = `${w}schemas/`;
+function we(e) {
+	return e.$ref.split("/").pop();
+}
+function E(e, t, n) {
+	let r = /* @__PURE__ */ new Set(), i = e;
+	for (; C(i);) {
+		if (!i.$ref.startsWith(n)) return;
+		if (r.has(i.$ref)) throw new g("specification", `Cyclic component reference: ${i.$ref}`);
+		r.add(i.$ref), i = t?.[i.$ref.slice(n.length)];
+	}
+	return i;
+}
+function D(e, t) {
+	return E(e, t.schemas, Ce);
+}
+function Te(e, t) {
+	return E(e, t.responses, T);
+}
+function Ee(e, t) {
+	return E(e, t.requestBodies, Se);
+}
+function De(e, t) {
+	return E(e, t.parameters, xe);
+}
+function O(e, t) {
+	return {
+		key: we(e),
+		schema: D(e, t)
+	};
+}
+//#endregion
+//#region src/openapi/responses.ts
+var k = "application/json", Oe = "text/event-stream";
+function A(e) {
+	return e.split(";")[0].trim().toLowerCase();
+}
+function ke(e) {
+	let t = A(e);
+	return t === "application/json" || /^application\/[^/]+\+json$/.test(t);
+}
+function Ae(e) {
+	let t = A(e);
+	return t.startsWith("text/") && t !== "text/event-stream";
+}
+function j(e, t, n = (e) => A(e) === t) {
+	if (!e) return;
+	if (e[t]) return e[t];
+	let r = Object.keys(e).find(n);
+	return r === void 0 ? void 0 : e[r];
+}
+function je(e, t) {
+	if (t && !C(t)) return j(t.content, e)?.schema;
+}
+function Me(e) {
+	if (e && !C(e)) return j(e.content, k, ke)?.schema;
+}
+function Ne(e) {
+	return je(Oe, e);
+}
+function Pe(e) {
+	return je("*/*", e);
+}
+function Fe(e) {
+	return !e || C(e) ? !1 : Object.keys(e.content ?? {}).some(Ae);
+}
+//#endregion
+//#region src/openapi/schemas.ts
+var Ie = [
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+];
+function Le(e) {
+	return Array.isArray(e) ? !0 : Ie.includes(e);
+}
+function M(e) {
+	return Array.isArray(e.enum) && e.enum.length > 0;
+}
+var Re = "x-enum-text";
+function ze(e) {
+	return e[Re];
+}
+function Be(e) {
+	return e.type === "object" && !!e.properties;
+}
+function Ve(e) {
+	return e.type === "array" && !!e.items;
+}
+function He(e) {
+	return Array.isArray(e.anyOf) && e.anyOf.length > 0;
+}
+function Ue(e) {
+	return Array.isArray(e.oneOf) && e.oneOf.length > 0;
+}
+function We(e) {
+	return Array.isArray(e.allOf) && e.allOf.length > 0;
+}
+function N(e) {
+	return He(e) || Ue(e) || We(e);
+}
+function Ge(e) {
+	return e.includes("|") || e.includes("&") ? `(${e})[]` : `${e}[]`;
+}
+function Ke(e) {
+	return e.type === "object" && !e.properties && e.additionalProperties !== void 0;
+}
+var qe = "x-map-key-schema";
+function Je(e) {
+	return e[qe];
+}
+function Ye(e) {
+	return e.type === "object" ? !e.properties || Object.keys(e.properties).length === 0 : !1;
+}
+function Xe(e) {
+	return e.readOnly === !0;
+}
+function P(e) {
+	if (Array.isArray(e)) return e.map((e) => P(e)).join(" | ");
+	switch (e) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		default: return "any";
+	}
+}
+function Ze(e, t) {
+	let n = [], r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), a = !1, o = (e) => {
+		if (!(!e || i.has(e) || a)) {
+			if (i.add(e), C(e)) {
+				o(t && D(e, t));
+				return;
+			}
+			if (e.nullable || Array.isArray(e.type)) {
+				a = !0;
+				return;
+			}
+			for (let t of e.required ?? []) r.add(t);
+			for (let t of Object.keys(e.properties ?? {})) n.includes(t) || n.push(t);
+			e.allOf?.forEach(o);
+		}
+	};
+	return o(e), a ? [] : n.filter((e) => !r.has(e));
+}
+//#endregion
+//#region src/openapi/operations.ts
+function Qe(e, t) {
+	return e.operation.operationId && t.operation.operationId ? S(e.operation.operationId, t.operation.operationId) : e.path && t.path ? S(e.path, t.path) : e.method && t.method ? S(e.method, t.method) : 0;
+}
+function $e(e, t, n) {
+	let r = /* @__PURE__ */ new Map();
+	for (let i of [...e, ...t]) {
+		let e = C(i) ? n && De(i, n) : i, t = e ? `${e.in}:${e.name}` : i.$ref;
+		r.set(t, i);
+	}
+	return [...r.values()];
+}
+function et(e, t) {
+	let n = [];
+	for (let [r, i] of Object.entries(e)) tt(i).forEach((e) => {
+		n.push({
+			method: e.method,
+			operation: i.parameters?.length ? {
+				...e.operation,
+				parameters: $e(i.parameters, e.operation.parameters ?? [], t)
+			} : e.operation,
+			path: r
+		});
+	});
+	return n.sort(Qe);
+}
+function tt(e) {
+	return [
+		{
+			method: "get",
+			operation: e.get
+		},
+		{
+			method: "put",
+			operation: e.put
+		},
+		{
+			method: "post",
+			operation: e.post
+		},
+		{
+			method: "delete",
+			operation: e.delete
+		},
+		{
+			method: "options",
+			operation: e.options
+		},
+		{
+			method: "head",
+			operation: e.head
+		},
+		{
+			method: "patch",
+			operation: e.patch
+		},
+		{
+			method: "trace",
+			operation: e.trace
+		}
+	].filter(({ operation: e }) => e !== void 0);
+}
+function nt(e) {
+	let t = Object.keys(e.responses ?? {});
+	if (t.includes("200")) return "200";
+	let n = t.filter((e) => /^2\d\d$/.test(e)).sort();
+	return n.length > 0 ? n[0] : t.find((e) => e.toUpperCase() === "2XX");
+}
+function F(e, t) {
+	let n = nt(e), r = n ? e.responses[n] : void 0;
+	return t && C(r) ? Te(r, t) : r;
+}
+function rt(e, t) {
+	return Me(F(e, t));
+}
+function it(e, t) {
+	return (e.parameters ?? []).map((e) => C(e) ? De(e, t) : e).filter((e) => e !== void 0);
+}
+function at(e, t) {
+	return e.parameters ? e.parameters.map((e) => C(e) ? De(e, t) : e).filter((e) => e?.in === "path") : [];
+}
+function ot(e, t) {
+	let n = (t) => {
+		let n = e.indexOf(`{${t.name}}`);
+		return n < 0 ? 2 ** 53 - 1 : n;
+	};
+	return [...t].sort((e, t) => n(e) - n(t));
+}
+var st = "string";
+function ct(e) {
+	return !e.schema || C(e.schema) || !e.schema.type || !Le(e.schema.type) ? st : P(e.schema.type);
+}
+//#endregion
+//#region src/wow/conventions.ts
+var lt = "8.10", ut = "x-wow-context-alias";
+function dt(e) {
+	return e.info[ut];
+}
+function ft(e) {
+	let t = e.split(".");
+	return t.length != 2 || t[0].length === 0 || t[1].length === 0 ? null : t;
+}
+function pt(e) {
+	let t = ft(e.name);
+	return t ? {
+		tag: e,
+		contextAlias: t[0],
+		aggregateName: t[1]
+	} : null;
+}
+function mt(e) {
+	if (!e) return null;
+	let t = e.split(".");
+	return t.length == 3 ? t[2] : null;
+}
+var ht = ".snapshot_state.single", gt = ".snapshot.count", _t = "x-wow-query-fields", vt = /^(?:\/tenant\/\{tenantId\})?(?:\/owner\/\{ownerId\})?\/(.+?)\/snapshot(?:\/|$)/, yt = [
+	"MaterializedSnapshot",
+	"MaterializedSnapshotPagedList",
+	"MaterializedSnapshotCursorPage",
+	"MaterializedSnapshotServerSentEventNonNullData",
+	"PagedList",
+	"ServerSentEventNonNullData",
+	"Snapshot",
+	"StateEvent"
+];
+function bt(e) {
+	return yt.map((t) => e + t);
+}
+function xt(e, t, n) {
+	return e !== "wow.api.query.PagedList" && e.startsWith("wow.api.query.") && e.endsWith("PagedList") || e.startsWith("wow.api.query.Operator") && e.endsWith("Map") ? !1 : e.startsWith("wow.") || e.endsWith("AggregatedCondition") || e.endsWith("AggregatedDomainEventStream") || e.endsWith("AggregatedDomainEventStreamPagedList") || e.endsWith("AggregatedDomainEventStreamCursorPage") || e.endsWith("AggregatedDomainEventStreamServerSentEventNonNullData") || e.endsWith("AggregatedListQuery") || e.endsWith("AggregatedPagedQuery") || e.endsWith("AggregatedSingleQuery") ? !0 : n.has(t());
+}
+var I = "@ahoo-wang/wow-client", St = "@ahoo-wang/wow-client/legacy", Ct = /* @__PURE__ */ new Set([
+	"Condition",
+	"ConditionOptions",
+	"ListQuery",
+	"Operator",
+	"PagedQuery"
+]), wt = {
+	"wow.command.CommandResult": "CommandResult",
+	"wow.command.CommandResultArray": "CommandResultArray",
+	"wow.MessageHeaderSqlType": "MessageHeaderSqlType",
+	"wow.api.BindingError": "BindingError",
+	"wow.api.DefaultErrorInfo": "ErrorInfo",
+	"wow.api.RecoverableType": "RecoverableType",
+	"wow.api.command.DefaultDeleteAggregate": "DeleteAggregate",
+	"wow.api.command.DefaultRecoverAggregate": "RecoverAggregate",
+	"wow.api.abac.DefaultApplyResourceTags": "ApplyResourceTags",
+	"wow.api.messaging.FunctionInfoData": "FunctionInfo",
+	"wow.api.messaging.FunctionKind": "FunctionKind",
+	"wow.api.modeling.AggregateId": "AggregateId",
+	"wow.api.query.Condition": "Condition",
+	"wow.api.query.ConditionOptions": "ConditionOptions",
+	"wow.api.query.ListQuery": "ListQuery",
+	"wow.api.query.Operator": "Operator",
+	"wow.api.query.PagedQuery": "PagedQuery",
+	"wow.api.query.Pagination": "Pagination",
+	"wow.api.query.Projection": "Projection",
+	"wow.api.query.Sort": "FieldSort",
+	"wow.api.query.Sort.Direction": "SortDirection",
+	"wow.api.query.DynamicDocument": "DynamicDocument",
+	"wow.api.query.DynamicDocumentArray": "DynamicDocumentArray",
+	"wow.command.CommandStage": "CommandStage",
+	"wow.command.SimpleWaitSignal": "WaitSignal",
+	"wow.configuration.Aggregate": "Aggregate",
+	"wow.configuration.BoundedContext": "BoundedContext",
+	"wow.configuration.WowMetadata": "WowMetadata",
+	"wow.modeling.DomainEvent": "DomainEvent",
+	"wow.openapi.BatchResult": "BatchResult",
+	"wow.messaging.CompensationTarget": "CompensationTarget"
+};
+function Tt(e, t) {
+	let n = wt[e];
+	if (t && "filter" in t && (e === "wow.api.query.ListQuery" ? n = "FilterListQuery" : e === "wow.api.query.PagedQuery" && (n = "FilterPagedQuery")), n) return {
+		name: n,
+		path: Ct.has(n) ? St : I
+	};
+}
+var Et = /* @__PURE__ */ new Set(["wow", "Actuator"]), Dt = ["tenantId", "ownerId"];
+function Ot(e) {
+	let t = 0, n = 0;
+	return e.commands.forEach((e) => {
+		e.path.startsWith("/tenant/{tenantId}") && (t += 1), e.path.startsWith("/owner/{ownerId}") && (n += 1);
+	}), t === 0 && n === 0 ? "ResourceAttributionPathSpec.NONE" : t > n ? "ResourceAttributionPathSpec.TENANT" : "ResourceAttributionPathSpec.OWNER";
+}
+//#endregion
+//#region src/analysis/clientNames.ts
+function kt(e, t) {
+	return `${e.contextAlias}/${e.aggregateName}/${t}.ts`;
+}
+function L(e, t) {
+	return `${de(e.aggregateName)}${t}`;
+}
+var At = "x-fetcher-method";
+function jt(e, t) {
+	let n = t ?? e["x-fetcher-method"];
+	if (n !== void 0) {
+		if (typeof n != "string" || !Mt(n)) throw new g("specification", `${At} of ${e.operationId ?? "an operation"} is ${JSON.stringify(n)}, which is not a valid method name.`);
+		return n;
+	}
+	if (!e.operationId) return;
+	let r = y(e.operationId.split(".").pop()) || "_";
+	return /^\p{N}/u.test(r) ? `_${r}` : r;
+}
+function Mt(e) {
+	return v(e) || /^[a-z]+$/.test(e);
+}
+function Nt(e, t) {
+	let n = le(e), r = n;
+	for (let e = 2; t.has(r); e++) r = `${n}${e}`;
+	return t.add(r), r;
+}
+//#endregion
+//#region src/analysis/modelInfo.ts
+function R(e, t) {
+	if (!e) return {
+		name: "",
+		path: "/"
+	};
+	let n = Tt(e, t?.properties);
+	if (n) return n;
+	let r = e.split("."), i = -1;
+	for (let e = 0; e < r.length; e++) if (r[e] && /^[A-Z]/.test(r[e])) {
+		i = e;
+		break;
+	}
+	let a = r.slice(0, i), o = a.length > 0 ? `/${a.join("/")}` : "/";
+	return {
+		name: de(r.slice(i)),
+		path: o
+	};
+}
+function Pt(e, t) {
+	if (!e.$ref.startsWith(Ce)) throw new g("specification", `Unsupported schema reference: ${e.$ref}. Bundle or inline external schemas before generation.`);
+	return R(we(e), t ? D(e, t) : void 0);
+}
+function z(e) {
+	let t = `${ge(e)}_BOUNDED_CONTEXT_ALIAS`;
+	return /^\p{N}/u.test(t) ? `_${t}` : t;
+}
+//#endregion
+//#region src/analysis/aggregates.ts
+var Ft = "Command";
+function It(e, t) {
+	return [...t.contexts.values()].flatMap((t) => [...t].map((t) => Lt(e, t)));
+}
+function Lt(e, t) {
+	let { contextAlias: n, aggregateName: r } = t.aggregate;
+	return {
+		contextAlias: n,
+		aggregateName: r,
+		context: {
+			alias: n,
+			constantName: z(n)
+		},
+		commandClient: Rt(e, t),
+		queryClient: Ut(t)
+	};
+}
+function Rt(e, t) {
+	let n = t.aggregate, r = Vt(t);
+	return {
+		file: kt(n, "commandClient"),
+		endpointPathsName: L(n, "CommandEndpointPaths"),
+		className: L(n, "CommandClient"),
+		streamClassName: L(n, "StreamCommandClient"),
+		commands: [...t.commands.values()].map((t) => {
+			let n = R(t.schema.key), i = /* @__PURE__ */ new Set(["commandRequest", "attributes"]);
+			return {
+				path: t.path,
+				endpointMember: r.get(t),
+				httpMethod: t.method,
+				methodName: Ht(t),
+				typeName: zt(n),
+				body: n,
+				bodyKey: t.schema.key,
+				optionalFields: Ze(t.schema.schema, e.components),
+				requestOptional: Ye(t.schema.schema),
+				pathParameters: ot(t.path, t.pathParameters).filter((e) => !Dt.includes(e.name)).map((e) => ({
+					name: Nt(e.name, i),
+					pathName: e.name,
+					type: ct(e)
+				})),
+				docs: [
+					t.summary,
+					t.description,
+					`- operationId: \`${t.operation.operationId}\``,
+					`- path: \`${t.path}\``
+				]
+			};
+		})
+	};
+}
+function zt(e) {
+	return e.path === "@ahoo-wang/wow-client" ? `${e.name}Command` : e.name.endsWith(Ft) ? void 0 : `${e.name}${Ft}`;
+}
+function Bt(e, t) {
+	for (let n of e) {
+		let e = `/${n.contextAlias}/${n.aggregateName}`, r = /* @__PURE__ */ new Map();
+		for (let n of t) n.info.path === e && r.set(n.info.name, {
+			holder: `the model of schema ${n.key}`,
+			key: n.key
+		});
+		for (let { body: e, bodyKey: t } of n.commandClient.commands) e.path !== "@ahoo-wang/wow-client" && r.set(e.name, {
+			holder: `the model of schema ${t}`,
+			key: t
+		});
+		for (let e of n.commandClient.commands) {
+			let { typeName: t, bodyKey: i } = e;
+			if (t === void 0 || e.body.path === "@ahoo-wang/wow-client") continue;
+			let a = r.get(t);
+			if (a !== void 0 && a.bodyKey !== i) throw new g("specification", `Command ${e.methodName}() of aggregate ${n.contextAlias}.${n.aggregateName} generates the type ${t} for its body ${i}, but ${a.holder} already has that name. Rename the schema ${i} or ${a.key} in the document.`);
+			r.set(t, {
+				holder: `the type of command ${e.methodName}()`,
+				key: i,
+				bodyKey: i
+			});
+		}
+	}
+}
+function Vt(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+	for (let r of e.commands.values()) {
+		let e = r.name.toUpperCase().replace(/[^\p{L}\p{N}_$]/gu, "_");
+		(!e || /^\p{N}/u.test(e)) && (e = `_${e}`);
+		let i = e;
+		for (let t = 2; n.has(i); t++) i = `${e}_${t}`;
+		n.add(i), t.set(r, i);
+	}
+	return t;
+}
+function Ht(e) {
+	let t = y(e.name) || "_";
+	return /^\p{N}/u.test(t) ? `_${t}` : t;
+}
+function Ut(e) {
+	let t = e.aggregate, n = y(t.aggregateName) || "_";
+	return {
+		file: kt(t, "queryClient"),
+		resourceName: e.resourceName,
+		resourceAttribution: Ot(e),
+		state: R(e.state.key),
+		fields: R(e.fields.key),
+		eventTitlesName: L(t, "DomainEventTypeMapTitle"),
+		eventTypeName: L(t, "DomainEventType"),
+		events: [...e.events.values()].map((e) => ({
+			memberName: b(e.name),
+			title: e.title,
+			body: R(e.schema.key)
+		})),
+		factoryName: `${/^\p{N}/u.test(n) ? "_" : ""}${n}QueryClientFactory`
+	};
+}
+//#endregion
+//#region src/naming/paths.ts
+function B(e, t) {
+	return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(t) ? t : t ? `${e.replace(/\/+$/, "")}/${t.replace(/^\/+/, "")}` : e;
+}
+var Wt = "types.ts";
+function Gt(e) {
+	return B(e.path, Wt);
+}
+function Kt(e) {
+	return `${e}/boundedContext.ts`;
+}
+//#endregion
+//#region src/wow/model.ts
+function qt(e) {
+	return e.contextAlias !== void 0 || e.aggregateTags.size > 0;
+}
+function Jt(e, t) {
+	return t ? {
+		...e,
+		...t
+	} : e;
+}
+//#endregion
+//#region src/analysis/apiClients.ts
+var Yt = ["httpRequest", "attributes"];
+function Xt(e, t, n, r) {
+	return new Zt(e, t, n, r).clients();
+}
+var Zt = class {
+	document;
+	wow;
+	config;
+	warnings;
+	basePath;
+	wowDocument;
+	constructor(e, t, n, r) {
+		this.document = e, this.wow = t, this.config = n, this.warnings = r, this.wowDocument = qt(t), t.contextAlias && (this.basePath = {
+			alias: t.contextAlias,
+			constantName: z(t.contextAlias)
+		});
+	}
+	clients() {
+		let e = this.tags(), t = this.groupOperations(e), n = /* @__PURE__ */ new Map();
+		return [...t.keys()].sort().map((r) => {
+			let i = R(r), a = i;
+			for (let e = 2; n.has(V(a)); e++) a = {
+				...i,
+				name: `${i.name}${e}`
+			};
+			return a !== i && this.warnings.push(`Tags ${n.get(V(i))} and ${r} both name the API client ${i.name}ApiClient; ${r} generates ${a.name}ApiClient.`), n.set(V(a), r), this.client(e.get(r), a, [...t.get(r)]);
+		});
+	}
+	client(e, t, n) {
+		let r = `${t.name}ApiClient`, i = t.path;
+		this.wow.contextAlias && (i = B(this.wow.contextAlias, i)), i = B(i, Qt(r));
+		let a = /* @__PURE__ */ new Map();
+		return {
+			tagName: e.name,
+			className: r,
+			file: i,
+			description: e.description,
+			basePath: this.basePath,
+			methods: n.map((t) => this.method(e, r, t, a))
+		};
+	}
+	method(e, t, n, r) {
+		let { operation: i } = n, a = this.methodName(e, t, n, r), o = new Set(Yt), s = this.parameters(e, n, o), c = this.body(i, o), l = [...s.filter(({ parameter: e }) => e.required), ...s.filter(({ parameter: e }) => !e.required)].filter(({ description: e }) => e);
+		return {
+			name: a,
+			httpMethod: n.method,
+			path: n.path,
+			parameters: s.map(({ parameter: e }) => e),
+			body: c,
+			returns: this.returns(i),
+			docs: [
+				i.summary,
+				i.description,
+				`- operationId: \`${i.operationId}\``,
+				`- path: \`${n.path}\``,
+				...l.map(({ parameter: e, description: t }) => `@param ${e.name} - ${t.replace(/\s*\n\s*/g, " ")}`)
+			]
+		};
+	}
+	methodName(e, t, n, r) {
+		let i = n.operation.operationId, a = jt(n.operation, this.config.apiClients?.[e.name]?.methodNames?.[i]), o = r.get(a);
+		if (o !== void 0) throw new g("specification", `Operations ${o} and ${i} of tag ${e.name} both generate the method ${t}.${a}(). Name one of them with apiClients["${e.name}"].methodNames in the generator configuration, or with the x-fetcher-method extension.`);
+		return r.set(a, i), a;
+	}
+	parameters(e, t, n) {
+		let r = it(t.operation, this.document.components ?? {}), i = [];
+		for (let a of [
+			"path",
+			"query",
+			"header"
+		]) {
+			let o = r.filter((e) => e.in === a);
+			for (let r of a === "path" ? ot(t.path, o) : o) a === "path" && this.ignoresPathParameter(e.name, r.name) || i.push({
+				parameter: {
+					name: Nt(r.name, n),
+					location: a,
+					parameterName: r.name,
+					schema: r.schema,
+					required: a === "path" || r.required === !0
+				},
+				description: r.description
+			});
+		}
+		let a = r.filter((e) => e.in === "cookie");
+		return a.length > 0 && this.warnings.push(`${t.method.toUpperCase()} ${t.path} leaves out its cookie parameter(s) ${a.map((e) => e.name).join(", ")}: the browser sends cookies, and fetch cannot set them.`), i;
+	}
+	ignoresPathParameter(e, t) {
+		return (this.config.apiClients?.[e]?.ignorePathParameters ?? (this.wowDocument ? Dt : [])).includes(t);
+	}
+	body(e, t) {
+		if (!e.requestBody) return;
+		let n = C(e.requestBody) ? Ee(e.requestBody, this.document.components) : e.requestBody;
+		if (!n) return;
+		let r = n.required === !0, i = n.content ?? {}, a = j(i, k, ke), o = Nt("body", t);
+		return a?.schema ? {
+			name: o,
+			required: r,
+			content: {
+				kind: "json",
+				schema: a.schema,
+				optionalFields: Ze(a.schema, this.document.components)
+			}
+		} : j(i, "multipart/form-data") ? {
+			name: o,
+			required: r,
+			content: { kind: "formData" }
+		} : j(i, "application/x-www-form-urlencoded") ? {
+			name: o,
+			required: r,
+			content: { kind: "urlEncoded" }
+		} : Object.keys(i).some(Ae) ? {
+			name: o,
+			required: r,
+			content: { kind: "text" }
+		} : {
+			name: o,
+			required: r,
+			content: { kind: "binary" }
+		};
+	}
+	returns(e) {
+		let t = F(e, this.document.components);
+		if (!t) return { kind: "response" };
+		let n = Me(t), r = n || Pe(t);
+		if (r) return {
+			kind: "json",
+			schema: r,
+			wildcard: !n
+		};
+		let i = Ne(t);
+		if (i) {
+			if (C(i)) {
+				let e = D(i, this.document.components);
+				if (Ve(e) && C(e.items)) {
+					let t = Pt(e.items, this.document.components);
+					return {
+						kind: "eventStream",
+						items: e.items,
+						serverSentEvent: t.name.includes("ServerSentEvent")
+					};
+				}
+			}
+			return {
+				kind: "eventStream",
+				serverSentEvent: !1
+			};
+		}
+		return Fe(t) ? { kind: "text" } : { kind: "response" };
+	}
+	groupOperations(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of this.document.endpoints) {
+			let r = `${n.method.toUpperCase()} ${n.path}`, i = n.operation.tags ?? [];
+			if (i.length === 0) {
+				this.warnings.push(`Skipping ${r}: it has no tag, and the tag names its API client.`);
+				continue;
+			}
+			let a = i.filter((t) => e.has(t));
+			if (!(a.length < i.length)) {
+				if (!n.operation.operationId) {
+					this.warnings.push(`Skipping ${r}: it has no operationId, and the operationId names its method.`);
+					continue;
+				}
+				for (let e of a) t.has(e) || t.set(e, /* @__PURE__ */ new Set()), t.get(e).add(n);
+			}
+		}
+		return t;
+	}
+	tags() {
+		let e = /* @__PURE__ */ new Map();
+		for (let { operation: t } of this.document.endpoints) t.tags?.forEach((t) => {
+			!this.ignoresTag(t) && !e.has(t) && e.set(t, {
+				name: t,
+				description: ""
+			});
+		});
+		return this.document.openAPI.tags?.forEach((t) => {
+			this.ignoresTag(t.name) || e.set(t.name, t);
+		}), e;
+	}
+	ignoresTag(e) {
+		return Et.has(e) || this.wow.aggregateTags.has(e);
+	}
+};
+function Qt(e) {
+	return `${e.charAt(0).toLowerCase()}${e.slice(1)}.ts`;
+}
+function V(e) {
+	return `${e.path}/${e.name}`.toLowerCase();
+}
+//#endregion
+//#region src/analysis/models.ts
+function $t(e) {
+	let t = new Set(e.contexts.keys());
+	return e.contextAlias && t.add(e.contextAlias), [...t].sort().map((e) => ({
+		alias: e,
+		constantName: z(e),
+		file: Kt(e)
+	}));
+}
+function en(e, t) {
+	let n = e.components?.schemas;
+	if (!n) return [];
+	let r = nn(t), i = tn(e, t), a = Object.keys(n).filter((e) => !xt(e, () => R(e).name, r) || !e.startsWith("wow.") && i.has(e));
+	rn(a);
+	let o = an(t);
+	return a.map((e) => {
+		let r = n[e], i = R(e);
+		return {
+			key: e,
+			info: i,
+			file: Gt(i),
+			schema: r,
+			docSchema: Jt(r, t.schemaDocOverrides.get(e)),
+			emptyMessageBody: o.has(e) && on(r)
+		};
+	});
+}
+function tn(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), i = e.components ?? {}, a = (e) => {
+		if (typeof e != "object" || !e || r.has(e)) return;
+		if (r.add(e), Array.isArray(e)) {
+			e.forEach(a);
+			return;
+		}
+		let { $ref: t } = e;
+		if (typeof t == "string" && t.startsWith("#/components/")) {
+			let [e, ...r] = t.slice(w.length).split("/"), o = r.join("/");
+			e === "schemas" && n.add(o), a(i[e]?.[o]);
+		}
+		Object.values(e).forEach(a);
+	};
+	for (let { operation: n } of e.endpoints) {
+		let e = n.tags ?? [];
+		e.length > 0 && e.every((e) => !Et.has(e) && !t.aggregateTags.has(e)) && a(n);
+	}
+	return n;
+}
+function nn(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.contexts.values()) for (let e of n) bt(R(e.state.key).name).forEach((e) => t.add(e));
+	return t;
+}
+function rn(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = R(n), r = `${e.path === "/" ? "" : e.path}/${e.name}`;
+		t.set(r, [...t.get(r) ?? [], n]);
+	}
+	let n = [...t].filter(([, e]) => e.length > 1);
+	if (n.length !== 0) throw new g("specification", `Schemas generate the same model: ${n.map(([e, t]) => `${t.join(", ")} → ${e}`).join("; ")}. Rename all but one of them in the document.`);
+}
+function an(e) {
+	return new Set([...e.contexts.values()].flatMap((e) => [...e].flatMap((e) => [...[...e.commands.values()].map((e) => e.schema.key), ...[...e.events.values()].map((e) => e.schema.key)])));
+}
+function on(e) {
+	return !C(e) && e.type === "object" && Object.keys(e.properties ?? {}).length === 0 && (e.additionalProperties === void 0 || e.additionalProperties === !1) && !e.required?.length && !N(e) && e.enum === void 0 && e.const === void 0;
+}
+//#endregion
+//#region src/analysis/analyze.ts
+function sn(e, t, n) {
+	let r = [], i = $t(t), a = en(e, t), o = It(e, t);
+	return Bt(o, a), {
+		model: {
+			contexts: i,
+			models: a,
+			aggregates: o,
+			apiClients: Xt(e, t, n, r)
+		},
+		warnings: r
+	};
+}
+//#endregion
+//#region src/emit/importRegistry.ts
+var cn = class {
+	declarations = /* @__PURE__ */ new Map();
+	add(e, t) {
+		let n = this.declarations.get(e);
+		n || (n = [], this.declarations.set(e, n));
+		for (let e of t) n.some((t) => t.name === e) || n.push({ name: e });
+		return n;
+	}
+	apply(e) {
+		for (let { moduleSpecifier: t, name: n, alias: r } of e) {
+			let e = this.add(t, [n]).find((e) => e.name === n);
+			r !== void 0 && (e.alias = r);
+		}
+	}
+	entries() {
+		return [...this.declarations].flatMap(([e, t]) => t.map(({ name: t, alias: n }) => n === void 0 ? {
+			moduleSpecifier: e,
+			name: t
+		} : {
+			moduleSpecifier: e,
+			name: t,
+			alias: n
+		}));
+	}
+	localNames(e) {
+		return [...this.declarations.values()].flat().filter((t) => t !== e).map((e) => e.alias ?? e.name);
+	}
+	structures() {
+		return [...this.declarations].map(([e, t]) => ({
+			moduleSpecifier: e,
+			namedImports: t.map(({ name: e, alias: t }) => t === void 0 ? e : {
+				name: e,
+				alias: t
+			})
+		}));
+	}
+}, ln = class {
+	sourceFile;
+	imports = new cn();
+	statements = [];
+	constructor(e) {
+		this.sourceFile = e;
+	}
+	get directoryPath() {
+		return this.sourceFile.getDirectoryPath();
+	}
+	add(e) {
+		return this.statements.push(e), e;
+	}
+	build() {
+		let e = [], t;
+		for (let n of this.imports.structures()) t = {
+			...n,
+			kind: o.ImportDeclaration
+		}, e.push(t);
+		for (let n of this.statements) t && fn(t, n) && e.push(dn), e.push(n), t = n;
+		return e.length > 0 && this.sourceFile.addStatements(e), this.sourceFile;
+	}
+}, un = class {
+	open;
+	modules = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.open = e;
+	}
+	module(e) {
+		let t = this.open(e), n = t.getFilePath(), r = this.modules.get(n);
+		return r || (r = new ln(t), this.modules.set(n, r)), r;
+	}
+	build() {
+		for (let e of this.modules.values()) e.build();
+		this.modules.clear();
+	}
+}, dn = (e) => {
+	e.blankLineIfLastNot();
+};
+function fn(e, t) {
+	if (typeof t == "string") return !1;
+	switch (t.kind) {
+		case o.TypeAlias:
+		case o.VariableStatement: return typeof e == "string" || e.kind !== t.kind;
+		default: return !0;
+	}
+}
+function pn(e) {
+	return e.map((e) => ({
+		...e,
+		initializer: `${e.initializer},`
+	}));
+}
+function mn(e, t) {
+	return {
+		name: "[key: string]",
+		type: e,
+		docs: t
+	};
+}
+//#endregion
+//#region src/emit/imports.ts
+var hn = "@";
+function H(e, t, n) {
+	return e.imports.add(t, n);
+}
+function U(e, t, n) {
+	return H(e, W(e, t, n), [n.name]);
+}
+function W(e, t, n) {
+	return n.path.startsWith(hn) ? n.path : gn(e.directoryPath, d(t, n.path, Wt));
+}
+function gn(e, t) {
+	let n = f(e, t).split(m).join("/");
+	return n = n.endsWith(".ts") ? n.replace(/\.ts$/, ".js") : `${n}/index.js`, n.startsWith(".") ? n : `./${n}`;
+}
+function G(e, t, n, r) {
+	return H(e, gn(e.directoryPath, d(t, Kt(n))), [r]);
+}
+//#endregion
+//#region src/emit/jsdoc.ts
+function _n(e, t = "\n") {
+	if (!Array.isArray(e)) return;
+	let n = e.filter((e) => typeof e == "string" && e.length > 0).map(vn);
+	return n.length > 0 ? n.join(t) : void 0;
+}
+function vn(e) {
+	return e.replace(/\*\//g, "*\\/");
+}
+function K(e, t) {
+	let n = _n(t);
+	n && (e.docs = [...e.docs ?? [], n]);
+}
+function yn(e, t) {
+	let n = [e.title, e.description];
+	return t && n.push(`- key: ${t}`), e.format && n.push(e.format === "int64" ? "- format: int64 (a value beyond Number.MAX_SAFE_INTEGER loses precision)" : `- format: ${e.format}`), Sn(n, e, "default"), Sn(n, e, "example"), wn(n, e), Tn(n, e), En(n, e), n;
+}
+function bn(e, t, n) {
+	K(e, yn(t, n));
+}
+function xn(e, t, n, r = !1) {
+	let i = yn(t, n);
+	r && Cn(i, "schema", t), K(e, i);
+}
+function Sn(e, t, n) {
+	let r = t[n];
+	if (r) {
+		if (typeof r != "object") {
+			e.push(`- ${n}: \`${r}\``);
+			return;
+		}
+		Cn(e, n, r);
+	}
+}
+function Cn(e, t, n) {
+	e.push(`- ${t}: `), e.push("```json"), e.push(JSON.stringify(n, null, 2)), e.push("```");
+}
+function wn(e, t) {
+	let n = ["- Numeric Constraints"];
+	t.minimum !== void 0 && n.push(`  - minimum: ${t.minimum}`), t.maximum !== void 0 && n.push(`  - maximum: ${t.maximum}`), t.exclusiveMinimum !== void 0 && n.push(`  - exclusiveMinimum: ${t.exclusiveMinimum}`), t.exclusiveMaximum !== void 0 && n.push(`  - exclusiveMaximum: ${t.exclusiveMaximum}`), t.multipleOf !== void 0 && n.push(`  - multipleOf: ${t.multipleOf}`), n.length !== 1 && e.push(...n);
+}
+function Tn(e, t) {
+	let n = ["- String Constraints"];
+	t.minLength !== void 0 && n.push(`  - minLength: ${t.minLength}`), t.maxLength !== void 0 && n.push(`  - maxLength: ${t.maxLength}`), t.pattern !== void 0 && n.push(`  - pattern: ${t.pattern}`), n.length !== 1 && e.push(...n);
+}
+function En(e, t) {
+	let n = ["- Array Constraints"];
+	t.minItems !== void 0 && n.push(`  - minItems: ${t.minItems}`), t.maxItems !== void 0 && n.push(`  - maxItems: ${t.maxItems}`), t.uniqueItems !== void 0 && n.push(`  - uniqueItems: ${t.uniqueItems}`), n.length !== 1 && e.push(...n);
+}
+//#endregion
+//#region src/types/typeResolver.ts
+function Dn(e, t) {
+	let n;
+	return {
+		components: e,
+		modelOf: (n) => t.ofReference(n, e),
+		namesAt(r) {
+			if (!n) {
+				n = /* @__PURE__ */ new Map();
+				for (let r of Object.keys(e?.schemas ?? {})) {
+					let e = t.ofKey(r), i = n.get(e.path);
+					i || (i = [], n.set(e.path, i)), i.push(e.name, `${e.name}EnumText`);
+				}
+			}
+			return n.get(r) ?? [];
+		}
+	};
+}
+var On = [
+	"Array",
+	"Blob",
+	"Exclude",
+	"FormData",
+	"Partial",
+	"Promise",
+	"ReadonlyArray",
+	"Record",
+	"Response",
+	"Symbol",
+	"URLSearchParams"
+], kn = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean"
+]), An = /* @__PURE__ */ new Set([
+	"$comment",
+	"$schema",
+	"default",
+	"deprecated",
+	"description",
+	"example",
+	"examples",
+	"externalDocs",
+	"readOnly",
+	"title",
+	"writeOnly",
+	"xml"
+]);
+function jn(e, t) {
+	return e === void 0 ? !1 : typeof e == "string" || typeof t == "string" ? e === t : e.primitive === t.primitive;
+}
+function q(e, t, n = /* @__PURE__ */ new Set()) {
+	if (C(e)) {
+		if (!t || n.has(e.$ref)) return;
+		n.add(e.$ref);
+		let r = D(e, t);
+		return r ? q(r, t, n) : void 0;
+	}
+	if (!(e.nullable || Array.isArray(e.type))) {
+		if (We(e) && e.type === void 0) {
+			let r = e.allOf.map((e) => q(e, t, n)), [i] = r;
+			return i !== void 0 && r.every((e) => jn(e, i)) ? i : void 0;
+		}
+		if (!(N(e) || e.const !== void 0 || e.type === void 0)) return e.type === "object" ? "object" : e.type === "array" ? "array" : { primitive: P(e.type) };
+	}
+}
+function Mn(e, t, n) {
+	let r = q(t, n);
+	if (typeof r != "object") return !1;
+	let i = q(e, n);
+	return i === void 0 || typeof i == "string" || i.primitive !== r.primitive;
+}
+function Nn(e, t) {
+	let n = e.additionalProperties;
+	return typeof n == "object" && Object.values(e.properties ?? {}).some((e) => Mn(e, n, t));
+}
+function Pn(e) {
+	return e.nullable !== !0 || M(e) || !N(e) ? !1 : [
+		e.allOf,
+		e.oneOf,
+		e.anyOf
+	].every((e) => e === void 0 || e.every(C));
+}
+function Fn(e, t) {
+	return t.type === void 0 || e === null && t.nullable ? !0 : [t.type].flat().some((t) => t === "null" ? e === null : t === "array" ? Array.isArray(e) : t === "object" ? typeof e == "object" && !!e && !Array.isArray(e) : t === "integer" ? typeof e == "number" && Number.isInteger(e) : typeof e === t);
+}
+function J(t) {
+	if (typeof t == "string") return new e({ useSingleQuote: !0 }).quote(t).toString();
+	if (Array.isArray(t)) return `[${t.map((e) => J(e)).join(", ")}]`;
+	if (typeof t == "object" && t) {
+		let e = Object.entries(t).map(([e, t]) => `${b(e)}: ${J(t)}`);
+		return e.length ? `{ ${e.join("; ")}; readonly [globalThis.Symbol.iterator]?: never }` : "globalThis.Record<string, never>";
+	}
+	return JSON.stringify(t) ?? "never";
+}
+var In = class {
+	scope;
+	entries;
+	requested = [];
+	constructor(e) {
+		this.scope = e, this.entries = e.imports.entries().map((e) => ({ ...e }));
+	}
+	get components() {
+		return this.scope.context.components;
+	}
+	imports() {
+		return this.requested.map(({ moduleSpecifier: e, name: t, alias: n }) => n === void 0 ? {
+			moduleSpecifier: e,
+			name: t
+		} : {
+			moduleSpecifier: e,
+			name: t,
+			alias: n
+		});
+	}
+	request(e) {
+		this.requested.includes(e) || this.requested.push(e);
+	}
+	reference(e) {
+		let t = this.scope.context.modelOf(e), { owner: n } = this.scope;
+		if (n.path === t.path) return t.name;
+		let r = this.scope.specifierOf(t), i = this.entries.find((e) => e.moduleSpecifier === r && e.name === t.name);
+		if (i || (i = {
+			moduleSpecifier: r,
+			name: t.name
+		}, this.entries.push(i)), this.request(i), i.alias) return i.alias;
+		let a = /* @__PURE__ */ new Set([
+			...On,
+			n.name,
+			...n.path === void 0 ? [] : this.scope.context.namesAt(n.path),
+			...this.entries.filter((e) => e !== i).map((e) => e.alias ?? e.name)
+		]);
+		if (!a.has(t.name)) return t.name;
+		let o = `_${t.name}`;
+		for (; a.has(o);) o = `_${o}`;
+		return i.alias = o, o;
+	}
+	additionalProperties(e) {
+		return e.additionalProperties === !1 || e.additionalProperties === void 0 && !e.required?.some((t) => !Object.hasOwn(e.properties ?? {}, t)) ? "" : e.additionalProperties === !0 || e.additionalProperties === void 0 ? "[key: string]: any" : `[key: string]: ${this.additionalPropertyType(e)}`;
+	}
+	additionalPropertyType(e) {
+		return this.type(typeof e.additionalProperties == "object" ? e.additionalProperties : {});
+	}
+	requiredAdditionalPropertyType(e) {
+		return e.additionalProperties === !1 ? "never" : typeof e.additionalProperties == "object" ? this.type(e.additionalProperties) : "null | string | number | boolean | globalThis.Record<string, unknown> | readonly unknown[]";
+	}
+	propertyDefinitions(e) {
+		let { properties: t } = e;
+		return Object.entries(t).map(([e, t]) => {
+			let n = this.type(t), r = (Xe(t) ? "readonly " : "") + b(e);
+			if (!C(t)) {
+				let e = _n(yn(t), "\n * ");
+				if (e) return `
+          /**
+           * ${e}
+           */
+          ${r}: ${n}
+          `;
+			}
+			return `${r}: ${n}`;
+		});
+	}
+	objectType(e) {
+		let t = [];
+		Be(e) && t.push(...this.propertyDefinitions(e));
+		for (let n of e.required ?? []) Object.hasOwn(e.properties ?? {}, n) || t.push(`${b(n)}: ${this.requiredAdditionalPropertyType(e)}`);
+		let n = Ke(e) && Je(e) ? this.mapType(e) : Nn(e, this.components) ? `globalThis.Record<string, ${this.additionalPropertyType(e)}>` : void 0, r = n ? "" : this.additionalProperties(e);
+		if (r && t.push(r), t.length === 0) return "globalThis.Record<string, any>";
+		let i = `{\n  ${t.join(";\n  ")}; \n}`;
+		return n ? `(${i} & ${n})` : i;
+	}
+	mapValueType(e) {
+		return e.additionalProperties === void 0 || e.additionalProperties === !1 || e.additionalProperties === !0 ? "any" : this.type(e.additionalProperties);
+	}
+	mapKeyType(e) {
+		let t = Je(e);
+		return t ? this.type(t) : "string";
+	}
+	mapType(e) {
+		return `globalThis.Record<${this.mapKeyType(e)},${this.mapValueType(e)}>`;
+	}
+	objectConstrained(e) {
+		let t = (e) => C(e) ? this.components && D(e, this.components) : e, n = t(e), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set(), a = n ? [n] : [];
+		for (let e of a) {
+			if (r.has(e)) continue;
+			let n = [
+				e.allOf,
+				e.oneOf,
+				e.anyOf
+			].map((e) => e?.map(t) ?? []);
+			r.set(e, n);
+			for (let e of n) for (let t of e) t && !r.has(t) && a.push(t);
+			(e.type === "object" || e.type === "null" || Array.isArray(e.type) && e.type.length > 0 && e.type.every((e) => e === "object" || e === "null")) && i.add(e);
+		}
+		let o = !0;
+		for (; o;) {
+			o = !1;
+			for (let [e, [t, n, a]] of r) {
+				if (i.has(e)) continue;
+				let r = (e) => e !== void 0 && i.has(e);
+				(t.some(r) || [n, a].some((e) => e.length > 0 && e.every(r))) && (i.add(e), o = !0);
+			}
+		}
+		return n !== void 0 && i.has(n);
+	}
+	type(e) {
+		if (C(e)) return this.reference(e);
+		if (Array.isArray(e.type)) return e.type.map((t) => {
+			let n = this.type({
+				...e,
+				type: t
+			});
+			return /[|&]/.test(n) ? `(${n})` : n;
+		}).join(" | ");
+		if (Pn(e)) return `(${this.type({
+			...e,
+			nullable: !1
+		})}) | null`;
+		if (N(e)) {
+			let t = this.simpleComposition(e);
+			if (t !== void 0) return t;
+			let n = [
+				"allOf",
+				"oneOf",
+				"anyOf"
+			].flatMap((t) => {
+				let n = e[t];
+				return n?.length ? [`(${n.map((n) => {
+					let r = this.memberType(e, t, n);
+					return r === "any" ? "unknown" : /[|&]/.test(r) ? `(${r})` : r;
+				}).join(t === "allOf" ? " & " : " | ")})`] : [];
+			}), r = n.length === 1 ? n[0] : `(${n.join(" & ")})`, i = {
+				...e,
+				oneOf: void 0,
+				anyOf: void 0,
+				allOf: void 0
+			}, a = this.type(i), o = a === "any" ? r : `(${r} & (${a}))`;
+			return this.objectConstrained(e) ? `globalThis.Exclude<${o}, string | number | boolean | readonly unknown[]> & ({ readonly [globalThis.Symbol.iterator]?: never } | null)` : o;
+		}
+		if (e.const !== void 0) {
+			if (!Fn(e.const, e)) return "never";
+			let t = J(e.const), n = this.type({
+				...e,
+				const: void 0
+			});
+			return n === "any" ? t : `(${t}) & (${n})`;
+		}
+		if (e.nullable && e.type && !M(e)) return `(${this.type({
+			...e,
+			nullable: !1
+		})}) | null`;
+		if (M(e)) {
+			let t = e.enum.filter((t) => Fn(t, e)).map((e) => J(e)).join(" | ") || "never", n = this.type({
+				...e,
+				enum: void 0
+			});
+			return n === "any" || kn.has(n) ? t : `(${t}) & (${n})`;
+		}
+		return Ke(e) && !e.required?.length ? this.mapType(e) : e.type === "array" ? Ge(this.type(e.items ?? {})) : e.type === "object" ? this.objectType(e) : e.type ? P(e.type) : e.required?.length || Object.keys(e.properties ?? {}).length > 0 ? `(${this.objectType({
+			...e,
+			type: "object",
+			additionalProperties: e.additionalProperties ?? !0
+		})} | null | string | number | boolean | readonly unknown[])` : "any";
+	}
+	simpleComposition(e) {
+		let t = [
+			"allOf",
+			"oneOf",
+			"anyOf"
+		].filter((t) => e[t]?.length);
+		if (t.length !== 1) return;
+		let [n] = t;
+		if (Object.keys(e).filter((e) => e !== n && e !== "discriminator" && !e.startsWith("x-") && !An.has(e)).length > 0) return;
+		let r = e[n], i = (e) => n !== "allOf" && [e.type].flat().every((e) => e === "null") && e.type !== void 0 && Object.keys(e).every((e) => e === "type" || An.has(e));
+		if (!r.every((e) => C(e) || i(e))) return;
+		let a = r.map((t) => C(t) ? this.memberType(e, n, t) : "null");
+		return [...new Set(a)].join(n === "allOf" ? " & " : " | ");
+	}
+	memberType(e, t, n) {
+		let r = this.type(n), i = e.discriminator;
+		if (t === "allOf" || !i?.propertyName || !C(n)) return r;
+		let a = we(n), o = Object.entries(i.mapping ?? {}).filter(([, e]) => e === n.$ref || e === a).map(([e]) => e), s = (o.length > 0 ? o : [a]).map((e) => x(e)).join(" | ");
+		return `(${r} & { ${b(i.propertyName)}: ${s} })`;
+	}
+};
+function Y(e, t) {
+	let n = new In(e);
+	return {
+		text: t(n),
+		imports: n.imports()
+	};
+}
+function Ln(e, t) {
+	return Y(t, (t) => t.type(e));
+}
+function Rn(e, t) {
+	return Y(t, (t) => t.additionalProperties(e));
+}
+function zn(e, t) {
+	return Y(t, (t) => t.additionalPropertyType(e));
+}
+function Bn(e, t) {
+	return Y(t, (t) => t.requiredAdditionalPropertyType(e));
+}
+function Vn(e, t) {
+	return Y(t, (t) => t.mapValueType(e));
+}
+//#endregion
+//#region src/emitters/decorators.ts
+var Hn = "@ahoo-wang/fetcher", Un = ["ContentTypeValues", "ResultExtractors"], Wn = "@ahoo-wang/fetcher-decorator", Gn = [
+	"ApiMetadata",
+	"ApiMetadataCapable",
+	"ParameterRequest",
+	"api",
+	"get",
+	"post",
+	"put",
+	"patch",
+	"del",
+	"request",
+	"attribute",
+	"path",
+	"query",
+	"header",
+	"body",
+	"autoGeneratedError"
+], Kn = {
+	type: "Promise<Response>",
+	metadata: "{resultExtractor: ResultExtractors.Response }"
+}, qn = {
+	type: "Promise<string>",
+	metadata: "{resultExtractor: ResultExtractors.Text }"
+}, Jn = "{\n  headers: { Accept: ContentTypeValues.TEXT_EVENT_STREAM },\n  resultExtractor: JsonEventStreamResultExtractor,\n}", Yn = "COMMAND_STREAM_ENDPOINT";
+function Xn(e) {
+	H(e, Hn, Un);
+}
+function Zn(e) {
+	H(e, Wn, Gn);
+}
+function Qn(e, t, n = [], r = [], i) {
+	return t.add({
+		kind: o.Class,
+		name: e,
+		isExported: !0,
+		typeParameters: r,
+		extends: i,
+		decorators: [{
+			name: "api",
+			arguments: n
+		}]
+	});
+}
+function $n(e, t) {
+	if (e.implements = [...[e.implements ?? []].flat(), "ApiMetadataCapable"], e.ctors ??= [], t === void 0) {
+		e.ctors.push({ parameters: [{
+			name: "apiMetadata",
+			type: "ApiMetadata",
+			hasQuestionToken: !0,
+			scope: a.Public,
+			isReadonly: !0
+		}] });
+		return;
+	}
+	e.properties = [...e.properties ?? [], {
+		name: "apiMetadata",
+		type: "ApiMetadata",
+		isReadonly: !0
+	}], e.ctors.push({
+		parameters: [{
+			name: "apiMetadata",
+			type: "ApiMetadata",
+			hasQuestionToken: !0
+		}],
+		statements: `this.apiMetadata = { ${t}, ...apiMetadata };`,
+		docs: ["@param apiMetadata - Merged over the defaults, so passing only a `fetcher` keeps the base path."]
+	});
+}
+function er(e) {
+	return e === "delete" ? "del" : e;
+}
+var tr = "@ahoo-wang/fetcher-eventstream";
+function nr(e) {
+	H(e, tr, ["JsonEventStreamResultExtractor", "JsonServerSentEventStream"]);
+}
+//#endregion
+//#region src/emitters/apiClients.ts
+function rr(e, t) {
+	let n = t.modules.module(e.file);
+	Xn(n), Zn(n), nr(n);
+	let r = Qn(e.className, n);
+	K(r, [e.description]);
+	let i;
+	e.basePath && (G(n, t.outputDir, e.basePath.alias, e.basePath.constantName), i = `basePath: ${e.basePath.constantName}`), $n(r, i);
+	let a = ir(e.className, n, t);
+	for (let t of e.methods) (r.methods ??= []).push(ar(t, a));
+}
+function ir(e, t, n) {
+	let r = {
+		context: n.types,
+		owner: { name: e },
+		specifierOf: (e) => W(t, n.outputDir, e),
+		imports: t.imports
+	};
+	return {
+		module: t,
+		resolveType(e) {
+			let n = Ln(e, r);
+			return t.imports.apply(n.imports), n.text;
+		}
+	};
+}
+function ar(e, t) {
+	let n = [], r = [];
+	for (let i of e.parameters) (i.required ? n : r).push({
+		name: i.name,
+		type: i.schema ? t.resolveType(i.schema) : "string",
+		hasQuestionToken: !i.required,
+		decorators: [{
+			name: i.location,
+			arguments: [x(i.parameterName)]
+		}]
+	});
+	e.body && (e.body.required ? n : r).push({
+		name: e.body.name,
+		type: or(e.body, t),
+		hasQuestionToken: !e.body.required,
+		decorators: [{
+			name: "body",
+			arguments: []
+		}]
+	});
+	let i = [
+		...n,
+		...r,
+		{
+			name: "httpRequest",
+			hasQuestionToken: !0,
+			type: "ParameterRequest",
+			decorators: [{
+				name: "request",
+				arguments: []
+			}]
+		},
+		{
+			name: "attributes",
+			hasQuestionToken: !0,
+			type: "Record<string, unknown>",
+			decorators: [{
+				name: "attribute",
+				arguments: []
+			}]
+		}
+	], a = sr(e.returns, t), o = x(e.path), s = {
+		name: e.name,
+		decorators: [{
+			name: er(e.httpMethod),
+			arguments: a.metadata ? [o, a.metadata] : [o]
+		}],
+		parameters: i,
+		returnType: a.type,
+		statements: [`throw autoGeneratedError(${i.map((e) => e.name).join(",")});`]
+	};
+	return K(s, [...e.docs]), s;
+}
+function or(e, t) {
+	let { content: n } = e;
+	switch (n.kind) {
+		case "json": {
+			let e = t.resolveType(n.schema), r = n.optionalFields;
+			return r.length === 0 || /[|&]/.test(e) || e === "any" ? e : (H(t.module, Hn, ["PartialBy"]), `PartialBy<${e}, ${r.map(x).join(" | ")}>`);
+		}
+		case "formData": return "FormData";
+		case "urlEncoded": return "URLSearchParams";
+		case "text": return "string";
+		case "binary": return "BodyInit";
+	}
+}
+function sr(e, t) {
+	switch (e.kind) {
+		case "json": {
+			let n = t.resolveType(e.schema);
+			return e.wildcard && n === "string" ? qn : { type: `Promise<${n}>` };
+		}
+		case "eventStream": {
+			if (!e.items) return {
+				type: "Promise<JsonServerSentEventStream<any>>",
+				metadata: Jn
+			};
+			let n = t.resolveType(e.items);
+			return {
+				type: `Promise<JsonServerSentEventStream<${e.serverSentEvent ? `${n}['data']` : n}>>`,
+				metadata: Jn
+			};
+		}
+		case "text": return qn;
+		case "response": return Kn;
+	}
+}
+//#endregion
+//#region src/emitters/commandClients.ts
+var cr = "DEFAULT_COMMAND_CLIENT_OPTIONS";
+function lr(e, t) {
+	let n = e.commandClient;
+	if (n.commands.length === 0) return;
+	let r = t.modules.module(n.file);
+	r.add({
+		kind: o.Enum,
+		name: n.endpointPathsName,
+		isExported: !0,
+		members: pn(n.commands.map((e) => ({
+			name: e.endpointMember,
+			initializer: x(e.path)
+		})))
+	});
+	let i = /* @__PURE__ */ new Set(), a = n.commands.map((e) => ur(r, t.outputDir, e, i));
+	G(r, t.outputDir, e.context.alias, e.context.constantName), r.add({
+		kind: o.VariableStatement,
+		declarationKind: c.Const,
+		declarations: [{
+			name: cr,
+			type: "ApiMetadata",
+			initializer: `{
+        basePath: ${e.context.constantName}
+      }`
+		}],
+		isExported: !1
+	}), H(r, I, [
+		"CommandRequest",
+		"CommandResult",
+		"CommandResultEventStream",
+		"CommandBody",
+		Yn
+	]), H(r, "@ahoo-wang/fetcher", ["PartialBy"]), Zn(r);
+	let s = Qn(n.className, r, [], ["R = CommandResult"]);
+	$n(s, `...${cr}`);
+	for (let [e, t] of n.commands.entries()) {
+		let r = dr(t, a[e]), i = {
+			name: t.methodName,
+			decorators: [{
+				name: er(t.httpMethod),
+				arguments: [`${n.endpointPathsName}.${t.endpointMember}`]
+			}],
+			parameters: r,
+			returnType: "Promise<R>",
+			statements: `throw autoGeneratedError(${r.map((e) => e.name).join(",")});`
+		};
+		(s.methods ??= []).push(i), K(i, [...t.docs]);
+	}
+	Qn(n.streamClassName, r, ["''", Yn], [], `${n.className}<CommandResultEventStream>`);
+}
+function ur(e, t, n, r) {
+	if (n.body.path === "@ahoo-wang/wow-client") return H(e, I, [n.typeName]), n.typeName;
+	U(e, t, n.body);
+	let i = n.body.name, a = n.optionalFields.map(x).join(" | ");
+	a !== "" && (i = `PartialBy<${i},${a}>`);
+	let s = `CommandBody<${i}>`;
+	return n.typeName === void 0 ? s : r.has(n.typeName) ? n.typeName : (r.add(n.typeName), e.add({
+		kind: o.TypeAlias,
+		name: n.typeName,
+		type: s,
+		isExported: !0
+	}), n.typeName);
+}
+function dr(e, t) {
+	return [
+		...e.pathParameters.map((e) => ({
+			name: e.name,
+			type: e.type,
+			hasQuestionToken: !1,
+			decorators: [{
+				name: "path",
+				arguments: [x(e.pathName)]
+			}]
+		})),
+		{
+			name: "commandRequest",
+			hasQuestionToken: e.requestOptional,
+			type: `CommandRequest<${t}>`,
+			decorators: [{
+				name: "request",
+				arguments: []
+			}]
+		},
+		{
+			name: "attributes",
+			hasQuestionToken: !0,
+			type: "Record<string, unknown>",
+			decorators: [{
+				name: "attribute",
+				arguments: []
+			}]
+		}
+	];
+}
+//#endregion
+//#region src/emitters/models.ts
+function fr(e) {
+	return Dn(e, {
+		ofKey: (e) => R(e),
+		ofReference: Pt
+	});
+}
+function pr(e, t) {
+	let n = t.modules.module(e.file);
+	if (e.emptyMessageBody) {
+		xn(n.add({
+			kind: o.TypeAlias,
+			name: e.info.name,
+			type: "globalThis.Record<string, never>",
+			isExported: !0
+		}), e.docSchema, e.key, t.schemaDocs === "full");
+		return;
+	}
+	new hr(e, n, t).write();
+}
+function mr(e) {
+	let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = _e(r), i = [e];
+		/^\d/.test(r) || i.push(r);
+		let a = i.find((e) => !t.has(e));
+		for (let n = 2; a === void 0; n++) t.has(`${e}_${n}`) || (a = `${e}_${n}`);
+		t.add(a), n.set(r, b(a));
+	}
+	return n;
+}
+var hr = class {
+	model;
+	module;
+	target;
+	modelInfo;
+	components;
+	constructor(e, t, n) {
+		this.model = e, this.module = t, this.target = n, this.modelInfo = e.info, this.components = n.types.components, this.scope = {
+			context: n.types,
+			owner: e.info,
+			specifierOf: (e) => W(t, n.outputDir, e),
+			imports: t.imports
+		};
+	}
+	write() {
+		let e = this.process();
+		e && xn(e, this.model.docSchema, this.model.key, this.target.schemaDocs === "full");
+	}
+	process() {
+		let { schema: e } = this.model;
+		return C(e) ? this.processTypeAlias(e) : M(e) ? this.processEnum(e) : e.const !== void 0 || e.nullable && e.type || N(e) && (e.type || e.properties || e.required) ? this.processTypeAlias(e) : Be(e) ? this.processInterface(e) : Ke(e) && typeof e.additionalProperties == "object" && !Je(e) && !e.required?.length ? this.processIndexSignature(e) : Ve(e) ? this.processArray(e) : N(e) ? this.processComposition(e) : this.processTypeAlias(e);
+	}
+	scope;
+	emit(e) {
+		return this.module.imports.apply(e.imports), e.text;
+	}
+	resolveType(e) {
+		return this.emit(Ln(e, this.scope));
+	}
+	processEnum(e) {
+		let t = ze(e);
+		if (t) {
+			let e = mr(Object.keys(t));
+			this.module.add({
+				kind: o.Enum,
+				name: this.modelInfo.name + "EnumText",
+				isExported: !0,
+				members: [...e].map(([e, n]) => ({
+					name: n,
+					initializer: J(t[e])
+				}))
+			});
+		}
+		let n = [...new Set(e.enum.filter((e) => typeof e == "string"))], r = mr(n);
+		return N(e) || e.const !== void 0 || e.type !== void 0 && e.type !== "string" || e.enum.some((e) => typeof e != "string") ? (n.length && this.module.add({
+			kind: o.VariableStatement,
+			declarationKind: c.Const,
+			isExported: !0,
+			declarations: [{
+				name: this.modelInfo.name,
+				initializer: (e) => {
+					e.inlineBlock(() => {
+						for (let t of n) e.write(`${r.get(t)}: `).quote(t).write(",").newLine();
+					}), e.write(" as const");
+				}
+			}]
+		}), this.processTypeAlias(e)) : this.module.add({
+			kind: o.Enum,
+			name: this.modelInfo.name,
+			isExported: !0,
+			members: n.map((e) => ({
+				name: r.get(e),
+				initializer: J(e)
+			}))
+		});
+	}
+	addPropertyToInterface(e, t, n) {
+		let r = {
+			name: b(t),
+			type: this.resolveType(n),
+			isReadonly: Xe(n)
+		};
+		(e.properties ??= []).push(r), bn(r, n);
+	}
+	processInterface(e) {
+		if (Nn(e, this.components)) return this.processTypeAlias(e);
+		let t = [], n = this.module.add({
+			kind: o.Interface,
+			name: this.modelInfo.name,
+			isExported: !0,
+			properties: t
+		}), r = e.properties || {};
+		Object.entries(r).forEach(([e, t]) => {
+			this.addPropertyToInterface(n, e, t);
+		});
+		for (let n of e.required ?? []) Object.hasOwn(r, n) || t.push({
+			name: b(n),
+			type: this.emit(Bn(e, this.scope))
+		});
+		return this.emit(Rn(e, this.scope)) && t.push(mn(this.emit(zn(e, this.scope)), ["Additional properties"])), n;
+	}
+	processArray(e) {
+		let t = this.resolveType(e.items);
+		return this.module.add({
+			kind: o.TypeAlias,
+			name: this.modelInfo.name,
+			type: Ge(t),
+			isExported: !0
+		});
+	}
+	processIndexSignature(e) {
+		return this.module.add({
+			kind: o.Interface,
+			name: this.modelInfo.name,
+			isExported: !0,
+			properties: [mn(this.emit(Vn(e, this.scope)))]
+		});
+	}
+	processComposition(e) {
+		return this.module.add({
+			kind: o.TypeAlias,
+			name: this.modelInfo.name,
+			type: this.resolveType(e),
+			isExported: !0
+		});
+	}
+	processTypeAlias(e) {
+		return this.module.add({
+			kind: o.TypeAlias,
+			name: this.modelInfo.name,
+			type: this.resolveType(e),
+			isExported: !0
+		});
+	}
+}, gr = "DEFAULT_QUERY_CLIENT_OPTIONS";
+function _r(e, t) {
+	let n = e.queryClient, r = t.modules.module(n.file);
+	H(r, I, [
+		"QueryClientFactory",
+		"QueryClientOptions",
+		"ResourceAttributionPathSpec"
+	]), G(r, t.outputDir, e.context.alias, e.context.constantName), r.add({
+		kind: o.VariableStatement,
+		declarationKind: c.Const,
+		declarations: [{
+			name: gr,
+			type: "QueryClientOptions",
+			initializer: `{
+        contextAlias: ${e.context.constantName},
+        aggregateName: ${x(n.resourceName)},
+        resourceAttribution: ${n.resourceAttribution},
+      }`
+		}],
+		isExported: !1
+	}), r.add({
+		kind: o.Enum,
+		name: n.eventTitlesName,
+		isExported: !0,
+		members: pn(n.events.map((e) => ({
+			name: e.memberName,
+			initializer: x(e.title)
+		})))
+	});
+	for (let e of n.events) U(r, t.outputDir, e.body);
+	r.add({
+		kind: o.TypeAlias,
+		isExported: !0,
+		name: n.eventTypeName,
+		type: n.events.map((e) => e.body.name).join(" | ") || "never"
+	}), U(r, t.outputDir, n.state), U(r, t.outputDir, n.fields), r.add({
+		kind: o.VariableStatement,
+		declarationKind: c.Const,
+		declarations: [{
+			name: n.factoryName,
+			initializer: `new QueryClientFactory<${n.state.name}, \`\${${n.fields.name}}\`, ${n.eventTypeName}>(${gr})`
+		}],
+		isExported: !0
+	});
+}
+//#endregion
+//#region src/emitters/emit.ts
+function vr(e, t) {
+	e.contexts.forEach((e) => yr(e, t)), e.models.forEach((e) => pr(e, t)), e.aggregates.forEach((e) => _r(e, t)), e.aggregates.forEach((e) => lr(e, t)), e.apiClients.forEach((e) => rr(e, t));
+}
+function yr(e, t) {
+	t.modules.module(e.file).add(`export const ${e.constantName} = ${x(e.alias)};`);
+}
+//#endregion
+//#region src/emitters/indexFiles.ts
+function br(e, t) {
+	let n = [];
+	return xr(e, t, n), n;
+}
+function xr(e, t, n) {
+	let r = [];
+	for (let t of e.getSourceFiles()) {
+		let e = t.getBaseName();
+		e.endsWith(".ts") && e !== "index.ts" && r.push({
+			specifier: `./${t.getBaseNameWithoutExtension()}.js`,
+			exports: Cr(t)
+		});
+	}
+	for (let i of e.getDirectories()) {
+		let e = xr(i, t, n);
+		e && r.push({
+			specifier: `./${i.getBaseName()}/index.js`,
+			exports: e
+		});
+	}
+	let i = e.getPath();
+	return r.length === 0 ? e.getProject().getSourceFile(`${i}/index.ts`) ? /* @__PURE__ */ new Map() : void 0 : Sr(i, r, t, n);
+}
+function Sr(e, t, n, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let e of t) for (let t of e.exports.keys()) i.set(t, [...i.get(t) ?? [], e.specifier]);
+	let a = [...i].filter(([, e]) => e.length > 1).map(([e]) => e).sort();
+	for (let t of a) r.push(`${t} is exported by both ${i.get(t).join(" and ")} in ${e}; its index leaves it out, so import it from its own module.`);
+	let o = n(e);
+	o.removeText();
+	let s = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = [...e.exports].filter(([e]) => !a.includes(e)).sort(([e], [t]) => S(e, t));
+		t.forEach(([e, t]) => s.set(e, t)), t.length === e.exports.size ? o.addExportDeclaration({ moduleSpecifier: e.specifier }) : t.length > 0 && o.addExportDeclaration({
+			moduleSpecifier: e.specifier,
+			namedExports: t.map(([e, t]) => ({
+				name: e,
+				isTypeOnly: t
+			}))
+		});
+	}
+	return o.getStatements().length === 0 && o.addStatements("export {};"), s;
+}
+function Cr(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let [r, i] of e.getExportedDeclarations()) t.set(r, i.every((e) => n.isInterfaceDeclaration(e) || n.isTypeAliasDeclaration(e)));
+	return t;
+}
+//#endregion
+//#region src/finalize/typeOnlyImports.ts
+function wr(e) {
+	let t = e;
+	for (let e = t.getParent(); e; t = e, e = e.getParent()) {
+		if (n.isQualifiedName(e)) {
+			if (e.getLeft() !== t) return !1;
+			continue;
+		}
+		if (n.isPropertyAccessExpression(e)) {
+			if (e.getExpression() !== t) return !1;
+			continue;
+		}
+		if (n.isExpressionWithTypeArguments(e)) {
+			let t = e.getParent(), r = t?.getParent();
+			return !(n.isHeritageClause(t) && t.getToken() === s.ExtendsKeyword && (n.isClassDeclaration(r) || n.isClassExpression(r)));
+		}
+		return n.isTypeNode(e);
+	}
+	return !1;
+}
+function Tr(e) {
+	let t = e.getImportDeclarations().filter((e) => !e.getDefaultImport() && !e.getNamespaceImport() && e.getNamedImports().length > 0);
+	if (t.length === 0) return [];
+	let r = new Set(t.flatMap((e) => e.getNamedImports().map((e) => (e.getAliasNode() ?? e.getNameNode()).getText()))), i = /* @__PURE__ */ new Set();
+	return e.forEachDescendant((e, t) => {
+		if (n.isImportDeclaration(e)) {
+			t.skip();
+			return;
+		}
+		if (n.isIdentifier(e) && r.has(e.getText()) && !wr(e)) {
+			let t = e.getSymbol();
+			t && i.add(t.compilerSymbol);
+		}
+	}), t.map((e) => Er(e, (e) => {
+		let t = e.getSymbol();
+		return !!t && !i.has(t.compilerSymbol);
+	}));
+}
+function Er(e, t) {
+	let n = e.getNamedImports(), r = n.map(t), i = r.every(Boolean);
+	return () => {
+		n.forEach((e, t) => {
+			let n = !i && r[t];
+			e.isTypeOnly() !== n && e.setIsTypeOnly(n);
+		}), e.isTypeOnly() !== i && e.setIsTypeOnly(i);
+	};
+}
+function Dr(e) {
+	let t = e.flatMap(Tr);
+	for (let e of t) e();
+}
+//#endregion
+//#region src/finalize/verification.ts
+var Or = /* @__PURE__ */ new Set([
+	2300,
+	2304,
+	2308,
+	2393,
+	2451,
+	2456,
+	2503,
+	2552
+]);
+function kr(e) {
+	let t = [];
+	for (let n of e) for (let e of n.getPreEmitDiagnostics()) {
+		if (!Or.has(e.getCode()) || e.getSourceFile() !== n) continue;
+		let r = l.flattenDiagnosticMessageText(e.compilerObject.messageText, " ");
+		t.push(`${n.getFilePath()}:${e.getLineNumber() ?? 0} TS${e.getCode()} ${r}`);
+	}
+	if (t.length > 0) throw Error(`The generated code does not compile; nothing was written. This is a wow-generator bug:\n${t.join("\n")}`);
+}
+//#endregion
+//#region src/finalize/finalize.ts
+var Ar = "// Code generated by wow-generator. DO NOT EDIT.\n\n", jr = {
+	indentSize: 2,
+	tabSize: 2,
+	convertTabsToSpaces: !0,
+	semicolons: "insert",
+	insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: !0
+};
+function Mr(e, t) {
+	e.forEach((n, r) => {
+		t.debug(`Optimizing file [${n.getFilePath()}] - ${r + 1}/${e.length}`), n.formatText(jr), n.organizeImports(jr);
+	}), Dr(e), kr(e);
+	for (let t of e) t.insertText(0, Ar);
+}
+//#endregion
+//#region src/input/resources.ts
+var Nr = 3e4;
+function Pr(e) {
+	return /^https?:\/\//i.test(e);
+}
+function Fr(e, t = {}) {
+	return Pr(e) ? Ir(e, t) : Rr(e);
+}
+async function Ir(e, t = {}) {
+	let n = t.timeoutMs ?? 3e4, r;
+	try {
+		let i = AbortSignal.timeout(n);
+		r = await fetch(e, {
+			headers: t.headers,
+			signal: t.signal ? AbortSignal.any([t.signal, i]) : i
+		});
+	} catch (e) {
+		let t = e instanceof Error && e.name === "TimeoutError" ? `no response within ${n} ms` : Lr(e);
+		throw Error(t, { cause: e });
+	}
+	if (!r.ok) {
+		let e = [r.status, r.statusText].filter(Boolean).join(" ");
+		throw Error(`HTTP ${e}`);
+	}
+	return await r.text();
+}
+function Lr(e) {
+	if (!(e instanceof Error)) return String(e);
+	let t = e.cause;
+	return t instanceof Error && t.message ? `${e.message} (${t.message})` : e.message;
+}
+function Rr(e) {
+	return new Promise((t, n) => {
+		te(e, "utf-8", (e, r) => {
+			e ? n(e) : t(r);
+		});
+	});
+}
+//#endregion
+//#region src/input/parsers.ts
+async function zr(e, t) {
+	let n;
+	try {
+		n = await Fr(e, t);
+	} catch (t) {
+		throw new g("input", `Cannot read the OpenAPI document ${e}: ${_(t)}`, { cause: t });
+	}
+	let r;
+	try {
+		r = Vr(n);
+	} catch (t) {
+		throw new g("input", `Cannot parse the OpenAPI document ${e}: ${_(t)}`, { cause: t });
+	}
+	return Br(r, e);
+}
+function Br(e, t) {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw new g("input", `${t} is not an OpenAPI document: expected an object at the top level.`);
+	let n = e;
+	if (n.swagger !== void 0) throw new g("input", `${t} is a Swagger ${String(n.swagger)} document; wow-generator reads OpenAPI 3.x only. Convert it first, for example with swagger2openapi.`);
+	if (typeof n.openapi != "string" || !/^3\.\d+/.test(n.openapi)) throw new g("input", `${t} is not an OpenAPI 3.x document: its "openapi" field is ${n.openapi === void 0 ? "missing" : JSON.stringify(n.openapi)}.`);
+	if (typeof n.info != "object" || n.info === null || Array.isArray(n.info)) throw new g("input", `${t} is not a valid OpenAPI document: its "info" object is missing.`);
+	return {
+		...n,
+		paths: n.paths ?? {}
+	};
+}
+function Vr(e) {
+	switch (Hr(e)) {
+		case "json": return JSON.parse(e);
+		case "yaml": return ee(e);
+	}
+}
+function Hr(e) {
+	let t = e.trimStart();
+	if (t.startsWith("{") || t.startsWith("[")) return "json";
+	if (t.startsWith("-") || t.startsWith("%YAML")) return "yaml";
+	try {
+		return JSON.parse(t), "json";
+	} catch {
+		if (t.length > 0) return "yaml";
+	}
+	throw Error("Unable to infer file format");
+}
+//#endregion
+//#region src/input/configuration.ts
+var Ur = "./fetcher-generator.config.json";
+async function Wr(e, t, n) {
+	if (e !== void 0) return {
+		...await qr({
+			path: e,
+			explicit: !0
+		}, t, n),
+		origin: X(e)
+	};
+	for (let e of [h, Ur]) {
+		let r = await qr({
+			path: e,
+			explicit: !1
+		}, t, n);
+		if (r === void 0) continue;
+		let i = [...r.warnings];
+		return e === "./fetcher-generator.config.json" && i.push(`${X(e)} uses the deprecated name; rename it to ${h.slice(2)}. The old name is no longer read from v10.`), {
+			config: r.config,
+			origin: X(e),
+			warnings: i
+		};
+	}
+	return t.debug("No configuration file found, generating with defaults"), {
+		config: {},
+		warnings: []
+	};
+}
+var Gr = ["apiClients"], Kr = ["ignorePathParameters", "methodNames"];
+async function qr(e, t, n) {
+	let r = X(e.path);
+	t.debug(`Reading configuration: ${r}`);
+	let i;
+	try {
+		i = await Fr(e.path, n);
+	} catch (n) {
+		if (!e.explicit && Jr(n)) {
+			t.debug(`No configuration file at ${r}`);
+			return;
+		}
+		throw new g("configuration", `Cannot read configuration ${r}: ${_(n)}`, { cause: n });
+	}
+	if (!i.trim()) return {
+		config: {},
+		warnings: [`Configuration ${r} is empty, generating with defaults`]
+	};
+	let a;
+	try {
+		a = Vr(i);
+	} catch (e) {
+		throw new g("configuration", `Cannot parse configuration ${r}: ${_(e)}`, { cause: e });
+	}
+	let o = Xr(a, r);
+	return t.debug(`Configuration loaded from ${r}: ${Qr(o.config)}`), o;
+}
+function X(e) {
+	return Pr(e) || u(e) ? e : p(e);
+}
+function Jr(e) {
+	return typeof e == "object" && !!e && e.code === "ENOENT";
+}
+function Z(e) {
+	return e === null ? "null" : Array.isArray(e) ? "an array" : `a ${typeof e}`;
+}
+function Q(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function Yr(e, t, n, r, i) {
+	let a = Object.keys(r).filter((e) => !i.includes(e));
+	a.length && e.push(`Ignoring unknown ${n} option(s) in ${t}: ${a.join(", ")}. Known option(s): ${i.join(", ")}`);
+}
+function Xr(e, t) {
+	if (!Q(e)) throw new g("configuration", `Configuration ${t} must be a JSON or YAML object, found ${Z(e)}`);
+	let n = [];
+	return Yr(n, t, "configuration", e, Gr), Zr(e.apiClients, t, n), {
+		config: e,
+		warnings: n
+	};
+}
+function Zr(e, t, n) {
+	if (e !== void 0) {
+		if (!Q(e)) throw new g("configuration", `apiClients in ${t} must be an object keyed by tag name, found ${Z(e)}`);
+		for (let [r, i] of Object.entries(e)) {
+			if (!Q(i)) throw new g("configuration", `apiClients["${r}"] in ${t} must be an object, found ${Z(i)}`);
+			Yr(n, t, `apiClients["${r}"]`, i, Kr);
+			let { ignorePathParameters: e } = i;
+			if (e !== void 0 && !(Array.isArray(e) && e.every((e) => typeof e == "string"))) throw new g("configuration", `apiClients["${r}"].ignorePathParameters in ${t} must be an array of strings, found ${Z(e)}`);
+			let { methodNames: a } = i;
+			if (a !== void 0) {
+				if (!Q(a)) throw new g("configuration", `apiClients["${r}"].methodNames in ${t} must be an object mapping operationIds to method names, found ${Z(a)}`);
+				for (let [e, n] of Object.entries(a)) if (typeof n != "string" || !v(n)) throw new g("configuration", `apiClients["${r}"].methodNames["${e}"] in ${t} must be a valid method name, found ${JSON.stringify(n)}`);
+			}
+		}
+	}
+}
+function Qr(e) {
+	let t = Object.keys(e.apiClients ?? {});
+	return `apiClients=${t.length ? t.join(", ") : "none"}`;
+}
+//#endregion
+//#region src/openapi/document.ts
+function $r(e) {
+	return {
+		openAPI: e,
+		components: e.components,
+		endpoints: et(e.paths, e.components)
+	};
+}
+//#endregion
+//#region src/output/outputStore.ts
+var ei = ".wow-generator.json", ti = ".fetcher-generator.json", ni = class e {
+	project;
+	outputPath;
+	outputDir;
+	previous;
+	legacyManifest;
+	written = /* @__PURE__ */ new Set();
+	stale = /* @__PURE__ */ new Set();
+	constructor(e, t, n, r, i) {
+		this.project = e, this.outputPath = t, this.outputDir = n, this.previous = r, this.legacyManifest = i;
+	}
+	static open(t, n, r) {
+		let i = t.getFileSystem(), a = n;
+		n = p(i.getCurrentDirectory(), n);
+		let o = d(n, ti), s = i.fileExistsSync(o) ? o : void 0, c = d(n, ei);
+		!i.fileExistsSync(c) && s && (c = s);
+		let l = /* @__PURE__ */ new Map();
+		if (i.fileExistsSync(c)) {
+			let e = ri(c, i.readFileSync(c));
+			for (let [t, r] of Object.entries(e.files)) {
+				let e = p(n, t);
+				if (oi(n, e), u(t) || !t.endsWith(".ts") || typeof r != "string" || !/^[a-f0-9]{64}$/.test(r)) throw new g("output", `Invalid generated file entry in ${c}: ${t}`);
+				l.set(e, r);
+			}
+		}
+		let f = /* @__PURE__ */ new Set([...r?.written ?? [], ...l.keys()]);
+		for (let e of t.getSourceFiles()) f.has(e.getFilePath()) && e.forget();
+		return new e(t, a, n, l, s);
+	}
+	get files() {
+		return this.written;
+	}
+	claim(e, t = this.outputPath) {
+		let n = B(t, e);
+		oi(t, n);
+		let r = this.project.getSourceFile(n) ?? this.project.createSourceFile(n, "", { overwrite: !0 }), i = r.getFilePath();
+		return this.written.has(i) || (r.removeText(), this.written.add(i)), r;
+	}
+	forgetStale() {
+		for (let [e, t] of this.previous) !this.written.has(e) && this.isUnchanged(e, t) && this.stale.add(e);
+		for (let e of this.project.getSourceFiles()) this.stale.has(e.getFilePath()) && e.forget();
+	}
+	async commit(e) {
+		e?.throwIfAborted();
+		let t = this.project.getFileSystem(), n = new Set([...this.written].map((e) => e.toLowerCase()));
+		for (let e of this.stale) !this.written.has(e) && n.has(e.toLowerCase()) && this.isUnchanged(e, this.previous.get(e)) && (await $("delete", e, () => t.delete(e)), this.stale.delete(e));
+		let r = [...this.written].sort().map((e) => this.project.getSourceFileOrThrow(e));
+		(await Promise.allSettled(r.map((e) => e.save()))).forEach((e, t) => {
+			if (e.status === "rejected") throw ai("write", r[t].getFilePath(), e.reason);
+		}), e?.throwIfAborted();
+		for (let e of this.stale) !this.written.has(e) && this.isUnchanged(e, this.previous.get(e)) && await $("delete", e, () => t.delete(e));
+		let i = d(this.outputDir, ei), a = JSON.stringify({
+			version: 1,
+			files: Object.fromEntries(r.map((e) => [f(this.outputDir, e.getFilePath()).split(m).join("/"), ii(t.readFileSync(e.getFilePath()))]))
+		}, null, 2) + "\n";
+		await $("write", i, async () => {
+			t.mkdirSync(this.outputDir), await t.writeFile(i, a);
+		});
+		let o = this.legacyManifest;
+		o && t.fileExistsSync(o) && await $("delete", o, () => t.delete(o));
+	}
+	isUnchanged(e, t) {
+		let n = this.project.getFileSystem();
+		return n.fileExistsSync(e) ? (oi(n.realpathSync(this.outputDir), n.realpathSync(e)), ii(n.readFileSync(e)) === t) : !1;
+	}
+};
+function ri(e, t) {
+	let n = "delete it; without it this run cannot remove the stale files of the last run", r;
+	try {
+		r = JSON.parse(t);
+	} catch (t) {
+		throw new g("output", `Cannot parse the generation manifest ${e}: ${_(t)}. Resolve the merge conflict in it if it has one, or ${n}.`, { cause: t });
+	}
+	let i = r?.version;
+	if (typeof i == "number" && Number.isInteger(i) && i > 1) throw new g("output", `The generation manifest ${e} was written by a newer wow-generator (manifest version ${i}); this one reads version 1. Upgrade wow-generator.`);
+	if (i !== 1 || !r.files || typeof r.files != "object" || Array.isArray(r.files)) throw new g("output", `Invalid generation manifest ${e}: expected "version": 1 and a "files" object. Restore it from version control, or ${n}.`);
+	return r;
+}
+function ii(e) {
+	if (!l.sys.createSHA256Hash) throw Error("SHA-256 hashing is unavailable in this environment.");
+	return l.sys.createSHA256Hash(e);
+}
+function ai(e, t, n) {
+	return n instanceof g ? n : new g("output", `Cannot ${e} ${t}: ${_(n)}`, { cause: n });
+}
+async function $(e, t, n) {
+	try {
+		await n();
+	} catch (n) {
+		throw ai(e, t, n);
+	}
+}
+function oi(e, t) {
+	let n = t.split("/").join(m), r = p(e), i = p(n), a = f(r, i);
+	if (a === "" || a.startsWith("..") || u(a)) throw new g("output", `Path traversal detected: "${t}" resolves outside the output directory "${e}".`);
+}
+//#endregion
+//#region src/wow/resolveWowModel.ts
+function si(e) {
+	let { openAPI: t, components: n, endpoints: r } = e, i = [], a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), s = t.tags ?? [], c = new Set(s.map((e) => e.name)), l = new Set(r.flatMap((e) => e.operation.tags ?? []).filter((e) => !c.has(e))), u = /* @__PURE__ */ new Map();
+	for (let e of [...s, ...[...l].map((e) => ({ name: e }))]) {
+		let t = pt(e);
+		t && u.set(e.name, {
+			aggregate: t,
+			commands: /* @__PURE__ */ new Map(),
+			events: /* @__PURE__ */ new Map()
+		});
+	}
+	let d = (e) => (e.tags ?? []).flatMap((e) => {
+		let t = u.get(e);
+		return t ? (o.add(e), [t]) : [];
+	}), f = (e, t, n) => {
+		let r = a.get(e.key);
+		r || (r = {}, a.set(e.key, r));
+		let i = t in r ? r[t] : e.schema[t];
+		r[t] = i || n;
+	}, p = (e, t) => new g("specification", `Cannot read the Wow metadata of ${e.operationId}: ${t}. wow-generator reads documents from Wow ${lt} or later.`), m = (e, t) => {
+		let n = vt.exec(t)?.[1];
+		n && e.forEach((e) => {
+			e.resourceName ??= n;
+		});
+	}, ee = (e) => {
+		let { operation: t, path: r } = e;
+		if (t.operationId === "wow.command.send") return;
+		let a = mt(t.operationId);
+		if (!a) return;
+		let o = F(t), s = /* @__PURE__ */ new Set();
+		for (; o && C(o) && o.$ref !== "#/components/responses/wow.CommandOk";) {
+			if (!o.$ref.startsWith(T)) return;
+			if (s.has(o.$ref)) throw new g("specification", `Cyclic component reference: ${o.$ref}`);
+			s.add(o.$ref), o = n?.responses?.[o.$ref.slice(T.length)];
+		}
+		if (!o || !C(o) || o.$ref !== "#/components/responses/wow.CommandOk") return;
+		let c = d(t);
+		if (!t.requestBody) return;
+		let l = at(t, n ?? {}), u = (C(t.requestBody) ? Ee(t.requestBody, n ?? {}) : t.requestBody)?.content?.[k]?.schema;
+		if (!C(u)) {
+			c.length > 0 && i.push(`Skipping command ${t.operationId} (${e.method.toUpperCase()} ${r}): its application/json request body is not a $ref to a component schema.`);
+			return;
+		}
+		let p = O(u, n ?? {});
+		if (!p.schema) return;
+		f(p, "title", t.summary), f(p, "description", t.description);
+		let m = {
+			name: a,
+			method: e.method,
+			path: r,
+			pathParameters: l,
+			summary: t.summary,
+			description: t.description,
+			schema: p,
+			operation: t
+		};
+		c.forEach((e) => {
+			e.commands.set(a, m);
+		});
+	}, te = ({ operation: e, path: t }) => {
+		if (!e.operationId?.endsWith(".snapshot_state.single")) return;
+		let r = d(e);
+		m(r, t);
+		let i = rt(e, n);
+		if (!C(i)) {
+			if (r.length > 0) throw p(e, "its 200 application/json response is not a $ref to the state schema");
+			return;
+		}
+		let a = O(i, n);
+		r.forEach((e) => {
+			e.state = a;
+		});
+	}, h = ({ operation: e }) => {
+		if (!n || !e.operationId?.endsWith(".event.list_query")) return;
+		let t = d(e);
+		if (t.length === 0) return;
+		let r = rt(e, n);
+		if (C(r)) return;
+		let i = r?.items;
+		if (!C(i)) throw p(e, "its 200 application/json response is not an array of a $ref to the event stream schema");
+		let a = ci(D(i, n), [
+			"properties",
+			"body",
+			"items",
+			"anyOf"
+		]);
+		if (!Array.isArray(a)) throw p(e, `the event stream schema ${i.$ref} has no properties.body.items.anyOf listing the domain events`);
+		let o = a.map((t, r) => {
+			let a = ci(t, [
+				"properties",
+				"name",
+				"const"
+			]), o = ci(t, ["properties", "body"]);
+			if (typeof a != "string" || !C(o)) throw p(e, `domain event ${r} of ${i.$ref} needs a properties.name.const and a properties.body that is a $ref to the event schema`);
+			let s = O(o, n);
+			return f(s, "title", t.title), {
+				title: t.title ?? a,
+				name: a,
+				schema: s
+			};
+		});
+		t.forEach((e) => {
+			o.forEach((t) => {
+				e.events.set(t.name, t);
+			});
+		});
+	}, ne = ({ operation: e, path: t }) => {
+		if (!n || !e.operationId?.endsWith(".snapshot.count")) return;
+		let r = d(e);
+		if (r.length === 0) return;
+		m(r, t);
+		let i = e.requestBody ? C(e.requestBody) ? Ee(e.requestBody, n) : e.requestBody : void 0;
+		if (!i) throw p(e, "it has no request body");
+		let a = i[_t], o;
+		if (a !== void 0) {
+			if (!C(a)) throw p(e, `${_t} must be a schema reference`);
+			o = a;
+		} else {
+			let t = i.content?.[k]?.schema, r = (C(t) ? D(t, n) : void 0)?.properties?.field;
+			if (!C(r)) throw p(e, `its request body has no ${_t}, and its condition schema has no field $ref to read the query fields from`);
+			o = r;
+		}
+		let s = O(o, n);
+		r.forEach((e) => {
+			e.fields = s;
+		});
+	};
+	for (let e of r) ee(e), te(e), h(e), ne(e);
+	let _ = /* @__PURE__ */ new Map();
+	for (let [e, t] of u) {
+		if (!t.state || !t.fields) {
+			if (o.has(e)) {
+				let n = [t.state ? void 0 : `${e}${ht}`, t.fields ? void 0 : `${e}${gt}`].filter(Boolean);
+				i.push(`Skipping aggregate ${e}: the document has no ${n.join(" or ")} operation, so it generates neither command nor query clients for it.`);
+			}
+			continue;
+		}
+		let n = t.aggregate.contextAlias, r = _.get(n);
+		r || (r = /* @__PURE__ */ new Set(), _.set(n, r)), r.add({
+			...t,
+			resourceName: t.resourceName ?? t.aggregate.aggregateName
+		});
+	}
+	return {
+		contextAlias: dt(t),
+		contexts: _,
+		aggregateTags: o,
+		schemaDocOverrides: a,
+		warnings: i
+	};
+}
+function ci(e, t) {
+	let n = e;
+	for (let e of t) {
+		if (typeof n != "object" || !n) return;
+		n = n[e];
+	}
+	return n;
+}
+//#endregion
+//#region src/pipeline/seams.ts
+var li = Symbol("project"), ui = Symbol("signal"), di = class {
+	options;
+	project;
+	logger;
+	signal;
+	output;
+	constructor(e) {
+		this.options = e, this.logger = e.logger ?? new ie(), this.signal = e[ui], this.project = e[li] ?? fi(e.tsConfigFilePath), this.project.manipulationSettings.set({
+			indentationText: t.TwoSpaces,
+			quoteKind: i.Single,
+			useTrailingCommas: !0
+		}), this.logger.debug(`Project instance created with tsConfigFilePath: ${this.options.tsConfigFilePath}`);
+	}
+	async generate() {
+		let { logger: e, signal: t, options: n } = this, r = 0, i = (t) => {
+			for (let n of t) r++, e.warn(n);
+		};
+		e.debug("Starting code generation from OpenAPI specification"), e.debug(`Work directory: ${process.cwd()}`), e.debug(`Input path: ${n.inputPath}`), e.debug(`Output directory: ${n.outputDir}`);
+		let a = {
+			headers: n.headers,
+			timeoutMs: n.timeoutMs,
+			signal: t
+		}, o = await Wr(n.configPath, e, a);
+		i(o.warnings), t?.throwIfAborted(), e.debug("Parsing OpenAPI specification");
+		let s = await zr(n.inputPath, a);
+		t?.throwIfAborted(), e.debug("OpenAPI specification parsed successfully");
+		let c = be(s);
+		if (c.length > 0) throw new g("specification", `${n.inputPath} has ${c.length} $ref(s) that point at nothing: ${c.slice(0, 10).map(({ ref: e, location: t }) => `${e} (at ${t})`).join(", ")}${c.length > 10 ? ", …" : ""}`);
+		let l = $r(s);
+		e.debug("Resolving bounded context aggregates");
+		let u = si(l);
+		i(u.warnings), e.debug(`Resolved ${u.contexts.size} bounded context aggregates`);
+		let d = ni.open(this.project, n.outputDir, this.output);
+		this.output = d, e.debug("Analysing the document");
+		let f = sn(l, u, o.config);
+		i(f.warnings), e.debug("Writing generated modules");
+		let p = new un((e) => d.claim(e));
+		vr(f.model, {
+			modules: p,
+			outputDir: n.outputDir,
+			types: fr(l.components),
+			schemaDocs: n.schemaDocs ?? "summary"
+		}), p.build(), e.debug("Generated modules written"), d.forgetStale();
+		let m = this.project.getDirectory(n.outputDir);
+		return m ? (e.debug("Generating index files"), i(br(m, (e) => d.claim("index.ts", e))), e.debug("Optimizing source files"), Mr(m.getDescendantSourceFiles().filter((e) => d.files.has(e.getFilePath())), e), e.debug("Source files optimized successfully")) : e.debug("Output directory not found."), e.debug("Saving project to disk"), await d.commit(t), e.debug("Code generation completed successfully"), {
+			files: [...d.files].sort(),
+			configPath: o.origin,
+			warnings: r
+		};
+	}
+};
+function fi(e) {
+	try {
+		return new r({
+			tsConfigFilePath: e,
+			skipAddingFilesFromTsConfig: !0
+		});
+	} catch (t) {
+		throw new g("configuration", `Cannot read the TypeScript configuration ${e}: ${_(t)}`, { cause: t });
+	}
+}
+//#endregion
+export { ae as a, h as c, ie as i, ui as n, ne as o, Nr as r, g as s, di as t };
+
+//# sourceMappingURL=codeGenerator-kyY9eLML.js.map