@glion/config 0.14.1

package/dist/json-schema2.js

@@ -0,0 +1,1085 @@
+import { HL7v2ConfigSchema } from "./schema.js";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
+const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+const defaultOptions = {
+	name: void 0,
+	$refStrategy: "root",
+	basePath: ["#"],
+	effectStrategy: "input",
+	pipeStrategy: "all",
+	dateStrategy: "format:date-time",
+	mapStrategy: "entries",
+	removeAdditionalStrategy: "passthrough",
+	allowedAdditionalProperties: true,
+	rejectedAdditionalProperties: false,
+	definitionPath: "definitions",
+	target: "jsonSchema7",
+	strictUnions: false,
+	definitions: {},
+	errorMessages: false,
+	markdownDescription: false,
+	patternStrategy: "escape",
+	applyRegexFlags: false,
+	emailStrategy: "format:email",
+	base64Strategy: "contentEncoding:base64",
+	nameStrategy: "ref",
+	openAiAnyTypeName: "OpenAiAnyType"
+};
+const getDefaultOptions = (options) => typeof options === "string" ? {
+	...defaultOptions,
+	name: options
+} : {
+	...defaultOptions,
+	...options
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js
+const getRefs = (options) => {
+	const _options = getDefaultOptions(options);
+	const currentPath = _options.name !== void 0 ? [
+		..._options.basePath,
+		_options.definitionPath,
+		_options.name
+	] : _options.basePath;
+	return {
+		..._options,
+		flags: { hasReferencedOpenAiAnyType: false },
+		currentPath,
+		propertyPath: void 0,
+		seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [def._def, {
+			def: def._def,
+			path: [
+				..._options.basePath,
+				_options.definitionPath,
+				name
+			],
+			jsonSchema: void 0
+		}]))
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+	if (!refs?.errorMessages) return;
+	if (errorMessage) res.errorMessage = {
+		...res.errorMessage,
+		[key]: errorMessage
+	};
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+	res[key] = value;
+	addErrorMessage(res, key, errorMessage, refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+const getRelativePath = (pathA, pathB) => {
+	let i = 0;
+	for (; i < pathA.length && i < pathB.length; i++) if (pathA[i] !== pathB[i]) break;
+	return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+	if (refs.target !== "openAi") return {};
+	const anyDefinitionPath = [
+		...refs.basePath,
+		refs.definitionPath,
+		refs.openAiAnyTypeName
+	];
+	refs.flags.hasReferencedOpenAiAnyType = true;
+	return { $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/") };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+	const res = { type: "array" };
+	if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) res.items = parseDef(def.type._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "items"]
+	});
+	if (def.minLength) setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+	if (def.maxLength) setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+	if (def.exactLength) {
+		setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+		setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+	}
+	return res;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+	const res = {
+		type: "integer",
+		format: "int64"
+	};
+	if (!def.checks) return res;
+	for (const check of def.checks) switch (check.kind) {
+		case "min":
+			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+			else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+			else {
+				if (!check.inclusive) res.exclusiveMinimum = true;
+				setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+			}
+			break;
+		case "max":
+			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+			else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+			else {
+				if (!check.inclusive) res.exclusiveMaximum = true;
+				setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+			}
+			break;
+		case "multipleOf":
+			setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+			break;
+	}
+	return res;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+	return { type: "boolean" };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+	return parseDef(_def.type._def, refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+const parseCatchDef = (def, refs) => {
+	return parseDef(def.innerType._def, refs);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+	const strategy = overrideDateStrategy ?? refs.dateStrategy;
+	if (Array.isArray(strategy)) return { anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)) };
+	switch (strategy) {
+		case "string":
+		case "format:date-time": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "format:date": return {
+			type: "string",
+			format: "date"
+		};
+		case "integer": return integerDateParser(def, refs);
+	}
+}
+const integerDateParser = (def, refs) => {
+	const res = {
+		type: "integer",
+		format: "unix-time"
+	};
+	if (refs.target === "openApi3") return res;
+	for (const check of def.checks) switch (check.kind) {
+		case "min":
+			setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+			break;
+		case "max":
+			setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+			break;
+	}
+	return res;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+	return {
+		...parseDef(_def.innerType._def, refs),
+		default: _def.defaultValue()
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+	return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+	return {
+		type: "string",
+		enum: Array.from(def.values)
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+const isJsonSchema7AllOfType = (type) => {
+	if ("type" in type && type.type === "string") return false;
+	return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+	const allOf = [parseDef(def.left._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"0"
+		]
+	}), parseDef(def.right._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"1"
+		]
+	})].filter((x) => !!x);
+	let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+	const mergedAllOf = [];
+	allOf.forEach((schema) => {
+		if (isJsonSchema7AllOfType(schema)) {
+			mergedAllOf.push(...schema.allOf);
+			if (schema.unevaluatedProperties === void 0) unevaluatedProperties = void 0;
+		} else {
+			let nestedSchema = schema;
+			if ("additionalProperties" in schema && schema.additionalProperties === false) {
+				const { additionalProperties, ...rest } = schema;
+				nestedSchema = rest;
+			} else unevaluatedProperties = void 0;
+			mergedAllOf.push(nestedSchema);
+		}
+	});
+	return mergedAllOf.length ? {
+		allOf: mergedAllOf,
+		...unevaluatedProperties
+	} : void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+	const parsedType = typeof def.value;
+	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") return { type: Array.isArray(def.value) ? "array" : "object" };
+	if (refs.target === "openApi3") return {
+		type: parsedType === "bigint" ? "integer" : parsedType,
+		enum: [def.value]
+	};
+	return {
+		type: parsedType === "bigint" ? "integer" : parsedType,
+		const: def.value
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+let emojiRegex = void 0;
+/**
+* Generated from the regular expressions found here as of 2024-05-22:
+* https://github.com/colinhacks/zod/blob/master/src/types.ts.
+*
+* Expressions with /i flag have been changed accordingly.
+*/
+const zodPatterns = {
+	cuid: /^[cC][^\s-]{8,}$/,
+	cuid2: /^[0-9a-z]+$/,
+	ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+	email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+	emoji: () => {
+		if (emojiRegex === void 0) emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+		return emojiRegex;
+	},
+	uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+	ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+	ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+	ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+	ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+	base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+	base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+	nanoid: /^[a-zA-Z0-9_-]{21}$/,
+	jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+	const res = { type: "string" };
+	if (def.checks) for (const check of def.checks) switch (check.kind) {
+		case "min":
+			setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+			break;
+		case "max":
+			setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+			break;
+		case "email":
+			switch (refs.emailStrategy) {
+				case "format:email":
+					addFormat(res, "email", check.message, refs);
+					break;
+				case "format:idn-email":
+					addFormat(res, "idn-email", check.message, refs);
+					break;
+				case "pattern:zod":
+					addPattern(res, zodPatterns.email, check.message, refs);
+					break;
+			}
+			break;
+		case "url":
+			addFormat(res, "uri", check.message, refs);
+			break;
+		case "uuid":
+			addFormat(res, "uuid", check.message, refs);
+			break;
+		case "regex":
+			addPattern(res, check.regex, check.message, refs);
+			break;
+		case "cuid":
+			addPattern(res, zodPatterns.cuid, check.message, refs);
+			break;
+		case "cuid2":
+			addPattern(res, zodPatterns.cuid2, check.message, refs);
+			break;
+		case "startsWith":
+			addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+			break;
+		case "endsWith":
+			addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+			break;
+		case "datetime":
+			addFormat(res, "date-time", check.message, refs);
+			break;
+		case "date":
+			addFormat(res, "date", check.message, refs);
+			break;
+		case "time":
+			addFormat(res, "time", check.message, refs);
+			break;
+		case "duration":
+			addFormat(res, "duration", check.message, refs);
+			break;
+		case "length":
+			setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+			setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+			break;
+		case "includes":
+			addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+			break;
+		case "ip":
+			if (check.version !== "v6") addFormat(res, "ipv4", check.message, refs);
+			if (check.version !== "v4") addFormat(res, "ipv6", check.message, refs);
+			break;
+		case "base64url":
+			addPattern(res, zodPatterns.base64url, check.message, refs);
+			break;
+		case "jwt":
+			addPattern(res, zodPatterns.jwt, check.message, refs);
+			break;
+		case "cidr":
+			if (check.version !== "v6") addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+			if (check.version !== "v4") addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+			break;
+		case "emoji":
+			addPattern(res, zodPatterns.emoji(), check.message, refs);
+			break;
+		case "ulid":
+			addPattern(res, zodPatterns.ulid, check.message, refs);
+			break;
+		case "base64":
+			switch (refs.base64Strategy) {
+				case "format:binary":
+					addFormat(res, "binary", check.message, refs);
+					break;
+				case "contentEncoding:base64":
+					setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+					break;
+				case "pattern:zod":
+					addPattern(res, zodPatterns.base64, check.message, refs);
+					break;
+			}
+			break;
+		case "nanoid": addPattern(res, zodPatterns.nanoid, check.message, refs);
+		case "toLowerCase":
+		case "toUpperCase":
+		case "trim": break;
+		default: ((_) => {})(check);
+	}
+	return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+	return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+const ALPHA_NUMERIC = /* @__PURE__ */ new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+	let result = "";
+	for (let i = 0; i < source.length; i++) {
+		if (!ALPHA_NUMERIC.has(source[i])) result += "\\";
+		result += source[i];
+	}
+	return result;
+}
+function addFormat(schema, value, message, refs) {
+	if (schema.format || schema.anyOf?.some((x) => x.format)) {
+		if (!schema.anyOf) schema.anyOf = [];
+		if (schema.format) {
+			schema.anyOf.push({
+				format: schema.format,
+				...schema.errorMessage && refs.errorMessages && { errorMessage: { format: schema.errorMessage.format } }
+			});
+			delete schema.format;
+			if (schema.errorMessage) {
+				delete schema.errorMessage.format;
+				if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
+			}
+		}
+		schema.anyOf.push({
+			format: value,
+			...message && refs.errorMessages && { errorMessage: { format: message } }
+		});
+	} else setResponseValueAndErrors(schema, "format", value, message, refs);
+}
+function addPattern(schema, regex, message, refs) {
+	if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+		if (!schema.allOf) schema.allOf = [];
+		if (schema.pattern) {
+			schema.allOf.push({
+				pattern: schema.pattern,
+				...schema.errorMessage && refs.errorMessages && { errorMessage: { pattern: schema.errorMessage.pattern } }
+			});
+			delete schema.pattern;
+			if (schema.errorMessage) {
+				delete schema.errorMessage.pattern;
+				if (Object.keys(schema.errorMessage).length === 0) delete schema.errorMessage;
+			}
+		}
+		schema.allOf.push({
+			pattern: stringifyRegExpWithFlags(regex, refs),
+			...message && refs.errorMessages && { errorMessage: { pattern: message } }
+		});
+	} else setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+}
+function stringifyRegExpWithFlags(regex, refs) {
+	if (!refs.applyRegexFlags || !regex.flags) return regex.source;
+	const flags = {
+		i: regex.flags.includes("i"),
+		m: regex.flags.includes("m"),
+		s: regex.flags.includes("s")
+	};
+	const source = flags.i ? regex.source.toLowerCase() : regex.source;
+	let pattern = "";
+	let isEscaped = false;
+	let inCharGroup = false;
+	let inCharRange = false;
+	for (let i = 0; i < source.length; i++) {
+		if (isEscaped) {
+			pattern += source[i];
+			isEscaped = false;
+			continue;
+		}
+		if (flags.i) {
+			if (inCharGroup) {
+				if (source[i].match(/[a-z]/)) {
+					if (inCharRange) {
+						pattern += source[i];
+						pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+						inCharRange = false;
+					} else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+						pattern += source[i];
+						inCharRange = true;
+					} else pattern += `${source[i]}${source[i].toUpperCase()}`;
+					continue;
+				}
+			} else if (source[i].match(/[a-z]/)) {
+				pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+				continue;
+			}
+		}
+		if (flags.m) {
+			if (source[i] === "^") {
+				pattern += `(^|(?<=[\r\n]))`;
+				continue;
+			} else if (source[i] === "$") {
+				pattern += `($|(?=[\r\n]))`;
+				continue;
+			}
+		}
+		if (flags.s && source[i] === ".") {
+			pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
+			continue;
+		}
+		pattern += source[i];
+		if (source[i] === "\\") isEscaped = true;
+		else if (inCharGroup && source[i] === "]") inCharGroup = false;
+		else if (!inCharGroup && source[i] === "[") inCharGroup = true;
+	}
+	try {
+		new RegExp(pattern);
+	} catch {
+		console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+		return regex.source;
+	}
+	return pattern;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(def, refs) {
+	if (refs.target === "openAi") console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+	if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
+		type: "object",
+		required: def.keyType._def.values,
+		properties: def.keyType._def.values.reduce((acc, key) => ({
+			...acc,
+			[key]: parseDef(def.valueType._def, {
+				...refs,
+				currentPath: [
+					...refs.currentPath,
+					"properties",
+					key
+				]
+			}) ?? parseAnyDef(refs)
+		}), {}),
+		additionalProperties: refs.rejectedAdditionalProperties
+	};
+	const schema = {
+		type: "object",
+		additionalProperties: parseDef(def.valueType._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalProperties"]
+		}) ?? refs.allowedAdditionalProperties
+	};
+	if (refs.target === "openApi3") return schema;
+	if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+		const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+		return {
+			...schema,
+			propertyNames: keyType
+		};
+	} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) return {
+		...schema,
+		propertyNames: { enum: def.keyType._def.values }
+	};
+	else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+		const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+		return {
+			...schema,
+			propertyNames: keyType
+		};
+	}
+	return schema;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+	if (refs.mapStrategy === "record") return parseRecordDef(def, refs);
+	return {
+		type: "array",
+		maxItems: 125,
+		items: {
+			type: "array",
+			items: [parseDef(def.keyType._def, {
+				...refs,
+				currentPath: [
+					...refs.currentPath,
+					"items",
+					"items",
+					"0"
+				]
+			}) || parseAnyDef(refs), parseDef(def.valueType._def, {
+				...refs,
+				currentPath: [
+					...refs.currentPath,
+					"items",
+					"items",
+					"1"
+				]
+			}) || parseAnyDef(refs)],
+			minItems: 2,
+			maxItems: 2
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+	const object = def.values;
+	const actualValues = Object.keys(def.values).filter((key) => {
+		return typeof object[object[key]] !== "number";
+	}).map((key) => object[key]);
+	const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+	return {
+		type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+		enum: actualValues
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+	return refs.target === "openAi" ? void 0 : { not: parseAnyDef({
+		...refs,
+		currentPath: [...refs.currentPath, "not"]
+	}) };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+	return refs.target === "openApi3" ? {
+		enum: ["null"],
+		nullable: true
+	} : { type: "null" };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+const primitiveMappings = {
+	ZodString: "string",
+	ZodNumber: "number",
+	ZodBigInt: "integer",
+	ZodBoolean: "boolean",
+	ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+	if (refs.target === "openApi3") return asAnyOf(def, refs);
+	const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+	if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+		const types = options.reduce((types, x) => {
+			const type = primitiveMappings[x._def.typeName];
+			return type && !types.includes(type) ? [...types, type] : types;
+		}, []);
+		return { type: types.length > 1 ? types : types[0] };
+	} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+		const types = options.reduce((acc, x) => {
+			const type = typeof x._def.value;
+			switch (type) {
+				case "string":
+				case "number":
+				case "boolean": return [...acc, type];
+				case "bigint": return [...acc, "integer"];
+				case "object": if (x._def.value === null) return [...acc, "null"];
+				default: return acc;
+			}
+		}, []);
+		if (types.length === options.length) {
+			const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+			return {
+				type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+				enum: options.reduce((acc, x) => {
+					return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+				}, [])
+			};
+		}
+	} else if (options.every((x) => x._def.typeName === "ZodEnum")) return {
+		type: "string",
+		enum: options.reduce((acc, x) => [...acc, ...x._def.values.filter((x) => !acc.includes(x))], [])
+	};
+	return asAnyOf(def, refs);
+}
+const asAnyOf = (def, refs) => {
+	const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			`${i}`
+		]
+	})).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+	return anyOf.length ? { anyOf } : void 0;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(def, refs) {
+	if ([
+		"ZodString",
+		"ZodNumber",
+		"ZodBigInt",
+		"ZodBoolean",
+		"ZodNull"
+	].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+		if (refs.target === "openApi3") return {
+			type: primitiveMappings[def.innerType._def.typeName],
+			nullable: true
+		};
+		return { type: [primitiveMappings[def.innerType._def.typeName], "null"] };
+	}
+	if (refs.target === "openApi3") {
+		const base = parseDef(def.innerType._def, {
+			...refs,
+			currentPath: [...refs.currentPath]
+		});
+		if (base && "$ref" in base) return {
+			allOf: [base],
+			nullable: true
+		};
+		return base && {
+			...base,
+			nullable: true
+		};
+	}
+	const base = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			"0"
+		]
+	});
+	return base && { anyOf: [base, { type: "null" }] };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+	const res = { type: "number" };
+	if (!def.checks) return res;
+	for (const check of def.checks) switch (check.kind) {
+		case "int":
+			res.type = "integer";
+			addErrorMessage(res, "type", check.message, refs);
+			break;
+		case "min":
+			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+			else setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+			else {
+				if (!check.inclusive) res.exclusiveMinimum = true;
+				setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+			}
+			break;
+		case "max":
+			if (refs.target === "jsonSchema7") if (check.inclusive) setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+			else setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+			else {
+				if (!check.inclusive) res.exclusiveMaximum = true;
+				setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+			}
+			break;
+		case "multipleOf":
+			setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+			break;
+	}
+	return res;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+	const forceOptionalIntoNullable = refs.target === "openAi";
+	const result = {
+		type: "object",
+		properties: {}
+	};
+	const required = [];
+	const shape = def.shape();
+	for (const propName in shape) {
+		let propDef = shape[propName];
+		if (propDef === void 0 || propDef._def === void 0) continue;
+		let propOptional = safeIsOptional(propDef);
+		if (propOptional && forceOptionalIntoNullable) {
+			if (propDef._def.typeName === "ZodOptional") propDef = propDef._def.innerType;
+			if (!propDef.isNullable()) propDef = propDef.nullable();
+			propOptional = false;
+		}
+		const parsedDef = parseDef(propDef._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"properties",
+				propName
+			],
+			propertyPath: [
+				...refs.currentPath,
+				"properties",
+				propName
+			]
+		});
+		if (parsedDef === void 0) continue;
+		result.properties[propName] = parsedDef;
+		if (!propOptional) required.push(propName);
+	}
+	if (required.length) result.required = required;
+	const additionalProperties = decideAdditionalProperties(def, refs);
+	if (additionalProperties !== void 0) result.additionalProperties = additionalProperties;
+	return result;
+}
+function decideAdditionalProperties(def, refs) {
+	if (def.catchall._def.typeName !== "ZodNever") return parseDef(def.catchall._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "additionalProperties"]
+	});
+	switch (def.unknownKeys) {
+		case "passthrough": return refs.allowedAdditionalProperties;
+		case "strict": return refs.rejectedAdditionalProperties;
+		case "strip": return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+	}
+}
+function safeIsOptional(schema) {
+	try {
+		return schema.isOptional();
+	} catch {
+		return true;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+const parseOptionalDef = (def, refs) => {
+	if (refs.currentPath.toString() === refs.propertyPath?.toString()) return parseDef(def.innerType._def, refs);
+	const innerSchema = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			"1"
+		]
+	});
+	return innerSchema ? { anyOf: [{ not: parseAnyDef(refs) }, innerSchema] } : parseAnyDef(refs);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+const parsePipelineDef = (def, refs) => {
+	if (refs.pipeStrategy === "input") return parseDef(def.in._def, refs);
+	else if (refs.pipeStrategy === "output") return parseDef(def.out._def, refs);
+	const a = parseDef(def.in._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"0"
+		]
+	});
+	return { allOf: [a, parseDef(def.out._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			a ? "1" : "0"
+		]
+	})].filter((x) => x !== void 0) };
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+	return parseDef(def.type._def, refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+	const schema = {
+		type: "array",
+		uniqueItems: true,
+		items: parseDef(def.valueType._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "items"]
+		})
+	};
+	if (def.minSize) setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+	if (def.maxSize) setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+	return schema;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+	if (def.rest) return {
+		type: "array",
+		minItems: def.items.length,
+		items: def.items.map((x, i) => parseDef(x._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"items",
+				`${i}`
+			]
+		})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+		additionalItems: parseDef(def.rest._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalItems"]
+		})
+	};
+	else return {
+		type: "array",
+		minItems: def.items.length,
+		maxItems: def.items.length,
+		items: def.items.map((x, i) => parseDef(x._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"items",
+				`${i}`
+			]
+		})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+	return { not: parseAnyDef(refs) };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+	return parseAnyDef(refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+const parseReadonlyDef = (def, refs) => {
+	return parseDef(def.innerType._def, refs);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+const selectParser = (def, typeName, refs) => {
+	switch (typeName) {
+		case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
+		case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef(refs);
+		case ZodFirstPartyTypeKind.ZodNull: return parseNullDef(refs);
+		case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUnion:
+		case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
+		case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNaN:
+		case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef(refs);
+		case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef(refs);
+		case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef(refs);
+		case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodFunction:
+		case ZodFirstPartyTypeKind.ZodVoid:
+		case ZodFirstPartyTypeKind.ZodSymbol: return;
+		default: return ((_) => void 0)(typeName);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef(def, refs, forceResolution = false) {
+	const seenItem = refs.seen.get(def);
+	if (refs.override) {
+		const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+		if (overrideResult !== ignoreOverride) return overrideResult;
+	}
+	if (seenItem && !forceResolution) {
+		const seenSchema = get$ref(seenItem, refs);
+		if (seenSchema !== void 0) return seenSchema;
+	}
+	const newItem = {
+		def,
+		path: refs.currentPath,
+		jsonSchema: void 0
+	};
+	refs.seen.set(def, newItem);
+	const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+	const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+	if (jsonSchema) addMeta(def, refs, jsonSchema);
+	if (refs.postProcess) {
+		const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+		newItem.jsonSchema = jsonSchema;
+		return postProcessResult;
+	}
+	newItem.jsonSchema = jsonSchema;
+	return jsonSchema;
+}
+const get$ref = (item, refs) => {
+	switch (refs.$refStrategy) {
+		case "root": return { $ref: item.path.join("/") };
+		case "relative": return { $ref: getRelativePath(refs.currentPath, item.path) };
+		case "none":
+		case "seen":
+			if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+				console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+				return parseAnyDef(refs);
+			}
+			return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+	}
+};
+const addMeta = (def, refs, jsonSchema) => {
+	if (def.description) {
+		jsonSchema.description = def.description;
+		if (refs.markdownDescription) jsonSchema.markdownDescription = def.description;
+	}
+	return jsonSchema;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+const zodToJsonSchema = (schema, options) => {
+	const refs = getRefs(options);
+	let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
+		...acc,
+		[name]: parseDef(schema._def, {
+			...refs,
+			currentPath: [
+				...refs.basePath,
+				refs.definitionPath,
+				name
+			]
+		}, true) ?? parseAnyDef(refs)
+	}), {}) : void 0;
+	const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+	const main = parseDef(schema._def, name === void 0 ? refs : {
+		...refs,
+		currentPath: [
+			...refs.basePath,
+			refs.definitionPath,
+			name
+		]
+	}, false) ?? parseAnyDef(refs);
+	const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+	if (title !== void 0) main.title = title;
+	if (refs.flags.hasReferencedOpenAiAnyType) {
+		if (!definitions) definitions = {};
+		if (!definitions[refs.openAiAnyTypeName]) definitions[refs.openAiAnyTypeName] = {
+			type: [
+				"string",
+				"number",
+				"integer",
+				"boolean",
+				"array",
+				"null"
+			],
+			items: { $ref: refs.$refStrategy === "relative" ? "1" : [
+				...refs.basePath,
+				refs.definitionPath,
+				refs.openAiAnyTypeName
+			].join("/") }
+		};
+	}
+	const combined = name === void 0 ? definitions ? {
+		...main,
+		[refs.definitionPath]: definitions
+	} : main : {
+		$ref: [
+			...refs.$refStrategy === "relative" ? [] : refs.basePath,
+			refs.definitionPath,
+			name
+		].join("/"),
+		[refs.definitionPath]: {
+			...definitions,
+			[name]: main
+		}
+	};
+	if (refs.target === "jsonSchema7") combined.$schema = "http://json-schema.org/draft-07/schema#";
+	else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+	if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+	return combined;
+};
+//#endregion
+//#region src/json-schema.ts
+/**
+* JSON Schema for hl7v2 configuration.
+*
+* This schema can be used for IDE autocomplete by adding:
+*
+* ```json
+* {
+*   "$schema": "https://raw.githubusercontent.com/rethinkhealth/hl7v2/main/packages/hl7v2-config/schema.json"
+* }
+* ```
+*/
+const jsonSchema = zodToJsonSchema(HL7v2ConfigSchema, {
+	$refStrategy: "none",
+	name: "HL7v2Config",
+	target: "jsonSchema7"
+});
+//#endregion
+export { jsonSchema as t };
+
+//# sourceMappingURL=json-schema2.js.map