@e-n-v/env 0.0.2 → 0.0.4

package/dist/schemas/zod.cjs

@@ -0,0 +1,629 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_chunk = require('../chunk-pbleEpgJ.cjs');
+const require_coerce = require('../coerce-b7UVodS9.cjs');
+const require_redis = require('../redis-EcC7TX3K.cjs');
+
+//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/classic/compat.js
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+const ZodIssueCode = {
+	invalid_type: "invalid_type",
+	too_big: "too_big",
+	too_small: "too_small",
+	invalid_format: "invalid_format",
+	not_multiple_of: "not_multiple_of",
+	unrecognized_keys: "unrecognized_keys",
+	invalid_union: "invalid_union",
+	invalid_key: "invalid_key",
+	invalid_element: "invalid_element",
+	invalid_value: "invalid_value",
+	custom: "custom"
+};
+/** @deprecated Use `z.config(params)` instead. */
+function setErrorMap(map$1) {
+	require_coerce.config({ customError: map$1 });
+}
+/** @deprecated Use `z.config()` instead. */
+function getErrorMap() {
+	return require_coerce.config().customError;
+}
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind$1) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+//#endregion
+//#region ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/classic/external.js
+var external_exports = /* @__PURE__ */ require_chunk.__export({
+	$brand: () => require_coerce.$brand,
+	$input: () => require_coerce.$input,
+	$output: () => require_coerce.$output,
+	NEVER: () => require_coerce.NEVER,
+	TimePrecision: () => require_coerce.TimePrecision,
+	ZodAny: () => require_coerce.ZodAny,
+	ZodArray: () => require_coerce.ZodArray,
+	ZodBase64: () => require_coerce.ZodBase64,
+	ZodBase64URL: () => require_coerce.ZodBase64URL,
+	ZodBigInt: () => require_coerce.ZodBigInt,
+	ZodBigIntFormat: () => require_coerce.ZodBigIntFormat,
+	ZodBoolean: () => require_coerce.ZodBoolean,
+	ZodCIDRv4: () => require_coerce.ZodCIDRv4,
+	ZodCIDRv6: () => require_coerce.ZodCIDRv6,
+	ZodCUID: () => require_coerce.ZodCUID,
+	ZodCUID2: () => require_coerce.ZodCUID2,
+	ZodCatch: () => require_coerce.ZodCatch,
+	ZodCodec: () => require_coerce.ZodCodec,
+	ZodCustom: () => require_coerce.ZodCustom,
+	ZodCustomStringFormat: () => require_coerce.ZodCustomStringFormat,
+	ZodDate: () => require_coerce.ZodDate,
+	ZodDefault: () => require_coerce.ZodDefault,
+	ZodDiscriminatedUnion: () => require_coerce.ZodDiscriminatedUnion,
+	ZodE164: () => require_coerce.ZodE164,
+	ZodEmail: () => require_coerce.ZodEmail,
+	ZodEmoji: () => require_coerce.ZodEmoji,
+	ZodEnum: () => require_coerce.ZodEnum,
+	ZodError: () => require_coerce.ZodError,
+	ZodFile: () => require_coerce.ZodFile,
+	ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+	ZodFunction: () => require_coerce.ZodFunction,
+	ZodGUID: () => require_coerce.ZodGUID,
+	ZodIPv4: () => require_coerce.ZodIPv4,
+	ZodIPv6: () => require_coerce.ZodIPv6,
+	ZodISODate: () => require_coerce.ZodISODate,
+	ZodISODateTime: () => require_coerce.ZodISODateTime,
+	ZodISODuration: () => require_coerce.ZodISODuration,
+	ZodISOTime: () => require_coerce.ZodISOTime,
+	ZodIntersection: () => require_coerce.ZodIntersection,
+	ZodIssueCode: () => ZodIssueCode,
+	ZodJWT: () => require_coerce.ZodJWT,
+	ZodKSUID: () => require_coerce.ZodKSUID,
+	ZodLazy: () => require_coerce.ZodLazy,
+	ZodLiteral: () => require_coerce.ZodLiteral,
+	ZodMap: () => require_coerce.ZodMap,
+	ZodNaN: () => require_coerce.ZodNaN,
+	ZodNanoID: () => require_coerce.ZodNanoID,
+	ZodNever: () => require_coerce.ZodNever,
+	ZodNonOptional: () => require_coerce.ZodNonOptional,
+	ZodNull: () => require_coerce.ZodNull,
+	ZodNullable: () => require_coerce.ZodNullable,
+	ZodNumber: () => require_coerce.ZodNumber,
+	ZodNumberFormat: () => require_coerce.ZodNumberFormat,
+	ZodObject: () => require_coerce.ZodObject,
+	ZodOptional: () => require_coerce.ZodOptional,
+	ZodPipe: () => require_coerce.ZodPipe,
+	ZodPrefault: () => require_coerce.ZodPrefault,
+	ZodPromise: () => require_coerce.ZodPromise,
+	ZodReadonly: () => require_coerce.ZodReadonly,
+	ZodRealError: () => require_coerce.ZodRealError,
+	ZodRecord: () => require_coerce.ZodRecord,
+	ZodSet: () => require_coerce.ZodSet,
+	ZodString: () => require_coerce.ZodString,
+	ZodStringFormat: () => require_coerce.ZodStringFormat,
+	ZodSuccess: () => require_coerce.ZodSuccess,
+	ZodSymbol: () => require_coerce.ZodSymbol,
+	ZodTemplateLiteral: () => require_coerce.ZodTemplateLiteral,
+	ZodTransform: () => require_coerce.ZodTransform,
+	ZodTuple: () => require_coerce.ZodTuple,
+	ZodType: () => require_coerce.ZodType,
+	ZodULID: () => require_coerce.ZodULID,
+	ZodURL: () => require_coerce.ZodURL,
+	ZodUUID: () => require_coerce.ZodUUID,
+	ZodUndefined: () => require_coerce.ZodUndefined,
+	ZodUnion: () => require_coerce.ZodUnion,
+	ZodUnknown: () => require_coerce.ZodUnknown,
+	ZodVoid: () => require_coerce.ZodVoid,
+	ZodXID: () => require_coerce.ZodXID,
+	_ZodString: () => require_coerce._ZodString,
+	_default: () => require_coerce._default,
+	_function: () => require_coerce._function,
+	any: () => require_coerce.any,
+	array: () => require_coerce.array,
+	base64: () => require_coerce.base64,
+	base64url: () => require_coerce.base64url,
+	bigint: () => require_coerce.bigint,
+	boolean: () => require_coerce.boolean,
+	catch: () => require_coerce._catch,
+	check: () => require_coerce.check,
+	cidrv4: () => require_coerce.cidrv4,
+	cidrv6: () => require_coerce.cidrv6,
+	clone: () => require_coerce.clone,
+	codec: () => require_coerce.codec,
+	coerce: () => require_coerce.coerce_exports,
+	config: () => require_coerce.config,
+	core: () => require_coerce.core_exports,
+	cuid: () => require_coerce.cuid,
+	cuid2: () => require_coerce.cuid2,
+	custom: () => require_coerce.custom,
+	date: () => require_coerce.date,
+	decode: () => require_coerce.decode,
+	decodeAsync: () => require_coerce.decodeAsync,
+	discriminatedUnion: () => require_coerce.discriminatedUnion,
+	e164: () => require_coerce.e164,
+	email: () => require_coerce.email,
+	emoji: () => require_coerce.emoji,
+	encode: () => require_coerce.encode,
+	encodeAsync: () => require_coerce.encodeAsync,
+	endsWith: () => require_coerce._endsWith,
+	enum: () => require_coerce._enum,
+	file: () => require_coerce.file,
+	flattenError: () => require_coerce.flattenError,
+	float32: () => require_coerce.float32,
+	float64: () => require_coerce.float64,
+	formatError: () => require_coerce.formatError,
+	function: () => require_coerce._function,
+	getErrorMap: () => getErrorMap,
+	globalRegistry: () => require_coerce.globalRegistry,
+	gt: () => require_coerce._gt,
+	gte: () => require_coerce._gte,
+	guid: () => require_coerce.guid,
+	hash: () => require_coerce.hash,
+	hex: () => require_coerce.hex,
+	hostname: () => require_coerce.hostname,
+	httpUrl: () => require_coerce.httpUrl,
+	includes: () => require_coerce._includes,
+	instanceof: () => require_coerce._instanceof,
+	int: () => require_coerce.int,
+	int32: () => require_coerce.int32,
+	int64: () => require_coerce.int64,
+	intersection: () => require_coerce.intersection,
+	ipv4: () => require_coerce.ipv4,
+	ipv6: () => require_coerce.ipv6,
+	iso: () => require_coerce.iso_exports,
+	json: () => require_coerce.json,
+	jwt: () => require_coerce.jwt,
+	keyof: () => require_coerce.keyof,
+	ksuid: () => require_coerce.ksuid,
+	lazy: () => require_coerce.lazy,
+	length: () => require_coerce._length,
+	literal: () => require_coerce.literal,
+	locales: () => require_coerce.locales_exports,
+	looseObject: () => require_coerce.looseObject,
+	lowercase: () => require_coerce._lowercase,
+	lt: () => require_coerce._lt,
+	lte: () => require_coerce._lte,
+	map: () => require_coerce.map,
+	maxLength: () => require_coerce._maxLength,
+	maxSize: () => require_coerce._maxSize,
+	mime: () => require_coerce._mime,
+	minLength: () => require_coerce._minLength,
+	minSize: () => require_coerce._minSize,
+	multipleOf: () => require_coerce._multipleOf,
+	nan: () => require_coerce.nan,
+	nanoid: () => require_coerce.nanoid,
+	nativeEnum: () => require_coerce.nativeEnum,
+	negative: () => require_coerce._negative,
+	never: () => require_coerce.never,
+	nonnegative: () => require_coerce._nonnegative,
+	nonoptional: () => require_coerce.nonoptional,
+	nonpositive: () => require_coerce._nonpositive,
+	normalize: () => require_coerce._normalize,
+	null: () => require_coerce._null,
+	nullable: () => require_coerce.nullable,
+	nullish: () => require_coerce.nullish,
+	number: () => require_coerce.number$1,
+	object: () => require_coerce.object,
+	optional: () => require_coerce.optional,
+	overwrite: () => require_coerce._overwrite,
+	parse: () => require_coerce.parse,
+	parseAsync: () => require_coerce.parseAsync,
+	partialRecord: () => require_coerce.partialRecord,
+	pipe: () => require_coerce.pipe,
+	positive: () => require_coerce._positive,
+	prefault: () => require_coerce.prefault,
+	preprocess: () => require_coerce.preprocess,
+	prettifyError: () => require_coerce.prettifyError,
+	promise: () => require_coerce.promise,
+	property: () => require_coerce._property,
+	readonly: () => require_coerce.readonly,
+	record: () => require_coerce.record,
+	refine: () => require_coerce.refine,
+	regex: () => require_coerce._regex,
+	regexes: () => require_coerce.regexes_exports,
+	registry: () => require_coerce.registry,
+	safeDecode: () => require_coerce.safeDecode,
+	safeDecodeAsync: () => require_coerce.safeDecodeAsync,
+	safeEncode: () => require_coerce.safeEncode,
+	safeEncodeAsync: () => require_coerce.safeEncodeAsync,
+	safeParse: () => require_coerce.safeParse,
+	safeParseAsync: () => require_coerce.safeParseAsync,
+	set: () => require_coerce.set,
+	setErrorMap: () => setErrorMap,
+	size: () => require_coerce._size,
+	startsWith: () => require_coerce._startsWith,
+	strictObject: () => require_coerce.strictObject,
+	string: () => require_coerce.string,
+	stringFormat: () => require_coerce.stringFormat,
+	stringbool: () => require_coerce.stringbool,
+	success: () => require_coerce.success,
+	superRefine: () => require_coerce.superRefine,
+	symbol: () => require_coerce.symbol,
+	templateLiteral: () => require_coerce.templateLiteral,
+	toJSONSchema: () => require_coerce.toJSONSchema,
+	toLowerCase: () => require_coerce._toLowerCase,
+	toUpperCase: () => require_coerce._toUpperCase,
+	transform: () => require_coerce.transform,
+	treeifyError: () => require_coerce.treeifyError,
+	trim: () => require_coerce._trim,
+	tuple: () => require_coerce.tuple,
+	uint32: () => require_coerce.uint32,
+	uint64: () => require_coerce.uint64,
+	ulid: () => require_coerce.ulid,
+	undefined: () => require_coerce._undefined,
+	union: () => require_coerce.union,
+	unknown: () => require_coerce.unknown,
+	uppercase: () => require_coerce._uppercase,
+	url: () => require_coerce.url,
+	util: () => require_coerce.util_exports,
+	uuid: () => require_coerce.uuid,
+	uuidv4: () => require_coerce.uuidv4,
+	uuidv6: () => require_coerce.uuidv6,
+	uuidv7: () => require_coerce.uuidv7,
+	void: () => require_coerce._void,
+	xid: () => require_coerce.xid
+});
+require_coerce.config(require_coerce.en_default());
+
+//#endregion
+//#region ../schemas/src/zod/v4/api.ts
+const apiKey = (z) => z.string().describe(require_redis.descriptions$5.apiKey).min(require_redis.constraints$5.apiKeyMinLength, { error: require_redis.messages$5.apiKeyMin });
+const apiBaseUrl = (z) => z.url().describe(require_redis.descriptions$5.apiBaseUrl).regex(require_redis.patterns$4.httpProtocol, { error: require_redis.messages$5.httpProtocolRequired });
+const apiTimeout = (z) => z.number().describe(require_redis.descriptions$5.apiTimeout).int({ error: require_redis.messages$5.apiTimeoutInt }).min(require_redis.constraints$5.apiTimeoutMin, { error: require_redis.messages$5.apiTimeoutMin }).max(require_redis.constraints$5.apiTimeoutMax, { error: require_redis.messages$5.apiTimeoutMax }).default(require_redis.defaults$4.apiTimeout);
+
+//#endregion
+//#region ../schemas/src/shared/applicationInsights.ts
+const descriptions$6 = {
+	connectionString: "Azure Application Insights connection string",
+	instrumentationKey: "Azure Application Insights instrumentation key (legacy)",
+	roleName: "Application Insights role name for distributed tracing",
+	samplingRate: "Application Insights telemetry sampling rate (0-100)",
+	autoCollectDependencies: "Enable automatic dependency tracking in Application Insights",
+	autoCollectExceptions: "Enable automatic exception tracking in Application Insights",
+	autoCollectConsole: "Enable automatic console log collection in Application Insights",
+	autoCollectPerformance: "Enable automatic performance counter collection in Application Insights"
+};
+const traits = {
+	connectionStringFormat: "a valid Application Insights connection string format",
+	instrumentationKeyUuid: "a valid UUID format for instrumentation key",
+	roleNameMin: "role name cannot be empty",
+	roleNameMax: "less than 256 characters",
+	samplingRateMin: "between 0 and 100",
+	samplingRateMax: "between 0 and 100"
+};
+const constraints$6 = {
+	roleNameMin: 1,
+	roleNameMax: 256,
+	samplingRateMin: 0,
+	samplingRateMax: 100
+};
+const defaults$5 = {
+	samplingRate: 100,
+	autoCollectDependencies: true,
+	autoCollectExceptions: true,
+	autoCollectConsole: true,
+	autoCollectPerformance: true
+};
+const patterns$5 = { connectionString: /^InstrumentationKey=[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12};IngestionEndpoint=https:\/\/[^;]+;LiveEndpoint=https:\/\/[^;]+$/ };
+const messages$6 = require_redis.toZodMessages(traits);
+
+//#endregion
+//#region ../schemas/src/zod/v4/applicationInsights.ts
+const applicationInsightsConnectionString = (z) => z.string().describe(descriptions$6.connectionString).regex(patterns$5.connectionString, { error: messages$6.connectionStringFormat });
+const appInsightsInstrumentationKey = (z) => z.uuid({ message: messages$6.instrumentationKeyUuid }).describe(descriptions$6.instrumentationKey);
+const appInsightsRoleName = (z) => z.string().describe(descriptions$6.roleName).min(constraints$6.roleNameMin, { error: messages$6.roleNameMin }).max(constraints$6.roleNameMax, { error: messages$6.roleNameMax });
+const appInsightsSamplingRate = (z) => z.number().describe(descriptions$6.samplingRate).min(constraints$6.samplingRateMin, { error: messages$6.samplingRateMin }).max(constraints$6.samplingRateMax, { error: messages$6.samplingRateMax }).default(defaults$5.samplingRate);
+const appInsightsAutocollectDependencies = (z) => z.boolean().describe(descriptions$6.autoCollectDependencies).default(defaults$5.autoCollectDependencies);
+const appInsightsAutocollectExceptions = (z) => z.boolean().describe(descriptions$6.autoCollectExceptions).default(defaults$5.autoCollectExceptions);
+const appInsightsAutocollectConsole = (z) => z.boolean().describe(descriptions$6.autoCollectConsole).default(defaults$5.autoCollectConsole);
+const appInsightsAutocollectPerformance = (z) => z.boolean().describe(descriptions$6.autoCollectPerformance).default(defaults$5.autoCollectPerformance);
+
+//#endregion
+//#region ../schemas/src/zod/v4/aws.ts
+const awsAccessKeyId = (z) => z.string().describe(require_redis.descriptions$4.awsAccessKeyId).min(require_redis.constraints$4.awsAccessKeyIdMin, { error: require_redis.messages$4.awsAccessKeyIdMin }).max(require_redis.constraints$4.awsAccessKeyIdMax, { error: require_redis.messages$4.awsAccessKeyIdMax });
+const awsSecretAccessKey = (z) => z.string().describe(require_redis.descriptions$4.awsSecretAccessKey).min(1, { error: require_redis.messages$4.awsSecretAccessKeyRequired });
+const awsRegion = (z) => z.string().describe(require_redis.descriptions$4.awsRegion).regex(require_redis.patterns$3.awsRegion, { error: require_redis.messages$4.awsRegionFormat });
+const awsS3BucketName = (z) => z.string().describe(require_redis.descriptions$4.awsS3BucketName).regex(require_redis.patterns$3.awsS3BucketName, { error: require_redis.messages$4.awsS3BucketNameFormat });
+const awsSqsQueueUrl = (z) => z.string().describe(require_redis.descriptions$4.awsSqsQueueUrl).regex(require_redis.patterns$3.awsSqsQueueUrl, { error: require_redis.messages$4.awsSqsQueueUrlFormat });
+
+//#endregion
+//#region ../schemas/src/zod/v4/azure.ts
+const azureStorageConnectionString = (z) => z.string().describe(require_redis.descriptions$4.azureStorageConnectionString).regex(require_redis.patterns$3.azureStorageConnectionString, { message: require_redis.messages$4.azureStorageConnectionStringFormat });
+const azureStorageAccountName = (z) => z.string().describe(require_redis.descriptions$4.azureStorageAccountName).regex(require_redis.patterns$3.azureStorageAccountName, { message: require_redis.messages$4.azureStorageAccountNameFormat });
+const azureStorageAccountKey = (z) => z.string().describe(require_redis.descriptions$4.azureStorageAccountKey).min(1, { message: require_redis.messages$4.azureStorageAccountKeyRequired });
+const azureServiceBusConnectionString = (z) => z.string().describe(require_redis.descriptions$4.azureServiceBusConnectionString).regex(require_redis.patterns$3.azureServiceBusConnectionString, { message: require_redis.messages$4.azureServiceBusConnectionStringFormat });
+const azureEventHubConnectionString = (z) => z.string().describe(require_redis.descriptions$4.azureEventHubConnectionString).regex(require_redis.patterns$3.azureEventHubConnectionString, { message: require_redis.messages$4.azureEventHubConnectionStringFormat });
+
+//#endregion
+//#region ../schemas/src/zod/v4/memcached.ts
+const memcachedServers = (z) => z.string().describe(require_redis.descriptions$4.memcachedServers).regex(require_redis.patterns$3.hostPortList, { message: require_redis.messages$4.hostPortListFormat });
+
+//#endregion
+//#region ../schemas/src/zod/v4/cors.ts
+const cors = (z) => z.string().describe(require_redis.descriptions$5.corsOrigin).refine((val) => {
+	if (val === "*") return true;
+	return val.split(",").map((origin) => origin.trim()).every((origin) => {
+		try {
+			new URL(origin);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}, { error: require_redis.messages$5.corsOriginInvalid });
+
+//#endregion
+//#region ../schemas/src/zod/v4/database.ts
+const databaseUrl = (z) => z.string().describe(require_redis.descriptions$3.databaseUrl).regex(require_redis.patterns$2.genericDatabaseUrl, { message: require_redis.messages$3.genericDatabaseUrlFormat });
+const databaseHost = (z) => z.string().describe(require_redis.descriptions$3.databaseHost).min(1, { message: require_redis.messages$3.databaseHostRequired });
+const databasePort = (z) => z.coerce.number().describe(require_redis.descriptions$3.databasePort).int({ message: require_redis.messages$3.databasePortInt }).min(require_redis.constraints$3.databasePortMin, { message: require_redis.messages$3.databasePortMin }).max(require_redis.constraints$3.databasePortMax, { message: require_redis.messages$3.databasePortMax });
+const databaseName = (z) => z.string().describe(require_redis.descriptions$3.databaseName).min(1, { message: require_redis.messages$3.databaseNameRequired });
+const databaseUsername = (z) => z.string().describe(require_redis.descriptions$3.databaseUsername).min(1, { message: require_redis.messages$3.databaseUsernameRequired });
+const databasePassword = (z) => z.string().describe(require_redis.descriptions$3.databasePassword).min(1, { message: require_redis.messages$3.databasePasswordRequired });
+const databaseSchema = (z) => z.string().describe(require_redis.descriptions$3.databaseSchema).optional();
+const databasePoolSize = (z) => z.coerce.number().describe(require_redis.descriptions$3.databasePoolSize).int({ message: require_redis.messages$3.databasePoolSizeInt }).min(require_redis.constraints$3.databasePoolSizeMin, { message: require_redis.messages$3.databasePoolSizeMin }).max(require_redis.constraints$3.databasePoolSizeMax, { message: require_redis.messages$3.databasePoolSizeMax }).default(require_redis.defaults$2.databasePoolSize);
+const databaseTimeout = (z) => z.coerce.number().describe(require_redis.descriptions$3.databaseTimeout).int({ message: require_redis.messages$3.databaseTimeoutInt }).min(require_redis.constraints$3.databaseTimeoutMin, { message: require_redis.messages$3.databaseTimeoutMin }).max(require_redis.constraints$3.databaseTimeoutMax, { message: require_redis.messages$3.databaseTimeoutMax }).default(require_redis.defaults$2.databaseTimeout);
+const databaseSsl = (z) => z.boolean().describe(require_redis.descriptions$3.databaseSsl).default(require_redis.defaults$2.databaseSsl);
+
+//#endregion
+//#region ../schemas/src/zod/v4/datadog.ts
+const datadogApiKey = (z) => z.string().describe(require_redis.descriptions$4.datadogApiKey).length(require_redis.constraints$4.datadogApiKeyLength, { message: require_redis.messages$4.datadogApiKeyLength }).optional();
+
+//#endregion
+//#region ../schemas/src/zod/v4/docker.ts
+const dockerRegistryUrl = (z) => z.string().url({ message: require_redis.messages$4.dockerRegistryUrlFormat }).describe(require_redis.descriptions$4.dockerRegistryUrl);
+const dockerRegistryUsername = (z) => z.string().describe(require_redis.descriptions$4.dockerRegistryUsername).optional();
+const dockerRegistryPassword = (z) => z.string().describe(require_redis.descriptions$4.dockerRegistryPassword).optional();
+
+//#endregion
+//#region ../schemas/src/zod/v4/elasticsearch.ts
+const elasticsearchUrl = (z) => z.url({ message: require_redis.messages$4.elasticsearchUrlFormat }).describe(require_redis.descriptions$4.elasticsearchUrl).regex(require_redis.patterns$4.httpProtocol, { message: require_redis.messages$4.elasticsearchUrlProtocol });
+const elasticsearchUsername = (z) => z.string().describe(require_redis.descriptions$4.elasticsearchUsername).optional();
+const elasticsearchPassword = (z) => z.string().describe(require_redis.descriptions$4.elasticsearchPassword).optional();
+
+//#endregion
+//#region ../schemas/src/zod/v4/encryptionKey.ts
+const encryptionKey = (z) => z.string().describe(require_redis.descriptions$5.encryptionKey).min(require_redis.constraints$5.encryptionKeyMinLength, { error: require_redis.messages$5.encryptionKeyMin });
+
+//#endregion
+//#region ../schemas/src/zod/v4/host.ts
+const hostSchema = (z) => z.string().describe(require_redis.descriptions$5.host).default(require_redis.defaults$4.host);
+
+//#endregion
+//#region ../schemas/src/zod/v4/jwt.ts
+const jwtSecret = (z) => z.string().describe(require_redis.descriptions$5.jwtSecret).min(require_redis.constraints$5.jwtSecretMinLength, { error: require_redis.messages$5.jwtSecretMin });
+const jwtAccessTokenExpiresIn = (z) => z.string().describe(require_redis.descriptions$5.jwtAccessTokenExpiresIn).regex(require_redis.patterns$4.jwtTokenDuration, { error: require_redis.messages$5.jwtDurationFormat }).default(require_redis.defaults$4.jwtAccessTokenExpiresIn);
+const jwtRefreshTokenExpiresIn = (z) => z.string().describe(require_redis.descriptions$5.jwtRefreshTokenExpiresIn).regex(require_redis.patterns$4.jwtTokenDuration, { error: require_redis.messages$5.jwtDurationFormat }).default(require_redis.defaults$4.jwtRefreshTokenExpiresIn);
+
+//#endregion
+//#region ../schemas/src/zod/v4/kafka.ts
+const kafkaBrokers = (z) => z.string().describe(require_redis.descriptions$4.kafkaBrokers).regex(require_redis.patterns$3.hostPortList, { message: require_redis.messages$4.hostPortListFormat });
+const kafkaClientId = (z) => z.string().describe(require_redis.descriptions$4.kafkaClientId).min(1, { message: require_redis.messages$4.kafkaClientIdRequired });
+
+//#endregion
+//#region ../schemas/src/zod/v4/kubernetes.ts
+const kubernetesNamespace = (z) => z.string().describe(require_redis.descriptions$4.kubernetesNamespace).regex(require_redis.patterns$3.kubernetesName, { message: require_redis.messages$4.kubernetesNameFormat }).default(require_redis.defaults$3.kubernetesNamespace);
+const kubernetesServiceAccount = (z) => z.string().describe(require_redis.descriptions$4.kubernetesServiceAccount).regex(require_redis.patterns$3.kubernetesName, { message: require_redis.messages$4.kubernetesServiceAccountFormat }).optional();
+
+//#endregion
+//#region ../schemas/src/zod/v4/logLevel.ts
+const logLevelSchema = (z) => z.enum([...require_redis.enumOptions.logLevel]).describe(require_redis.descriptions$5.logLevel).default(require_redis.defaults$4.logLevel);
+
+//#endregion
+//#region ../schemas/src/zod/v4/rabbitmq.ts
+const rabbitmqUrl = (z) => z.string().describe(require_redis.descriptions$4.rabbitmqUrl).regex(require_redis.patterns$3.rabbitmqUrl, { message: require_redis.messages$4.rabbitmqUrlFormat });
+
+//#endregion
+//#region ../schemas/src/zod/v4/monitoring.ts
+const newRelicLicenseKey = (z) => z.string().describe(require_redis.descriptions$4.newRelicLicenseKey).length(require_redis.constraints$4.newRelicLicenseKeyLength, { message: require_redis.messages$4.newRelicLicenseKeyLength }).optional();
+const sentryDsn = (z) => z.string().describe(require_redis.descriptions$4.sentryDsn).regex(require_redis.patterns$3.sentryDsn, { message: require_redis.messages$4.sentryDsnFormat }).optional();
+const jaegerEndpoint = (z) => z.string().url({ message: require_redis.messages$4.jaegerEndpointFormat }).describe(require_redis.descriptions$4.jaegerEndpoint).optional();
+const prometheusPort = (z) => z.number().describe(require_redis.descriptions$4.prometheusPort).int({ message: require_redis.messages$4.prometheusPortInt }).min(require_redis.constraints$4.prometheusPortMin, { message: require_redis.messages$4.prometheusPortMin }).max(require_redis.constraints$4.prometheusPortMax, { message: require_redis.messages$4.prometheusPortMax }).default(require_redis.defaults$3.prometheusPort);
+
+//#endregion
+//#region ../schemas/src/zod/v4/node.ts
+const nodeEnv = (z) => z.enum([...require_redis.enumOptions.nodeEnv]).describe(require_redis.descriptions$5.nodeEnv).default(require_redis.defaults$4.nodeEnv);
+
+//#endregion
+//#region ../schemas/src/zod/v4/oauth.ts
+const oauthClientId = (z) => z.string().describe(require_redis.descriptions$2.clientId).min(require_redis.constraints$2.clientIdMinLength, { error: require_redis.messages$2.clientIdRequired });
+const oauthClientSecret = (z) => z.string().describe(require_redis.descriptions$2.clientSecret).min(require_redis.constraints$2.clientSecretMinLength, { error: require_redis.messages$2.clientSecretMinLength });
+const oauthRedirectUri = (z) => z.url({ message: require_redis.messages$2.redirectUriInvalid }).describe(require_redis.descriptions$2.redirectUri);
+const oauthScope = (z) => z.string().describe(require_redis.descriptions$2.scope).min(require_redis.constraints$2.scopeMinLength, { error: require_redis.messages$2.scopeRequired });
+
+//#endregion
+//#region ../schemas/src/zod/v4/openai.ts
+const openaiApiKey = (z) => z.string().describe(require_redis.descriptions$1.apiKey).min(require_redis.constraints$1.apiKeyMinLength, { error: require_redis.messages$1.apiKeyMinLength }).regex(require_redis.patterns$1.apiKey, { message: require_redis.messages$1.apiKeyFormat });
+const openaiOrganizationId = (z) => z.string().describe(require_redis.descriptions$1.organizationId).regex(require_redis.patterns$1.organizationId, { message: require_redis.messages$1.organizationFormat }).optional();
+const openaiProjectId = (z) => z.string().describe(require_redis.descriptions$1.projectId).regex(require_redis.patterns$1.projectId, { message: require_redis.messages$1.projectFormat }).optional();
+const openaiBaseUrl = (z) => z.string().describe(require_redis.descriptions$1.baseUrl).url({ message: require_redis.messages$1.baseUrlInvalid }).refine((value) => value.startsWith("https://"), { message: require_redis.messages$1.baseUrlProtocol }).optional();
+const openaiModel = (z) => z.string().describe(require_redis.descriptions$1.model).min(1, { message: require_redis.messages$1.modelRequired }).optional();
+const openaiTimeout = (z) => z.number().describe(require_redis.descriptions$1.timeout).int({ message: require_redis.messages$1.timeoutInteger }).min(require_redis.constraints$1.timeoutMin, { message: require_redis.messages$1.timeoutMin }).max(require_redis.constraints$1.timeoutMax, { message: require_redis.messages$1.timeoutMax }).default(require_redis.defaults$1.timeout);
+
+//#endregion
+//#region ../schemas/src/zod/v4/redis.ts
+const redisUrl = (z) => z.string().describe(require_redis.descriptions.url).regex(require_redis.patterns.url, { message: require_redis.messages.urlFormat });
+const redisHost = (z) => z.string().describe(require_redis.descriptions.host).min(1, { message: require_redis.messages.hostRequired }).regex(require_redis.patterns.host, { message: require_redis.messages.hostFormat });
+const redisPort = (z) => z.number().describe(require_redis.descriptions.port).int({ message: require_redis.messages.portInteger }).min(require_redis.constraints.portMin, { message: require_redis.messages.portMin }).max(require_redis.constraints.portMax, { message: require_redis.messages.portMax }).default(require_redis.defaults.port);
+const redisUsername = (z) => z.string().describe(require_redis.descriptions.username).min(1, { message: require_redis.messages.usernameRequired });
+const redisPassword = (z) => z.string().describe(require_redis.descriptions.password).min(1, { message: require_redis.messages.passwordRequired });
+const redisDb = (z) => z.number().describe(require_redis.descriptions.db).int({ message: require_redis.messages.dbInteger }).min(require_redis.constraints.dbMin, { message: require_redis.messages.dbRange }).max(require_redis.constraints.dbMax, { message: require_redis.messages.dbRange }).default(require_redis.defaults.db);
+const redisTls = (z) => z.boolean().describe(require_redis.descriptions.tls).default(require_redis.defaults.tls);
+const redisTlsCaCertPath = (z) => z.string().describe(require_redis.descriptions.tlsCaCertPath).min(1, { message: require_redis.messages.tlsCaCertPathRequired });
+
+//#endregion
+//#region ../schemas/src/zod/v4/port.ts
+const port = (z) => z.coerce.number().describe(require_redis.descriptions$5.port).int({ error: require_redis.messages$5.portInt }).min(require_redis.constraints$5.portMin, { error: require_redis.messages$5.portMin }).max(require_redis.constraints$5.portMax, { error: require_redis.messages$5.portMax }).default(require_redis.defaults$4.port);
+
+//#endregion
+//#region ../schemas/src/zod/v4/rateLimit.ts
+const rateLimitRpm = (z) => z.coerce.number().describe(require_redis.descriptions$5.rateLimitRpm).int({ error: require_redis.messages$5.rateLimitRpmInt }).min(require_redis.constraints$5.rateLimitRpmMin, { error: require_redis.messages$5.rateLimitRpmMin }).max(require_redis.constraints$5.rateLimitRpmMax, { error: require_redis.messages$5.rateLimitRpmMax }).default(require_redis.defaults$4.rateLimitRpm);
+const rateLimitWindow = (z) => z.coerce.number().describe(require_redis.descriptions$5.rateLimitWindow).int({ error: require_redis.messages$5.rateLimitWindowInt }).min(require_redis.constraints$5.rateLimitWindowMin, { error: require_redis.messages$5.rateLimitWindowMin }).max(require_redis.constraints$5.rateLimitWindowMax, { error: require_redis.messages$5.rateLimitWindowMax }).default(require_redis.defaults$4.rateLimitWindow);
+
+//#endregion
+//#region ../schemas/src/zod/v4/webhook.ts
+const webhookUrl = (z) => z.url({ message: require_redis.messages$5.mustBeValidUrl }).describe(require_redis.descriptions$5.webhookUrl).regex(require_redis.patterns$4.httpsProtocol, { error: require_redis.messages$5.httpsProtocolRequired });
+
+//#endregion
+//#region ../schemas/src/zod/v4/index.ts
+var v4_default = (z) => ({
+	API_KEY: apiKey(z),
+	API_BASE_URL: apiBaseUrl(z),
+	API_TIMEOUT: apiTimeout(z),
+	APPLICATIONINSIGHTS_CONNECTION_STRING: applicationInsightsConnectionString(z),
+	APPINSIGHTS_INSTRUMENTATIONKEY: appInsightsInstrumentationKey(z),
+	APPINSIGHTS_ROLE_NAME: appInsightsRoleName(z),
+	APPINSIGHTS_SAMPLING_RATE: appInsightsSamplingRate(z),
+	APPINSIGHTS_AUTOCOLLECT_DEPENDENCIES: appInsightsAutocollectDependencies(z),
+	APPINSIGHTS_AUTOCOLLECT_EXCEPTIONS: appInsightsAutocollectExceptions(z),
+	APPINSIGHTS_AUTOCOLLECT_CONSOLE: appInsightsAutocollectConsole(z),
+	APPINSIGHTS_AUTOCOLLECT_PERFORMANCE: appInsightsAutocollectPerformance(z),
+	AWS_ACCESS_KEY_ID: awsAccessKeyId(z),
+	AWS_SECRET_ACCESS_KEY: awsSecretAccessKey(z),
+	AWS_REGION: awsRegion(z),
+	AWS_S3_BUCKET_NAME: awsS3BucketName(z),
+	AWS_SQS_QUEUE_URL: awsSqsQueueUrl(z),
+	AZURE_STORAGE_CONNECTION_STRING: azureStorageConnectionString(z),
+	AZURE_STORAGE_ACCOUNT_NAME: azureStorageAccountName(z),
+	AZURE_STORAGE_ACCOUNT_KEY: azureStorageAccountKey(z),
+	AZURE_SERVICE_BUS_CONNECTION_STRING: azureServiceBusConnectionString(z),
+	AZURE_EVENT_HUB_CONNECTION_STRING: azureEventHubConnectionString(z),
+	MEMCACHED_SERVERS: memcachedServers(z),
+	CORS_ORIGIN: cors(z),
+	DATABASE_URL: databaseUrl(z),
+	DATABASE_HOST: databaseHost(z),
+	DATABASE_PORT: databasePort(z),
+	DATABASE_NAME: databaseName(z),
+	DATABASE_USERNAME: databaseUsername(z),
+	DATABASE_PASSWORD: databasePassword(z),
+	DATABASE_SCHEMA: databaseSchema(z),
+	DATABASE_POOL_SIZE: databasePoolSize(z),
+	DATABASE_TIMEOUT: databaseTimeout(z),
+	DATABASE_SSL: databaseSsl(z),
+	DATADOG_API_KEY: datadogApiKey(z),
+	DOCKER_REGISTRY_URL: dockerRegistryUrl(z),
+	DOCKER_REGISTRY_USERNAME: dockerRegistryUsername(z),
+	DOCKER_REGISTRY_PASSWORD: dockerRegistryPassword(z),
+	ELASTICSEARCH_URL: elasticsearchUrl(z),
+	ELASTICSEARCH_USERNAME: elasticsearchUsername(z),
+	ELASTICSEARCH_PASSWORD: elasticsearchPassword(z),
+	ENCRYPTION_KEY: encryptionKey(z),
+	HOST: hostSchema(z),
+	PORT: port(z),
+	JWT_SECRET: jwtSecret(z),
+	JWT_ACCESS_TOKEN_EXPIRES_IN: jwtAccessTokenExpiresIn(z),
+	JWT_REFRESH_TOKEN_EXPIRES_IN: jwtRefreshTokenExpiresIn(z),
+	KAFKA_BROKERS: kafkaBrokers(z),
+	KAFKA_CLIENT_ID: kafkaClientId(z),
+	KUBERNETES_NAMESPACE: kubernetesNamespace(z),
+	KUBERNETES_SERVICE_ACCOUNT: kubernetesServiceAccount(z),
+	LOG_LEVEL: logLevelSchema(z),
+	RABBITMQ_URL: rabbitmqUrl(z),
+	NEW_RELIC_LICENSE_KEY: newRelicLicenseKey(z),
+	SENTRY_DSN: sentryDsn(z),
+	JAEGER_ENDPOINT: jaegerEndpoint(z),
+	PROMETHEUS_PORT: prometheusPort(z),
+	NODE_ENV: nodeEnv(z),
+	OAUTH_CLIENT_ID: oauthClientId(z),
+	OAUTH_CLIENT_SECRET: oauthClientSecret(z),
+	OAUTH_REDIRECT_URI: oauthRedirectUri(z),
+	OAUTH_SCOPE: oauthScope(z),
+	OPENAI_API_KEY: openaiApiKey(z),
+	OPENAI_ORGANIZATION_ID: openaiOrganizationId(z),
+	OPENAI_PROJECT_ID: openaiProjectId(z),
+	OPENAI_BASE_URL: openaiBaseUrl(z),
+	OPENAI_MODEL: openaiModel(z),
+	OPENAI_TIMEOUT: openaiTimeout(z),
+	REDIS_URL: redisUrl(z),
+	REDIS_HOST: redisHost(z),
+	REDIS_PORT: redisPort(z),
+	REDIS_USERNAME: redisUsername(z),
+	REDIS_PASSWORD: redisPassword(z),
+	REDIS_DB: redisDb(z),
+	REDIS_TLS: redisTls(z),
+	REDIS_TLS_CA_CERT_PATH: redisTlsCaCertPath(z),
+	RATE_LIMIT_RPM: rateLimitRpm(z),
+	RATE_LIMIT_WINDOW: rateLimitWindow(z),
+	WEBHOOK_URL: webhookUrl(z)
+});
+
+//#endregion
+//#region src/schemas/zod.ts
+var zod_default = v4_default(external_exports);
+
+//#endregion
+exports.apiBaseUrl = apiBaseUrl;
+exports.apiKey = apiKey;
+exports.apiTimeout = apiTimeout;
+exports.appInsightsAutocollectConsole = appInsightsAutocollectConsole;
+exports.appInsightsAutocollectDependencies = appInsightsAutocollectDependencies;
+exports.appInsightsAutocollectExceptions = appInsightsAutocollectExceptions;
+exports.appInsightsAutocollectPerformance = appInsightsAutocollectPerformance;
+exports.appInsightsInstrumentationKey = appInsightsInstrumentationKey;
+exports.appInsightsRoleName = appInsightsRoleName;
+exports.appInsightsSamplingRate = appInsightsSamplingRate;
+exports.applicationInsightsConnectionString = applicationInsightsConnectionString;
+exports.awsAccessKeyId = awsAccessKeyId;
+exports.awsRegion = awsRegion;
+exports.awsS3BucketName = awsS3BucketName;
+exports.awsSecretAccessKey = awsSecretAccessKey;
+exports.awsSqsQueueUrl = awsSqsQueueUrl;
+exports.azureEventHubConnectionString = azureEventHubConnectionString;
+exports.azureServiceBusConnectionString = azureServiceBusConnectionString;
+exports.azureStorageAccountKey = azureStorageAccountKey;
+exports.azureStorageAccountName = azureStorageAccountName;
+exports.azureStorageConnectionString = azureStorageConnectionString;
+exports.cors = cors;
+exports.databaseHost = databaseHost;
+exports.databaseName = databaseName;
+exports.databasePassword = databasePassword;
+exports.databasePoolSize = databasePoolSize;
+exports.databasePort = databasePort;
+exports.databaseSchema = databaseSchema;
+exports.databaseSsl = databaseSsl;
+exports.databaseTimeout = databaseTimeout;
+exports.databaseUrl = databaseUrl;
+exports.databaseUsername = databaseUsername;
+exports.datadogApiKey = datadogApiKey;
+exports.default = zod_default;
+exports.dockerRegistryPassword = dockerRegistryPassword;
+exports.dockerRegistryUrl = dockerRegistryUrl;
+exports.dockerRegistryUsername = dockerRegistryUsername;
+exports.elasticsearchPassword = elasticsearchPassword;
+exports.elasticsearchUrl = elasticsearchUrl;
+exports.elasticsearchUsername = elasticsearchUsername;
+exports.encryptionKey = encryptionKey;
+exports.hostSchema = hostSchema;
+exports.jaegerEndpoint = jaegerEndpoint;
+exports.jwtAccessTokenExpiresIn = jwtAccessTokenExpiresIn;
+exports.jwtRefreshTokenExpiresIn = jwtRefreshTokenExpiresIn;
+exports.jwtSecret = jwtSecret;
+exports.kafkaBrokers = kafkaBrokers;
+exports.kafkaClientId = kafkaClientId;
+exports.kubernetesNamespace = kubernetesNamespace;
+exports.kubernetesServiceAccount = kubernetesServiceAccount;
+exports.logLevelSchema = logLevelSchema;
+exports.memcachedServers = memcachedServers;
+exports.newRelicLicenseKey = newRelicLicenseKey;
+exports.nodeEnv = nodeEnv;
+exports.oauthClientId = oauthClientId;
+exports.oauthClientSecret = oauthClientSecret;
+exports.oauthRedirectUri = oauthRedirectUri;
+exports.oauthScope = oauthScope;
+exports.openaiApiKey = openaiApiKey;
+exports.openaiBaseUrl = openaiBaseUrl;
+exports.openaiModel = openaiModel;
+exports.openaiOrganizationId = openaiOrganizationId;
+exports.openaiProjectId = openaiProjectId;
+exports.openaiTimeout = openaiTimeout;
+exports.port = port;
+exports.prometheusPort = prometheusPort;
+exports.rabbitmqUrl = rabbitmqUrl;
+exports.rateLimitRpm = rateLimitRpm;
+exports.rateLimitWindow = rateLimitWindow;
+exports.redisDb = redisDb;
+exports.redisHost = redisHost;
+exports.redisPassword = redisPassword;
+exports.redisPort = redisPort;
+exports.redisTls = redisTls;
+exports.redisTlsCaCertPath = redisTlsCaCertPath;
+exports.redisUrl = redisUrl;
+exports.redisUsername = redisUsername;
+exports.sentryDsn = sentryDsn;
+exports.webhookUrl = webhookUrl;