@e-n-v/env 0.0.1 → 0.0.4

package/dist/src-CVdUqK3q.js

@@ -0,0 +1,850 @@
+import { a as isEnvVarSchema, c as EnumEnvVarSchema, l as BooleanEnvVarSchema, o as StringEnvVarSchema, s as NumberEnvVarSchema } from "./src-CLTURaoo.js";
+import { Qr as safeParse, jn as stringbool, kn as string, n as number } from "./coerce-DNIuYAx4.js";
+
+//#region ../converters/src/converters/zod/ZodV3Converter.ts
+/**
+* Zod v3 schema converter implementation
+*/
+var ZodV3Converter = class {
+	applies(schema) {
+		return isZodV3Schema(schema);
+	}
+	convert(schema) {
+		return convertFromZodV3Schema(schema);
+	}
+};
+/**
+* Check if a schema is a Zod v3 schema
+*/
+function isZodV3Schema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const candidate = schema;
+	return Boolean(candidate._def && !("_zod" in candidate) && (candidate._def.typeName || typeof candidate.parse === "function"));
+}
+/**
+* Extract definition from Zod v3 schema
+*/
+function getV3Def(schema) {
+	return schema._def || {};
+}
+/**
+* Get the type name from a Zod v3 definition
+*/
+function getV3TypeName(def) {
+	return def.typeName || "unknown";
+}
+/**
+* Check if a type is a wrapper type that should be unwrapped
+*/
+function isV3WrapperType(typeName) {
+	return [
+		"ZodOptional",
+		"ZodDefault",
+		"ZodEffects",
+		"ZodNullable",
+		"ZodNullish",
+		"ZodReadonly",
+		"ZodBranded",
+		"ZodCatch"
+	].includes(typeName);
+}
+/**
+* Get inner schema from wrapper
+*/
+function getV3InnerSchema(def) {
+	return def.innerType || def.schema;
+}
+/**
+* Get default value from definition
+*/
+function getV3DefaultValue(def) {
+	if (def.defaultValue === void 0) return void 0;
+	return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+}
+/**
+* Extract enum values from schema
+*/
+function extractV3EnumValues(def) {
+	if (!Array.isArray(def.values)) return void 0;
+	return def.values.map((v) => String(v));
+}
+/**
+* Get description from schema
+*/
+function getV3Description(schema, def) {
+	const directDesc = schema.description;
+	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
+	if (typeof def.description === "string" && def.description.length > 0) return def.description;
+}
+/**
+* Resolve environment variable type from schema
+*/
+function resolveV3EnvVarType(schema) {
+	const def = getV3Def(schema);
+	switch (getV3TypeName(def)) {
+		case "ZodString": return "string";
+		case "ZodNumber": return "number";
+		case "ZodBoolean": return "boolean";
+		case "ZodEnum": return "enum";
+		default:
+			if (def.values) return "enum";
+			return "string";
+	}
+}
+function peelV3Schema(schema) {
+	let current = schema;
+	let required = true;
+	let defaultValue = void 0;
+	let description = void 0;
+	for (let i = 0; i < 20; i++) {
+		const def = getV3Def(current);
+		const typeName = getV3TypeName(def);
+		if (!description) description = getV3Description(current, def);
+		if (!isV3WrapperType(typeName)) break;
+		if (typeName === "ZodOptional" || typeName === "ZodNullish") required = false;
+		if (typeName === "ZodDefault" && defaultValue === void 0) defaultValue = getV3DefaultValue(def);
+		const inner = getV3InnerSchema(def);
+		if (!inner) break;
+		current = inner;
+	}
+	return {
+		schema: current,
+		required,
+		default: defaultValue,
+		description
+	};
+}
+/**
+* Create a process function for Zod v3 schemas
+*/
+function createV3ProcessFunction(schema, type) {
+	return (value) => {
+		try {
+			let processSchema = schema;
+			if (type === "number") processSchema = number();
+			else if (type === "boolean") processSchema = string().transform((val) => {
+				const lower = val.toLowerCase().trim();
+				if ([
+					"true",
+					"1",
+					"yes",
+					"on",
+					"enabled"
+				].includes(lower)) return true;
+				if ([
+					"false",
+					"0",
+					"no",
+					"off",
+					"disabled"
+				].includes(lower)) return false;
+				throw new Error(`Expected boolean value, received "${val}"`);
+			});
+			const result = processSchema.safeParse(value);
+			if (result.success) return result.data;
+			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Zod v3 schema to EnvVarSchema
+*/
+function convertFromZodV3Schema(schema) {
+	const peeled = peelV3Schema(schema);
+	const type = resolveV3EnvVarType(peeled.schema);
+	const def = getV3Def(peeled.schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createV3ProcessFunction(peeled.schema, "boolean"),
+			required: peeled.required,
+			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createV3ProcessFunction(peeled.schema, "number"),
+			required: peeled.required,
+			default: typeof peeled.default === "number" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "enum": {
+			const values = extractV3EnumValues(def) || [];
+			return new EnumEnvVarSchema({
+				process: createV3ProcessFunction(peeled.schema, "enum"),
+				values,
+				required: peeled.required,
+				default: typeof peeled.default === "string" ? peeled.default : void 0,
+				description: peeled.description
+			});
+		}
+		case "string":
+		default: {
+			const process = createV3ProcessFunction(peeled.schema, "string");
+			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
+			return new StringEnvVarSchema({
+				process,
+				required: peeled.required,
+				default: defaultValue,
+				description: peeled.description
+			});
+		}
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/zod/ZodV4Converter.ts
+/**
+* Zod v4 schema converter implementation
+*/
+var ZodV4Converter = class {
+	applies(schema) {
+		return isZodV4Schema(schema);
+	}
+	convert(schema) {
+		return convertFromZodV4Schema(schema);
+	}
+};
+/**
+* Check if a schema is a Zod v4 schema
+*/
+function isZodV4Schema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	return "_zod" in schema;
+}
+/**
+* Extract definition from Zod v4 schema
+*/
+function getV4Def(schema) {
+	const container = schema;
+	if (container._zod && container._zod.def) return container._zod.def;
+	return {};
+}
+/**
+* Get the type name from a Zod v4 definition
+*/
+function getV4TypeName(def) {
+	return def.type || "unknown";
+}
+/**
+* Check if a type is a wrapper type that should be unwrapped
+*/
+function isV4WrapperType(typeName) {
+	return [
+		"optional",
+		"default",
+		"catch",
+		"readonly",
+		"brand",
+		"prefault",
+		"nullable",
+		"nullish"
+	].includes(typeName);
+}
+/**
+* Get inner schema from wrapper
+*/
+function getV4InnerSchema(def) {
+	return def.innerType || def.schema || def.in || def.inner;
+}
+/**
+* Get default value from definition
+*/
+function getV4DefaultValue(def) {
+	if (def.defaultValue !== void 0) return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+	if (def.prefaultValue !== void 0) return typeof def.prefaultValue === "function" ? def.prefaultValue() : def.prefaultValue;
+}
+/**
+* Extract enum values from schema
+*/
+function extractV4EnumValues(def) {
+	if (Array.isArray(def.values)) return def.values.map((v) => String(v));
+	if (def.entries && typeof def.entries === "object") return Object.values(def.entries).map((v) => String(v));
+}
+/**
+* Get description from schema
+*/
+function getV4Description(schema, def) {
+	const directDesc = schema.description;
+	if (typeof directDesc === "string" && directDesc.length > 0) return directDesc;
+	if (typeof def.description === "string" && def.description.length > 0) return def.description;
+	const metaFn = schema.meta;
+	if (typeof metaFn === "function") {
+		const meta = metaFn.call(schema);
+		if (meta?.description && typeof meta.description === "string") return meta.description.trim();
+	}
+}
+/**
+* Resolve environment variable type from schema
+*/
+function resolveV4EnvVarType(schema) {
+	const def = getV4Def(schema);
+	switch (getV4TypeName(def)) {
+		case "string": return "string";
+		case "number":
+		case "int": return "number";
+		case "boolean":
+		case "stringbool": return "boolean";
+		case "pipe":
+			if (def.in && def.out) {
+				const inType = resolveV4EnvVarType(def.in);
+				const outType = resolveV4EnvVarType(def.out);
+				if (inType === "string" && outType === "boolean") return "boolean";
+			}
+			return "string";
+		case "enum": return "enum";
+		default:
+			if (def.values || def.entries) return "enum";
+			return "string";
+	}
+}
+function peelV4Schema(schema) {
+	let current = schema;
+	let required = true;
+	let defaultValue = void 0;
+	let description = void 0;
+	for (let i = 0; i < 20; i++) {
+		const def = getV4Def(current);
+		const typeName = getV4TypeName(def);
+		if (!description) description = getV4Description(current, def);
+		if (!isV4WrapperType(typeName)) if (typeName === "pipe" && def.in && def.out) {
+			const inType = resolveV4EnvVarType(def.in);
+			const outType = resolveV4EnvVarType(def.out);
+			if (inType === "string" && outType === "boolean") break;
+		} else break;
+		if (typeName === "optional" || typeName === "nullish") required = false;
+		if ((typeName === "default" || typeName === "prefault") && defaultValue === void 0) defaultValue = getV4DefaultValue(def);
+		const inner = getV4InnerSchema(def);
+		if (!inner) break;
+		current = inner;
+	}
+	return {
+		schema: current,
+		required,
+		default: defaultValue,
+		description
+	};
+}
+/**
+* Create a process function for Zod v4 schemas
+*/
+function createV4ProcessFunction(schema, type, originalSchema) {
+	return (value) => {
+		try {
+			let processSchema = schema;
+			const def = getV4Def(schema);
+			const typeName = getV4TypeName(def);
+			if (typeName === "stringbool" || typeName === "pipe" && def.in && def.out && resolveV4EnvVarType(def.in) === "string" && resolveV4EnvVarType(def.out) === "boolean") processSchema = originalSchema;
+			else if (type === "number") processSchema = number();
+			else if (type === "boolean") processSchema = stringbool();
+			const result = safeParse(processSchema, value);
+			if (result.success) return result.data;
+			throw new Error(`Failed to parse value "${value}": ${result.error.issues.map((issue) => issue.message).join("; ")}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Zod v4 schema to EnvVarSchema
+*/
+function convertFromZodV4Schema(schema) {
+	const peeled = peelV4Schema(schema);
+	const type = resolveV4EnvVarType(peeled.schema);
+	const def = getV4Def(peeled.schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createV4ProcessFunction(peeled.schema, "boolean", schema),
+			required: peeled.required,
+			default: typeof peeled.default === "boolean" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createV4ProcessFunction(peeled.schema, "number", schema),
+			required: peeled.required,
+			default: typeof peeled.default === "number" ? peeled.default : void 0,
+			description: peeled.description
+		});
+		case "enum": {
+			const values = extractV4EnumValues(def) || [];
+			return new EnumEnvVarSchema({
+				process: createV4ProcessFunction(peeled.schema, "enum", schema),
+				values,
+				required: peeled.required,
+				default: typeof peeled.default === "string" ? peeled.default : void 0,
+				description: peeled.description
+			});
+		}
+		case "string":
+		default: {
+			const process = createV4ProcessFunction(peeled.schema, "string", schema);
+			const defaultValue = typeof peeled.default === "string" ? peeled.default : void 0;
+			return new StringEnvVarSchema({
+				process,
+				required: peeled.required,
+				default: defaultValue,
+				description: peeled.description
+			});
+		}
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/joi/JoiConverter.ts
+/**
+* Joi schema converter implementation
+*/
+var JoiConverter = class {
+	applies(schema) {
+		return isJoiSchema(schema);
+	}
+	convert(schema) {
+		return convertFromJoiSchema(schema);
+	}
+};
+/**
+* Check if a schema is a Joi schema using the official API
+*/
+function isJoiSchema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	const candidate = schema;
+	if (!(typeof candidate.describe === "function" && typeof candidate.validate === "function")) return false;
+	if (candidate.isJoi === true) return true;
+	const hasAsyncVariant = typeof candidate.validateAsync === "function";
+	const hasRoot = typeof candidate.$_root === "object" && candidate.$_root !== null;
+	const hasFlags = typeof candidate._flags === "object" && candidate._flags !== null;
+	return hasAsyncVariant || hasRoot || hasFlags;
+}
+/**
+* Get description from Joi schema using public API first, internal as fallback
+*/
+function getJoiDescription(schema) {
+	try {
+		return schema.describe()?.flags?.description;
+	} catch {
+		return schema._flags?.description;
+	}
+}
+/**
+* Check if schema is required using public API first, internal as fallback
+*/
+function isJoiRequired(schema) {
+	try {
+		const presence = schema.describe()?.flags?.presence;
+		if (presence === "required") return true;
+		if (presence === "optional") return false;
+		return presence === void 0;
+	} catch {
+		const flags = schema._flags;
+		if (flags?.presence === "required") return true;
+		if (flags?.presence === "optional") return false;
+		return true;
+	}
+}
+/**
+* Get default value from Joi schema using public API first, internal as fallback
+*/
+function getJoiDefaultValue(schema) {
+	try {
+		const defaultValue = schema.describe()?.flags?.default;
+		return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+	} catch {
+		const flags = schema._flags;
+		if (flags?.default !== void 0) {
+			const defaultValue = flags.default;
+			return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+		}
+		return;
+	}
+}
+/**
+* Get valid values for enum-like schemas using public API first, internal as fallback
+*/
+function getJoiValidValues(schema) {
+	const values = [];
+	let isOnlySchema = false;
+	try {
+		const description = schema.describe();
+		if (description?.allow && Array.isArray(description.allow)) values.push(...description.allow);
+		isOnlySchema = description?.flags?.only === true;
+	} catch {
+		if (schema._valids?._values) values.push(...Array.from(schema._valids._values));
+		isOnlySchema = schema._flags?.only === true;
+	}
+	if (isOnlySchema && values.length > 0) return values.map((v) => String(v));
+}
+/**
+* Resolve environment variable type from Joi schema using public API first, internal as fallback
+*/
+function resolveJoiEnvVarType(schema) {
+	let type;
+	const exposedSchema = schema;
+	try {
+		type = schema.describe()?.type;
+	} catch {
+		type = exposedSchema._type || schema.type;
+	}
+	const validValues = getJoiValidValues(schema);
+	if (validValues && validValues.length > 0) return "enum";
+	switch (type) {
+		case "string": return "string";
+		case "number": return "number";
+		case "boolean": return "boolean";
+		default: return "string";
+	}
+}
+/**
+* Create a process function for Joi schemas
+*/
+function createJoiProcessFunction(schema, type) {
+	return (value) => {
+		try {
+			let processValue = value;
+			if (type === "number") {
+				const num = Number(value);
+				if (Number.isNaN(num)) throw new Error(`Expected number, received "${value}"`);
+				processValue = num;
+			} else if (type === "boolean") {
+				const lower = value.toLowerCase().trim();
+				if ([
+					"true",
+					"1",
+					"yes",
+					"on",
+					"enabled"
+				].includes(lower)) processValue = true;
+				else if ([
+					"false",
+					"0",
+					"no",
+					"off",
+					"disabled"
+				].includes(lower)) processValue = false;
+				else throw new Error(`Expected boolean value, received "${value}"`);
+			}
+			const result = schema.validate(processValue, { convert: true });
+			if (result.error) {
+				const message = result.error.details ? result.error.details.map((d) => d.message).join("; ") : result.error.message || String(result.error);
+				throw new Error(`Validation failed: ${message}`);
+			}
+			return result.value;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(message);
+		}
+	};
+}
+/**
+* Convert Joi schema to EnvVarSchema
+*/
+function convertFromJoiSchema(schema) {
+	const type = resolveJoiEnvVarType(schema);
+	const required = isJoiRequired(schema);
+	const defaultValue = getJoiDefaultValue(schema);
+	const description = getJoiDescription(schema);
+	switch (type) {
+		case "boolean": return new BooleanEnvVarSchema({
+			process: createJoiProcessFunction(schema, "boolean"),
+			required,
+			default: typeof defaultValue === "boolean" ? defaultValue : void 0,
+			description
+		});
+		case "number": return new NumberEnvVarSchema({
+			process: createJoiProcessFunction(schema, "number"),
+			required,
+			default: typeof defaultValue === "number" ? defaultValue : void 0,
+			description
+		});
+		case "enum": {
+			const values = getJoiValidValues(schema) || [];
+			return new EnumEnvVarSchema({
+				process: createJoiProcessFunction(schema, "enum"),
+				values,
+				required,
+				default: typeof defaultValue === "string" ? defaultValue : void 0,
+				description
+			});
+		}
+		case "string":
+		default: return new StringEnvVarSchema({
+			process: createJoiProcessFunction(schema, "string"),
+			required,
+			default: typeof defaultValue === "string" ? defaultValue : void 0,
+			description
+		});
+	}
+}
+
+//#endregion
+//#region ../converters/src/converters/superstruct/SuperstructConverter.ts
+/**
+* Superstruct schema converter implementation
+*/
+var SuperstructConverter = class {
+	applies(schema) {
+		return isSuperstructSchema(schema);
+	}
+	convert(schema) {
+		return convertFromSuperstruct(schema);
+	}
+};
+/**
+* Detect if a value looks like a Superstruct Struct instance
+*/
+function isSuperstructSchema(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.type === "string" && typeof candidate.validate === "function" && typeof candidate.create === "function";
+}
+/**
+* Convert a Superstruct schema to an EnvVarSchema
+*/
+function convertFromSuperstruct(schema) {
+	const resolvedType = resolveSuperstructEnvVarType(schema);
+	const required = isStructRequired(schema);
+	const description = getStructDescription(schema);
+	const defaultValue = getStructDefault(schema);
+	if (resolvedType === "enum") {
+		const values = extractEnumValues(schema);
+		if (!values || values.length === 0) return createStringEnvVarSchema(schema, required, defaultValue, description);
+		const readonlyValues = values;
+		return new EnumEnvVarSchema({
+			process: createSuperstructProcessFunction(schema, "enum"),
+			values: readonlyValues,
+			required,
+			default: typeof defaultValue === "string" ? defaultValue : void 0,
+			description
+		});
+	}
+	if (resolvedType === "boolean") return new BooleanEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "boolean"),
+		required,
+		default: typeof defaultValue === "boolean" ? defaultValue : void 0,
+		description
+	});
+	if (resolvedType === "number") return new NumberEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "number"),
+		required,
+		default: typeof defaultValue === "number" ? defaultValue : void 0,
+		description
+	});
+	return createStringEnvVarSchema(schema, required, defaultValue, description);
+}
+function createStringEnvVarSchema(schema, required, defaultValue, description) {
+	return new StringEnvVarSchema({
+		process: createSuperstructProcessFunction(schema, "string"),
+		required,
+		default: typeof defaultValue === "string" ? defaultValue : void 0,
+		description
+	});
+}
+function resolveSuperstructEnvVarType(schema) {
+	switch (getStructType(schema)) {
+		case "boolean": return "boolean";
+		case "number":
+		case "integer": return "number";
+		case "enums": return "enum";
+		case "literal": return typeof schema.schema === "string" ? "enum" : "string";
+		default: return "string";
+	}
+}
+function getStructType(schema) {
+	const typeValue = schema.type;
+	return typeof typeValue === "string" ? typeValue : "unknown";
+}
+function extractEnumValues(schema) {
+	const typeName = getStructType(schema);
+	if (typeName === "enums") {
+		const structSchema = schema.schema;
+		if (structSchema && typeof structSchema === "object") {
+			const rawValues = Object.values(structSchema);
+			if (rawValues.every((value) => typeof value === "string")) return rawValues;
+		}
+	}
+	if (typeName === "literal") {
+		const value = schema.schema;
+		if (typeof value === "string") return [value];
+	}
+}
+function isStructRequired(schema) {
+	try {
+		const [error] = schema.validate(void 0);
+		return !!error;
+	} catch {
+		return true;
+	}
+}
+function getStructDefault(schema) {
+	try {
+		const [error, value] = schema.validate(void 0, { coerce: true });
+		if (!error && value !== void 0) return value;
+	} catch {}
+}
+function getStructDescription(schema) {
+	const structSchema = schema.schema;
+	if (structSchema && typeof structSchema === "object" && typeof structSchema.description === "string") return structSchema.description;
+	if (typeof schema.description === "string") return schema.description;
+}
+function createSuperstructProcessFunction(schema, type) {
+	return (value) => {
+		if (typeof value !== "string") throw new Error("Value must be a string");
+		let candidate = value;
+		if (type === "number") {
+			const trimmed = value.trim();
+			if (trimmed === "") candidate = void 0;
+			else {
+				const parsed = Number(trimmed);
+				if (Number.isNaN(parsed) || !Number.isFinite(parsed)) throw new Error(`"${value}" is not a valid number`);
+				candidate = parsed;
+			}
+		} else if (type === "boolean") {
+			const trimmed = value.trim().toLowerCase();
+			if (trimmed === "") candidate = void 0;
+			else if ([
+				"true",
+				"1",
+				"yes",
+				"on",
+				"enabled"
+			].includes(trimmed)) candidate = true;
+			else if ([
+				"false",
+				"0",
+				"no",
+				"off",
+				"disabled"
+			].includes(trimmed)) candidate = false;
+			else throw new Error(`"${value}" is not a valid boolean. Use: true/false, 1/0, yes/no, on/off, or enabled/disabled`);
+		} else if (value === "") candidate = void 0;
+		const [error, result] = schema.validate(candidate, { coerce: true });
+		if (error) throw new Error(error.message);
+		return result;
+	};
+}
+
+//#endregion
+//#region ../converters/src/converters.ts
+/**
+* Registry of available schema converters
+*/
+const converters = [
+	new ZodV4Converter(),
+	new ZodV3Converter(),
+	new JoiConverter(),
+	new SuperstructConverter()
+];
+
+//#endregion
+//#region ../models/src/resolve.ts
+/**
+* Resolve any supported schema to a EnvVarSchema.
+*
+* This is the main entry point for converting external schemas
+* (like Zod schemas) to envcredible's internal schema format.
+* If the input is already a EnvVarSchema, it returns it directly.
+*
+* @param schema - The schema to convert (e.g., Zod v3/v4 schema or EnvVarSchema)
+* @returns EnvVarSchema that can be used with envcredible
+* @throws Error if no converter can handle the schema
+*/
+function resolveSchema(schema) {
+	if (isEnvVarSchema(schema)) return schema;
+	for (const converter of converters) if (converter.applies(schema)) return converter.convert(schema);
+	throw new Error(`No converter found for schema. Supported types: Zod v3, Zod v4, Joi, Superstruct, EnvVarSchema. Received: ${typeof schema}`);
+}
+/**
+* Resolve mixed schema map (Zod schemas or EnvVarSchema) to pure EnvVarSchema map.
+*
+* This function takes a map where values can be:
+* - Zod v3 schemas
+* - Zod v4 schemas
+* - Already resolved EnvVarSchema instances
+*
+* And converts everything to EnvVarSchema instances that can be used throughout envcredible.
+*
+* @param schemas - Object mapping environment variable names to various schema types
+* @returns Record mapping env var names to EnvVarSchema instances
+*/
+function resolveSchemas(schemas) {
+	const resolved = {};
+	for (const [key, schema] of Object.entries(schemas)) try {
+		resolved[key] = resolveSchema(schema);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to resolve schema for environment variable "${key}": ${message}`);
+	}
+	return resolved;
+}
+
+//#endregion
+//#region ../models/src/EnvModel.ts
+/**
+* Environment variable specification container
+* Encapsulates schemas and preprocessor configuration
+*/
+var EnvModel = class {
+	/**
+	* Resolved environment variable schemas
+	*/
+	schemas;
+	/**
+	* Preprocessing configuration for environment variable types
+	*/
+	preprocess;
+	/**
+	* Create an EnvModel instance from options
+	* @param options - Specification options
+	*/
+	constructor(options) {
+		this.schemas = resolveSchemas(options.schemas);
+		this.preprocess = this.resolvePreprocessors(options.preprocess);
+	}
+	/**
+	* Resolve preprocessor configuration from options
+	* @param config - Preprocessor configuration (true, false, or partial object)
+	* @returns Resolved preprocessors object
+	*/
+	resolvePreprocessors(config) {
+		if (config === false) return {
+			string: false,
+			number: false,
+			boolean: false,
+			enum: false
+		};
+		if (config === true || config === void 0) return {};
+		return { ...config };
+	}
+};
+
+//#endregion
+//#region ../models/src/model.ts
+/**
+* Create an environment variable model
+*
+* Sugar utility for creating EnvModel instances with full type inference
+*
+* @param options - Model options
+* @returns EnvModel instance with inferred types
+*
+* @example
+* ```typescript
+* import { define, s } from "@e-n-v/models";
+*
+* export default define({
+*   schemas: {
+*     PORT: s.number({ default: 3000 }),
+*     DATABASE_URL: s.string(),
+*     DEBUG: s.boolean({ default: false })
+*   },
+*   preprocess: true
+* });
+* ```
+*/
+function define(options) {
+	return new EnvModel(options);
+}
+
+//#endregion
+export { resolveSchemas as i, EnvModel as n, resolveSchema as r, define as t };