@e-n-v/env 0.0.1 → 0.0.4

package/dist/bundle.cjs

@@ -1,1290 +0,0 @@
-const require_src = require('./src-oetJm-nZ.cjs');
-let zod = require("zod");
-zod = require_src.__toESM(zod);
-
-//#region ../files/src/source.ts
-function source(filePath) {
-	return new require_src.EnvSource(filePath);
-}
-
-//#endregion
-//#region ../core/src/schema.ts
-const schema = {
-	string: (input = {}) => new require_src.StringEnvVarSchema(input),
-	number: (input = {}) => new require_src.NumberEnvVarSchema(input),
-	boolean: (input = {}) => new require_src.BooleanEnvVarSchema(input),
-	enum: (input) => new require_src.EnumEnvVarSchema(input)
-};
-const s = schema;
-
-//#endregion
-//#region ../parse/src/errors/EnvParseError.ts
-/**
-* Error thrown when parsing environment variables fails.
-* Collects all issues so callers can inspect them without relying on subclasses.
-*/
-var EnvParseError = class EnvParseError extends Error {
-	issues;
-	partial;
-	constructor(params) {
-		const { issues, partial } = params;
-		super(EnvParseError.formatMessage(issues));
-		this.name = "EnvParseError";
-		this.issues = Object.freeze([...issues]);
-		this.partial = partial ?? {};
-	}
-	/** Number of issues encountered while parsing. */
-	get issueCount() {
-		return this.issues.length;
-	}
-	/** Keys that were missing but required. */
-	get missing() {
-		return this.issues.filter((issue) => issue.type === "missing").map((issue) => issue.key);
-	}
-	/** Keys that were present but invalid. */
-	get invalid() {
-		return this.issues.filter((issue) => issue.type === "invalid").map((issue) => issue.key);
-	}
-	/**
-	* Get all issue messages as a numbered list for easy logging.
-	*/
-	formatIssues() {
-		return this.issues.map((issue, index) => `${index + 1}. ${issue.message}`).join("\n");
-	}
-	static formatMessage(issues) {
-		if (issues.length === 0) return "Environment validation failed with no details.";
-		return [`Environment validation failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}:`, ...issues.map((issue) => {
-			if (issue.type === "missing") return `- ${issue.key}: ${issue.message}`;
-			return `- ${issue.key}: ${issue.message}`;
-		})].join("\n");
-	}
-};
-
-//#endregion
-//#region ../parse/src/parse.ts
-/**
-* Parse and validate environment variables from a source object
-* Does NOT mutate process.env
-*/
-function parse(source$1, modelOrOptions) {
-	let resolvedSchemas;
-	let preprocessConfig;
-	if (modelOrOptions instanceof require_src.EnvModel) {
-		const model = modelOrOptions;
-		resolvedSchemas = model.schemas;
-		preprocessConfig = model.preprocess;
-	} else {
-		const options = modelOrOptions;
-		resolvedSchemas = require_src.resolveSchemas(options.schemas);
-		const config = options.preprocess;
-		if (config === false) preprocessConfig = {
-			string: false,
-			number: false,
-			boolean: false,
-			enum: false
-		};
-		else if (config === true || config === void 0) preprocessConfig = {};
-		else preprocessConfig = { ...config };
-	}
-	const result = {};
-	const issues = [];
-	for (const [key, schema$1] of Object.entries(resolvedSchemas)) {
-		const rawValue = source$1[key];
-		if (rawValue === void 0 || rawValue.trim() === "") {
-			if (schema$1.default !== void 0) {
-				result[key] = schema$1.default;
-				continue;
-			}
-			if (schema$1.required) {
-				issues.push({
-					type: "missing",
-					key,
-					message: `Required environment variable "${key}" is missing`
-				});
-				result[key] = void 0;
-				continue;
-			}
-			result[key] = void 0;
-			continue;
-		}
-		const preprocessor = require_src.resolvePreprocessor(schema$1.type, preprocessConfig);
-		const preprocessedValue = preprocessor ? preprocessor(rawValue) : rawValue;
-		const stringValue = typeof preprocessedValue === "string" ? preprocessedValue : String(preprocessedValue);
-		try {
-			const processedValue = schema$1.process(stringValue);
-			if (processedValue === void 0) if (schema$1.default !== void 0) result[key] = schema$1.default;
-			else if (schema$1.required) {
-				issues.push({
-					type: "missing",
-					key,
-					message: `Required environment variable "${key}" is missing`
-				});
-				result[key] = void 0;
-			} else result[key] = void 0;
-			else result[key] = processedValue;
-		} catch (error) {
-			const message = `Environment variable "${key}" validation failed: ${error instanceof Error ? error.message : String(error)}`;
-			issues.push({
-				type: "invalid",
-				key,
-				value: rawValue,
-				message
-			});
-			result[key] = void 0;
-		}
-	}
-	if (issues.length > 0) throw new EnvParseError({
-		issues,
-		partial: { ...result }
-	});
-	return result;
-}
-
-//#endregion
-//#region ../schemas/src/helpers/createZodProcesor.ts
-/**
-* Creates a process function from a Zod schema for use with EnvVarSchema constructors.
-*
-* This helper is specifically for the @e-n-v/schemas package to create process functions
-* that can be passed to StringEnvVarSchema, NumberEnvVarSchema, etc. constructors.
-*
-* The schema itself defines the validation and type conversion logic. For environment
-* variables that need coercion from strings, use z.coerce.number() or z.coerce.boolean().
-*
-* @param schema - The Zod schema to convert
-* @returns A process function that can be used in EnvVarSchema constructors
-*
-* @example
-* ```typescript
-* // String validation
-* new StringEnvVarSchema({
-*   process: createZodProcessor(z.string().email()),
-*   description: "Email address",
-* });
-*
-* // Number with coercion
-* new NumberEnvVarSchema({
-*   process: createZodProcessor(z.coerce.number().min(0)),
-*   description: "Port number",
-* });
-*
-* // Boolean with coercion
-* new BooleanEnvVarSchema({
-*   process: createZodProcessor(z.coerce.boolean()),
-*   description: "Feature flag",
-* });
-* ```
-*/
-function createZodProcessor(schema$1) {
-	return (value) => {
-		const result = zod.z.safeParse(schema$1, value);
-		if (result.success) return result.data;
-		throw new Error(result.error.issues.map((issue) => issue.message).join("; "));
-	};
-}
-
-//#endregion
-//#region ../schemas/src/shared/messages.ts
-const COMMON_MESSAGES = { MUST_BE_VALID_URL: "Must be a valid URL" };
-
-//#endregion
-//#region ../schemas/src/shared/apiService.ts
-const descriptions$4 = {
-	apiKey: "API key for external service",
-	jwtSecret: "JWT secret key for token signing",
-	jwtAccessTokenExpiresIn: "JWT access token expiration (e.g., '15m', '1h', '1d')",
-	jwtRefreshTokenExpiresIn: "JWT refresh token expiration (e.g., '7d', '30d')",
-	apiBaseUrl: "Base URL for API service",
-	serviceUrl: "Service URL",
-	webhookUrl: "Webhook URL for receiving callbacks",
-	encryptionKey: "Encryption key for data encryption",
-	sessionSecret: "Session secret for cookie signing",
-	corsOrigin: "CORS allowed origins (comma-separated URLs or '*')",
-	rateLimitRpm: "Rate limit: requests per minute",
-	rateLimitWindow: "Rate limit window size in minutes",
-	apiTimeout: "API request timeout (milliseconds)",
-	maxFileSize: "Maximum file upload size (bytes)",
-	logLevel: "Application log level",
-	nodeEnv: "Node.js environment",
-	port: "Server port number",
-	host: "Server host address"
-};
-const messages$4 = {
-	apiKeyMin: "API key must be at least 8 characters long",
-	jwtSecretMin: "JWT secret must be at least 32 characters long for security",
-	jwtDurationFormat: "Must be in format like '15m', '1h', '7d'",
-	mustBeValidUrl: COMMON_MESSAGES.MUST_BE_VALID_URL,
-	httpProtocolRequired: "Must start with http:// or https://",
-	httpsProtocolRequired: "Webhook URLs should use HTTPS for security",
-	encryptionKeyMin: "Encryption key must be at least 32 characters long",
-	sessionSecretMin: "Session secret must be at least 32 characters long for security",
-	corsOriginInvalid: "Must be '*' or comma-separated valid URLs",
-	rateLimitRpmInt: "Rate limit must be an integer",
-	rateLimitRpmMin: "Rate limit must be at least 1",
-	rateLimitRpmMax: "Rate limit should not exceed 10,000",
-	rateLimitWindowInt: "Rate limit window must be an integer",
-	rateLimitWindowMin: "Rate limit window must be at least 1 minute",
-	rateLimitWindowMax: "Rate limit window should not exceed 60 minutes",
-	apiTimeoutInt: "Timeout must be an integer",
-	apiTimeoutMin: "Timeout must be at least 1 second",
-	apiTimeoutMax: "Timeout should not exceed 5 minutes",
-	maxFileSizeInt: "File size must be an integer",
-	maxFileSizeMin: "File size must be at least 1KB",
-	maxFileSizeMax: "File size should not exceed 1GB",
-	portInt: "Port must be an integer",
-	portMin: "Port must be >= 1024 (avoid reserved ports)",
-	portMax: "Port must be <= 65535"
-};
-const constraints$4 = {
-	apiKeyMinLength: 8,
-	jwtSecretMinLength: 32,
-	encryptionKeyMinLength: 32,
-	sessionSecretMinLength: 32,
-	rateLimitRpmMin: 1,
-	rateLimitRpmMax: 1e4,
-	rateLimitWindowMin: 1,
-	rateLimitWindowMax: 60,
-	apiTimeoutMin: 1e3,
-	apiTimeoutMax: 3e5,
-	maxFileSizeMin: 1024,
-	maxFileSizeMax: 1073741824,
-	portMin: 1024,
-	portMax: 65535
-};
-const defaults$2 = {
-	jwtAccessTokenExpiresIn: "15m",
-	jwtRefreshTokenExpiresIn: "7d",
-	rateLimitRpm: 60,
-	rateLimitWindow: 1,
-	apiTimeout: 3e4,
-	maxFileSize: 10485760,
-	logLevel: "info",
-	nodeEnv: "development",
-	port: 3e3,
-	host: "localhost"
-};
-const enumOptions = {
-	logLevel: [
-		"error",
-		"warn",
-		"info",
-		"debug",
-		"trace"
-	],
-	nodeEnv: [
-		"development",
-		"production",
-		"test",
-		"staging"
-	]
-};
-const patterns$3 = {
-	jwtTokenDuration: /^\d+[smhd]$/,
-	httpProtocol: /^https?:\/\//,
-	httpsProtocol: /^https:\/\//
-};
-
-//#endregion
-//#region ../schemas/src/plain/api.ts
-const apiKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.apiKey,
-	process: createZodProcessor(zod.z.string().min(constraints$4.apiKeyMinLength, { message: messages$4.apiKeyMin })),
-	...input
-});
-const apiBaseUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.apiBaseUrl,
-	process: createZodProcessor(zod.z.string().url({ message: "Must be a valid URL" }).refine((url) => patterns$3.httpProtocol.test(url), { message: messages$4.httpProtocolRequired })),
-	...input
-});
-const apiTimeout = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$4.apiTimeout,
-	default: defaults$2.apiTimeout,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$4.apiTimeoutInt }).min(constraints$4.apiTimeoutMin, { message: messages$4.apiTimeoutMin }).max(constraints$4.apiTimeoutMax, { message: messages$4.apiTimeoutMax })),
-	...input
-});
-const API_KEY = apiKey();
-const API_BASE_URL = apiBaseUrl();
-const API_TIMEOUT = apiTimeout();
-
-//#endregion
-//#region ../schemas/src/shared/infrastructure.ts
-const descriptions$1 = {
-	azureStorageConnectionString: "Azure Storage Account connection string",
-	azureStorageAccountName: "Azure Storage Account name",
-	azureStorageAccountKey: "Azure Storage Account key",
-	azureServiceBusConnectionString: "Azure Service Bus connection string",
-	azureEventHubConnectionString: "Azure Event Hub connection string",
-	awsSqsQueueUrl: "AWS SQS queue URL",
-	awsRegion: "AWS region",
-	awsAccessKeyId: "AWS access key ID",
-	awsSecretAccessKey: "AWS secret access key",
-	awsS3BucketName: "AWS S3 bucket name",
-	elasticsearchUrl: "Elasticsearch/OpenSearch URL",
-	elasticsearchUsername: "Elasticsearch username",
-	elasticsearchPassword: "Elasticsearch password",
-	rabbitmqUrl: "RabbitMQ connection URL",
-	kafkaBrokers: "Kafka broker list (comma-separated host:port)",
-	kafkaClientId: "Kafka client ID",
-	memcachedServers: "Memcached servers (comma-separated host:port)",
-	dockerRegistryUrl: "Docker registry URL",
-	dockerRegistryUsername: "Docker registry username",
-	dockerRegistryPassword: "Docker registry password or access token",
-	kubernetesNamespace: "Kubernetes namespace",
-	kubernetesServiceAccount: "Kubernetes service account",
-	prometheusPort: "Prometheus metrics port",
-	jaegerEndpoint: "Jaeger tracing endpoint URL",
-	newRelicLicenseKey: "New Relic license key",
-	datadogApiKey: "Datadog API key",
-	sentryDsn: "Sentry DSN for error tracking"
-};
-const messages$1 = {
-	azureStorageConnectionStringFormat: "Must be a valid Azure Storage connection string",
-	azureStorageAccountNameFormat: "Storage account name must be 3-24 characters, lowercase letters and numbers only",
-	azureStorageAccountKeyRequired: "Storage account key is required",
-	azureServiceBusConnectionStringFormat: "Must be a valid Azure Service Bus connection string",
-	azureEventHubConnectionStringFormat: "Must be a valid Azure Event Hub connection string",
-	awsSqsQueueUrlFormat: "Must be a valid AWS SQS queue URL",
-	awsRegionFormat: "Must be a valid AWS region format (e.g., us-east-1)",
-	awsAccessKeyIdMin: "AWS access key ID must be at least 16 characters",
-	awsAccessKeyIdMax: "AWS access key ID must be less than 128 characters",
-	awsSecretAccessKeyRequired: "AWS secret access key is required",
-	awsS3BucketNameFormat: "S3 bucket names must be 3-63 characters, lowercase letters, numbers, and hyphens only",
-	elasticsearchUrlFormat: COMMON_MESSAGES.MUST_BE_VALID_URL,
-	elasticsearchUrlProtocol: "Must start with http:// or https://",
-	rabbitmqUrlFormat: "Must be a valid RabbitMQ URL (amqp:// or amqps://...)",
-	hostPortListFormat: "Must be comma-separated list of host:port (e.g., localhost:9092,broker2:9092)",
-	kafkaClientIdRequired: "Kafka client ID is required",
-	dockerRegistryUrlFormat: COMMON_MESSAGES.MUST_BE_VALID_URL,
-	kubernetesNameFormat: "Must be a valid Kubernetes namespace name",
-	kubernetesServiceAccountFormat: "Must be a valid Kubernetes service account name",
-	prometheusPortInt: "Port must be an integer",
-	prometheusPortMin: "Port must be >= 1024",
-	prometheusPortMax: "Port must be <= 65535",
-	jaegerEndpointFormat: COMMON_MESSAGES.MUST_BE_VALID_URL,
-	newRelicLicenseKeyLength: "New Relic license key must be exactly 40 characters",
-	datadogApiKeyLength: "Datadog API key must be exactly 32 characters",
-	sentryDsnFormat: "Must be a valid Sentry DSN format"
-};
-const defaults$3 = {
-	kubernetesNamespace: "default",
-	prometheusPort: 9090
-};
-const constraints$3 = {
-	awsAccessKeyIdMin: 16,
-	awsAccessKeyIdMax: 128,
-	prometheusPortMin: 1024,
-	prometheusPortMax: 65535,
-	newRelicLicenseKeyLength: 40,
-	datadogApiKeyLength: 32
-};
-const patterns$1 = {
-	awsRegion: /^[a-z]{2}-[a-z]+-\d{1}$/,
-	awsS3BucketName: /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/,
-	awsSqsQueueUrl: /^https:\/\/sqs\.[^.]+\.amazonaws\.com\/\d+\/[^/]+$/,
-	azureStorageConnectionString: /^DefaultEndpointsProtocol=https;AccountName=[^;]+;AccountKey=[^;]+;EndpointSuffix=.+$/,
-	azureStorageAccountName: /^[a-z0-9]{3,24}$/,
-	azureServiceBusConnectionString: /^Endpoint=sb:\/\/[^;]+;SharedAccessKeyName=[^;]+;SharedAccessKey=.+$/,
-	azureEventHubConnectionString: /^Endpoint=sb:\/\/[^;]+;SharedAccessKeyName=[^;]+;SharedAccessKey=.+$/,
-	hostPortList: /^[a-zA-Z0-9.-]+:\d+(,[a-zA-Z0-9.-]+:\d+)*$/,
-	rabbitmqUrl: /^amqps?:\/\/(?:[^:@/]+(?::[^@/]*)?@)?[^:/]+(?::\d+)?(?:\/.*)?$/,
-	kubernetesName: /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/,
-	sentryDsn: /^https:\/\/[a-f0-9]+@[a-f0-9]+\.ingest\.sentry\.io\/\d+$/
-};
-
-//#endregion
-//#region ../schemas/src/plain/aws.ts
-const awsAccessKeyId = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.awsAccessKeyId,
-	process: createZodProcessor(zod.z.string().min(constraints$3.awsAccessKeyIdMin, { message: messages$1.awsAccessKeyIdMin }).max(constraints$3.awsAccessKeyIdMax, { message: messages$1.awsAccessKeyIdMax })),
-	secret: true,
-	...input
-});
-const awsSecretAccessKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.awsSecretAccessKey,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$1.awsSecretAccessKeyRequired })),
-	secret: true,
-	...input
-});
-const awsRegion = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.awsRegion,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.awsRegion, { message: messages$1.awsRegionFormat })),
-	...input
-});
-const awsS3BucketName = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.awsS3BucketName,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.awsS3BucketName, { message: messages$1.awsS3BucketNameFormat })),
-	...input
-});
-const awsSqsQueueUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.awsSqsQueueUrl,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.awsSqsQueueUrl, { message: messages$1.awsSqsQueueUrlFormat })),
-	...input
-});
-const AWS_ACCESS_KEY_ID = awsAccessKeyId();
-const AWS_SECRET_ACCESS_KEY = awsSecretAccessKey();
-const AWS_REGION = awsRegion();
-const AWS_S3_BUCKET_NAME = awsS3BucketName();
-const AWS_SQS_QUEUE_URL = awsSqsQueueUrl();
-const aws = {
-	AWS_ACCESS_KEY_ID,
-	AWS_SECRET_ACCESS_KEY,
-	AWS_REGION,
-	AWS_S3_BUCKET_NAME,
-	AWS_SQS_QUEUE_URL
-};
-
-//#endregion
-//#region ../schemas/src/plain/azure.ts
-const azureStorageConnectionString = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.azureStorageConnectionString,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.azureStorageConnectionString, { message: messages$1.azureStorageConnectionStringFormat })),
-	secret: true,
-	...input
-});
-const azureStorageAccountName = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.azureStorageAccountName,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.azureStorageAccountName, { message: messages$1.azureStorageAccountNameFormat })),
-	...input
-});
-const azureStorageAccountKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.azureStorageAccountKey,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$1.azureStorageAccountKeyRequired })),
-	secret: true,
-	...input
-});
-const azureServiceBusConnectionString = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.azureServiceBusConnectionString,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.azureServiceBusConnectionString, { message: messages$1.azureServiceBusConnectionStringFormat })),
-	secret: true,
-	...input
-});
-const azureEventHubConnectionString = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.azureEventHubConnectionString,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.azureEventHubConnectionString, { message: messages$1.azureEventHubConnectionStringFormat })),
-	secret: true,
-	...input
-});
-const AZURE_STORAGE_CONNECTION_STRING = azureStorageConnectionString();
-const AZURE_STORAGE_ACCOUNT_NAME = azureStorageAccountName();
-const AZURE_STORAGE_ACCOUNT_KEY = azureStorageAccountKey();
-const AZURE_SERVICE_BUS_CONNECTION_STRING = azureServiceBusConnectionString();
-const AZURE_EVENT_HUB_CONNECTION_STRING = azureEventHubConnectionString();
-const azure = {
-	AZURE_STORAGE_CONNECTION_STRING,
-	AZURE_STORAGE_ACCOUNT_NAME,
-	AZURE_STORAGE_ACCOUNT_KEY,
-	AZURE_SERVICE_BUS_CONNECTION_STRING,
-	AZURE_EVENT_HUB_CONNECTION_STRING
-};
-
-//#endregion
-//#region ../schemas/src/plain/common.ts
-const port = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$4.port,
-	default: defaults$2.port,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$4.portInt }).min(constraints$4.portMin, { message: messages$4.portMin }).max(constraints$4.portMax, { message: messages$4.portMax })),
-	...input
-});
-const PORT = port();
-
-//#endregion
-//#region ../schemas/src/plain/cors.ts
-const corsOrigin = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.corsOrigin,
-	process: createZodProcessor(zod.z.string().refine((val) => {
-		if (val === "*") return true;
-		return val.split(",").map((origin) => origin.trim()).every((origin) => {
-			try {
-				new URL(origin);
-				return true;
-			} catch {
-				return false;
-			}
-		});
-	}, { message: messages$4.corsOriginInvalid })),
-	...input
-});
-const CORS_ORIGIN = corsOrigin();
-const cors = { CORS_ORIGIN };
-
-//#endregion
-//#region ../schemas/src/shared/database.ts
-const descriptions$5 = {
-	databaseUrl: "Database connection string",
-	databaseUrlPostgresql: "PostgreSQL database connection string",
-	databaseUrlMysql: "MySQL database connection string",
-	databaseUrlMongodb: "MongoDB connection string",
-	databaseUrlSqlserver: "Microsoft SQL Server connection string",
-	redisUrl: "Redis connection string",
-	databaseHost: "Database host address",
-	databasePort: "Database port number",
-	databaseName: "Database name",
-	databaseUsername: "Database username",
-	databasePassword: "Database password",
-	databaseSchema: "Database schema name",
-	databasePoolSize: "Database connection pool size",
-	databaseTimeout: "Database connection timeout (milliseconds)",
-	databaseSsl: "Enable SSL connection to database"
-};
-const messages$5 = {
-	databaseUrlPostgresqlFormat: "Must be a valid PostgreSQL connection string (postgresql://...)",
-	databaseUrlMysqlFormat: "Must be a valid MySQL connection string (mysql://...)",
-	databaseUrlMongodbFormat: "Must be a valid MongoDB connection string (mongodb:// or mongodb+srv://...)",
-	databaseUrlSqlserverFormat: "Must be a valid SQL Server connection string (sqlserver://... or Server=...;Database=...;...)",
-	redisUrlFormat: "Must be a valid Redis connection string (redis:// or rediss://...)",
-	genericDatabaseUrlFormat: "Must be a valid database connection string with supported protocol",
-	databaseHostRequired: "Database host is required",
-	databasePortInt: "Port must be an integer",
-	databasePortMin: "Port must be greater than 0",
-	databasePortMax: "Port must be less than 65536",
-	databaseNameRequired: "Database name is required",
-	databaseNameFormat: "Database name must contain only letters, numbers, underscores, and hyphens",
-	databaseUsernameRequired: "Database username is required",
-	databasePasswordRequired: "Database password is required",
-	databaseSchemaFormat: "Schema name must contain only letters, numbers, and underscores",
-	databasePoolSizeInt: "Pool size must be an integer",
-	databasePoolSizeMin: "Pool size must be at least 1",
-	databasePoolSizeMax: "Pool size should not exceed 100",
-	databaseTimeoutInt: "Timeout must be an integer",
-	databaseTimeoutMin: "Timeout must be at least 1 second",
-	databaseTimeoutMax: "Timeout should not exceed 5 minutes"
-};
-const defaults$4 = {
-	databasePoolSize: 10,
-	databaseTimeout: 3e4,
-	databaseSsl: true
-};
-const constraints$5 = {
-	databasePortMin: 1,
-	databasePortMax: 65535,
-	databasePoolSizeMin: 1,
-	databasePoolSizeMax: 100,
-	databaseTimeoutMin: 1e3,
-	databaseTimeoutMax: 3e5
-};
-const patterns$4 = {
-	postgresUrl: /^postgresql:\/\/(?:[^:@/]+(?::[^@/]*)?@)?[^:/]+(?::\d+)?(?:\/[^?]*)?(?:\?.*)?$/,
-	mysqlUrl: /^mysql:\/\/(?:[^:@/]+(?::[^@/]*)?@)?[^:/]+(?::\d+)?(?:\/[^?]*)?(?:\?.*)?$/,
-	mongodbUrl: /^mongodb(?:\+srv)?:\/\/(?:[^:@/]+(?::[^@/]*)?@)?[^:/,]+(?::\d+)?(?:,[^:/,]+(?::\d+)?)*(?:\/[^?]*)?(?:\?.*)?$/,
-	sqlserverUrlPrefix: /^sqlserver:\/\//,
-	sqlserverServer: /Server=.+/,
-	sqlserverDatabase: /Database=.+/,
-	sqlserverInitialCatalog: /Initial Catalog=.+/,
-	redisUrl: /^rediss?:\/\/(?:[^:@/]+(?::[^@/]*)?@)?[^:/]+(?::\d+)?(?:\/\d+)?(?:\?.*)?$/,
-	genericDatabaseUrl: /^(postgresql|mysql|mongodb|mongodb\+srv|sqlserver|sqlite|oracle|redshift):\/\/.+/,
-	databaseName: /^[a-zA-Z0-9_-]+$/,
-	databaseSchema: /^[a-zA-Z0-9_]+$/
-};
-
-//#endregion
-//#region ../schemas/src/plain/database.ts
-const databaseUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databaseUrl,
-	process: createZodProcessor(zod.z.string().regex(patterns$4.genericDatabaseUrl, { message: messages$5.genericDatabaseUrlFormat })),
-	secret: true,
-	...input
-});
-const databaseHost = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databaseHost,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$5.databaseHostRequired })),
-	...input
-});
-const databasePort = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$5.databasePort,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$5.databasePortInt }).min(constraints$5.databasePortMin, { message: messages$5.databasePortMin }).max(constraints$5.databasePortMax, { message: messages$5.databasePortMax })),
-	...input
-});
-const databaseName = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databaseName,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$5.databaseNameRequired })),
-	...input
-});
-const databaseUsername = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databaseUsername,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$5.databaseUsernameRequired })),
-	...input
-});
-const databasePassword = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databasePassword,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$5.databasePasswordRequired })),
-	secret: true,
-	...input
-});
-const databaseSchema = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$5.databaseSchema,
-	process: createZodProcessor(zod.z.string()),
-	required: false,
-	...input
-});
-const databasePoolSize = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$5.databasePoolSize,
-	default: defaults$4.databasePoolSize,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$5.databasePoolSizeInt }).min(constraints$5.databasePoolSizeMin, { message: messages$5.databasePoolSizeMin }).max(constraints$5.databasePoolSizeMax, { message: messages$5.databasePoolSizeMax })),
-	...input
-});
-const databaseTimeout = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$5.databaseTimeout,
-	default: defaults$4.databaseTimeout,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$5.databaseTimeoutInt }).min(constraints$5.databaseTimeoutMin, { message: messages$5.databaseTimeoutMin }).max(constraints$5.databaseTimeoutMax, { message: messages$5.databaseTimeoutMax })),
-	...input
-});
-const databaseSsl = (input = {}) => new require_src.BooleanEnvVarSchema({
-	description: descriptions$5.databaseSsl,
-	default: defaults$4.databaseSsl,
-	...input
-});
-const DATABASE_URL = databaseUrl();
-const DATABASE_HOST = databaseHost();
-const DATABASE_PORT = databasePort();
-const DATABASE_NAME = databaseName();
-const DATABASE_USERNAME = databaseUsername();
-const DATABASE_PASSWORD = databasePassword();
-const DATABASE_SCHEMA = databaseSchema();
-const DATABASE_POOL_SIZE = databasePoolSize();
-const DATABASE_TIMEOUT = databaseTimeout();
-const DATABASE_SSL = databaseSsl();
-
-//#endregion
-//#region ../schemas/src/plain/docker.ts
-const dockerRegistryUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.dockerRegistryUrl,
-	process: createZodProcessor(zod.z.string().url({ message: messages$1.dockerRegistryUrlFormat })),
-	...input
-});
-const dockerRegistryUsername = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.dockerRegistryUsername,
-	process: createZodProcessor(zod.z.string()),
-	required: false,
-	...input
-});
-const dockerRegistryPassword = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.dockerRegistryPassword,
-	process: createZodProcessor(zod.z.string()),
-	secret: true,
-	required: false,
-	...input
-});
-const DOCKER_REGISTRY_URL = dockerRegistryUrl();
-const DOCKER_REGISTRY_USERNAME = dockerRegistryUsername();
-const DOCKER_REGISTRY_PASSWORD = dockerRegistryPassword();
-const docker = {
-	DOCKER_REGISTRY_URL,
-	DOCKER_REGISTRY_USERNAME,
-	DOCKER_REGISTRY_PASSWORD
-};
-
-//#endregion
-//#region ../schemas/src/plain/elasticsearch.ts
-const elasticsearchUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.elasticsearchUrl,
-	process: createZodProcessor(zod.z.string().url({ message: messages$1.elasticsearchUrlFormat }).regex(patterns$3.httpProtocol, { message: messages$1.elasticsearchUrlProtocol })),
-	...input
-});
-const elasticsearchUsername = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.elasticsearchUsername,
-	process: createZodProcessor(zod.z.string()),
-	required: false,
-	...input
-});
-const elasticsearchPassword = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.elasticsearchPassword,
-	process: createZodProcessor(zod.z.string()),
-	secret: true,
-	required: false,
-	...input
-});
-const ELASTICSEARCH_URL = elasticsearchUrl();
-const ELASTICSEARCH_USERNAME = elasticsearchUsername();
-const ELASTICSEARCH_PASSWORD = elasticsearchPassword();
-const elasticsearch = {
-	ELASTICSEARCH_URL,
-	ELASTICSEARCH_USERNAME,
-	ELASTICSEARCH_PASSWORD
-};
-
-//#endregion
-//#region ../schemas/src/plain/host.ts
-const host = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.host,
-	default: defaults$2.host,
-	process: createZodProcessor(zod.z.string()),
-	...input
-});
-const HOST = host();
-const hostSchema = { HOST };
-
-//#endregion
-//#region ../schemas/src/plain/jwt.ts
-const jwtSecret = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.jwtSecret,
-	process: createZodProcessor(zod.z.string().min(constraints$4.jwtSecretMinLength, { message: messages$4.jwtSecretMin })),
-	secret: true,
-	...input
-});
-const jwtAccessTokenExpiresIn = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.jwtAccessTokenExpiresIn,
-	default: defaults$2.jwtAccessTokenExpiresIn,
-	process: createZodProcessor(zod.z.string().regex(patterns$3.jwtTokenDuration, { message: messages$4.jwtDurationFormat })),
-	...input
-});
-const jwtRefreshTokenExpiresIn = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.jwtRefreshTokenExpiresIn,
-	default: defaults$2.jwtRefreshTokenExpiresIn,
-	process: createZodProcessor(zod.z.string().regex(patterns$3.jwtTokenDuration, { message: messages$4.jwtDurationFormat })),
-	...input
-});
-const JWT_SECRET = jwtSecret();
-const JWT_ACCESS_TOKEN_EXPIRES_IN = jwtAccessTokenExpiresIn();
-const JWT_REFRESH_TOKEN_EXPIRES_IN = jwtRefreshTokenExpiresIn();
-const jwt = {
-	JWT_SECRET,
-	JWT_ACCESS_TOKEN_EXPIRES_IN,
-	JWT_REFRESH_TOKEN_EXPIRES_IN
-};
-
-//#endregion
-//#region ../schemas/src/plain/kafka.ts
-const kafkaBrokers = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.kafkaBrokers,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.hostPortList, { message: messages$1.hostPortListFormat })),
-	...input
-});
-const kafkaClientId = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.kafkaClientId,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$1.kafkaClientIdRequired })),
-	...input
-});
-const KAFKA_BROKERS = kafkaBrokers();
-const KAFKA_CLIENT_ID = kafkaClientId();
-const kafka = {
-	KAFKA_BROKERS,
-	KAFKA_CLIENT_ID
-};
-
-//#endregion
-//#region ../schemas/src/plain/logLevel.ts
-const logLevel = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$4.logLevel,
-	default: defaults$2.logLevel,
-	process: createZodProcessor(zod.z.enum([...enumOptions.logLevel])),
-	...input
-});
-const LOG_LEVEL = logLevel();
-const logLevelSchema = { LOG_LEVEL };
-
-//#endregion
-//#region ../schemas/src/plain/monitoring.ts
-const newRelicLicenseKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.newRelicLicenseKey,
-	process: createZodProcessor(zod.z.string().length(constraints$3.newRelicLicenseKeyLength, { message: messages$1.newRelicLicenseKeyLength })),
-	secret: true,
-	required: false,
-	...input
-});
-const sentryDsn = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.sentryDsn,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.sentryDsn, { message: messages$1.sentryDsnFormat })),
-	secret: true,
-	required: false,
-	...input
-});
-const jaegerEndpoint = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.jaegerEndpoint,
-	process: createZodProcessor(zod.z.string().url({ message: messages$1.jaegerEndpointFormat })),
-	required: false,
-	...input
-});
-const prometheusPort = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$1.prometheusPort,
-	default: defaults$3.prometheusPort,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$1.prometheusPortInt }).min(constraints$3.prometheusPortMin, { message: messages$1.prometheusPortMin }).max(constraints$3.prometheusPortMax, { message: messages$1.prometheusPortMax })),
-	...input
-});
-const datadogApiKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.datadogApiKey,
-	process: createZodProcessor(zod.z.string().length(constraints$3.datadogApiKeyLength, { message: messages$1.datadogApiKeyLength })),
-	secret: true,
-	required: false,
-	...input
-});
-const NEW_RELIC_LICENSE_KEY = newRelicLicenseKey();
-const SENTRY_DSN = sentryDsn();
-const JAEGER_ENDPOINT = jaegerEndpoint();
-const PROMETHEUS_PORT = prometheusPort();
-const DATADOG_API_KEY = datadogApiKey();
-const monitoring = {
-	NEW_RELIC_LICENSE_KEY,
-	SENTRY_DSN,
-	JAEGER_ENDPOINT,
-	PROMETHEUS_PORT,
-	DATADOG_API_KEY
-};
-
-//#endregion
-//#region ../schemas/src/plain/node.ts
-const nodeEnv = (input = {}) => new require_src.EnumEnvVarSchema({
-	values: [...enumOptions.nodeEnv],
-	description: descriptions$4.nodeEnv,
-	default: defaults$2.nodeEnv,
-	process: createZodProcessor(zod.z.enum([...enumOptions.nodeEnv])),
-	...input
-});
-const NODE_ENV = nodeEnv();
-const node = { NODE_ENV };
-
-//#endregion
-//#region ../schemas/src/shared/oauth.ts
-const descriptions$3 = {
-	clientId: "The OAuth client ID",
-	clientSecret: "OAuth client secret",
-	redirectUri: "OAuth redirect URI",
-	scope: "OAuth scope (space-separated)"
-};
-const messages$3 = {
-	clientIdRequired: "OAuth client ID is required",
-	clientSecretMinLength: "OAuth client secret must be at least 8 characters long",
-	redirectUriInvalid: COMMON_MESSAGES.MUST_BE_VALID_URL,
-	scopeRequired: "OAuth scope is required"
-};
-const constraints$2 = {
-	clientIdMinLength: 1,
-	clientSecretMinLength: 8,
-	scopeMinLength: 1
-};
-
-//#endregion
-//#region ../schemas/src/plain/oauth.ts
-const oauthClientId = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$3.clientId,
-	process: createZodProcessor(zod.z.string().min(constraints$2.clientIdMinLength, { message: messages$3.clientIdRequired })),
-	secret: true,
-	...input
-});
-const oauthClientSecret = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$3.clientSecret,
-	process: createZodProcessor(zod.z.string().min(constraints$2.clientSecretMinLength, { message: messages$3.clientSecretMinLength })),
-	secret: true,
-	...input
-});
-const oauthRedirectUri = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$3.redirectUri,
-	process: createZodProcessor(zod.z.string().url({ message: messages$3.redirectUriInvalid })),
-	...input
-});
-const oauthScope = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$3.scope,
-	process: createZodProcessor(zod.z.string().min(constraints$2.scopeMinLength, { message: messages$3.scopeRequired })),
-	...input
-});
-const OAUTH_CLIENT_ID = oauthClientId();
-const OAUTH_CLIENT_SECRET = oauthClientSecret();
-const OAUTH_REDIRECT_URI = oauthRedirectUri();
-const OAUTH_SCOPE = oauthScope();
-const oauth = {
-	OAUTH_CLIENT_ID,
-	OAUTH_CLIENT_SECRET,
-	OAUTH_REDIRECT_URI,
-	OAUTH_SCOPE
-};
-
-//#endregion
-//#region ../schemas/src/shared/openai.ts
-const descriptions$2 = {
-	apiKey: "OpenAI API key for authenticating requests",
-	organizationId: "OpenAI organization identifier (org-...)",
-	projectId: "OpenAI project identifier (proj_...)",
-	baseUrl: "Custom base URL for OpenAI-compatible API endpoints",
-	model: "Default OpenAI model identifier to use for requests",
-	timeout: "Request timeout in seconds for OpenAI API calls"
-};
-const messages$2 = {
-	apiKeyMinLength: "OpenAI API key must be at least 40 characters",
-	apiKeyFormat: "OpenAI API key must start with 'sk-' and contain only letters and numbers",
-	organizationFormat: "OpenAI organization ID must start with 'org-'",
-	projectFormat: "OpenAI project ID must start with 'proj_'",
-	baseUrlInvalid: "OpenAI base URL must be a valid URL",
-	baseUrlProtocol: "OpenAI base URL must use https://",
-	modelRequired: "OpenAI model identifier cannot be empty",
-	timeoutInteger: "OpenAI timeout must be an integer value",
-	timeoutMin: "OpenAI timeout must be at least 1 second",
-	timeoutMax: "OpenAI timeout must be 600 seconds or less"
-};
-const constraints$1 = {
-	apiKeyMinLength: 40,
-	timeoutMin: 1,
-	timeoutMax: 600
-};
-const defaults$1 = { timeout: 30 };
-const patterns$2 = {
-	apiKey: /^sk-[A-Za-z0-9]{20,}$/,
-	organizationId: /^org-[A-Za-z0-9_-]{8,}$/,
-	projectId: /^proj_[A-Za-z0-9_-]{8,}$/
-};
-
-//#endregion
-//#region ../schemas/src/plain/openai.ts
-const openaiApiKey = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$2.apiKey,
-	process: createZodProcessor(zod.z.string().min(constraints$1.apiKeyMinLength, { message: messages$2.apiKeyMinLength }).regex(patterns$2.apiKey, { message: messages$2.apiKeyFormat })),
-	secret: true,
-	...input
-});
-const openaiOrganizationId = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$2.organizationId,
-	process: createZodProcessor(zod.z.string().regex(patterns$2.organizationId, { message: messages$2.organizationFormat })),
-	required: false,
-	...input
-});
-const openaiProjectId = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$2.projectId,
-	process: createZodProcessor(zod.z.string().regex(patterns$2.projectId, { message: messages$2.projectFormat })),
-	required: false,
-	...input
-});
-const openaiBaseUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$2.baseUrl,
-	process: createZodProcessor(zod.z.string().url({ message: messages$2.baseUrlInvalid }).refine((value) => value.startsWith("https://"), { message: messages$2.baseUrlProtocol })),
-	required: false,
-	...input
-});
-const openaiModel = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$2.model,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages$2.modelRequired })),
-	required: false,
-	...input
-});
-const openaiTimeout = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions$2.timeout,
-	default: defaults$1.timeout,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages$2.timeoutInteger }).min(constraints$1.timeoutMin, { message: messages$2.timeoutMin }).max(constraints$1.timeoutMax, { message: messages$2.timeoutMax })),
-	...input
-});
-const OPENAI_API_KEY = openaiApiKey();
-const OPENAI_ORGANIZATION_ID = openaiOrganizationId();
-const OPENAI_PROJECT_ID = openaiProjectId();
-const OPENAI_BASE_URL = openaiBaseUrl();
-const OPENAI_MODEL = openaiModel();
-const OPENAI_TIMEOUT = openaiTimeout();
-const openai = {
-	OPENAI_API_KEY,
-	OPENAI_ORGANIZATION_ID,
-	OPENAI_PROJECT_ID,
-	OPENAI_BASE_URL,
-	OPENAI_MODEL,
-	OPENAI_TIMEOUT
-};
-
-//#endregion
-//#region ../schemas/src/plain/rabbitmq.ts
-const rabbitmqUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions$1.rabbitmqUrl,
-	process: createZodProcessor(zod.z.string().regex(patterns$1.rabbitmqUrl, { message: messages$1.rabbitmqUrlFormat })),
-	secret: true,
-	...input
-});
-const RABBITMQ_URL = rabbitmqUrl();
-const rabbitmq = { RABBITMQ_URL };
-
-//#endregion
-//#region ../schemas/src/shared/redis.ts
-const descriptions = {
-	url: "Redis connection string (redis:// or rediss://)",
-	host: "Redis server host name or IP address",
-	port: "Redis server port number",
-	username: "Redis username for ACL authentication",
-	password: "Redis password or access token",
-	db: "Redis logical database index (0-15)",
-	tls: "Enable TLS for connections to Redis",
-	tlsCaCertPath: "Path to CA certificate file for Redis TLS validation"
-};
-const messages = {
-	urlFormat: "Redis URL must start with redis:// or rediss://",
-	hostRequired: "Redis host is required",
-	hostFormat: "Redis host may contain letters, numbers, dots, and hyphens",
-	portInteger: "Redis port must be an integer",
-	portMin: "Redis port must be at least 1",
-	portMax: "Redis port must be 65535 or less",
-	dbInteger: "Redis database index must be an integer",
-	dbRange: "Redis database index must be between 0 and 15",
-	usernameRequired: "Redis username cannot be empty",
-	passwordRequired: "Redis password cannot be empty",
-	tlsCaCertPathRequired: "Redis TLS CA certificate path cannot be empty"
-};
-const defaults = {
-	port: 6379,
-	db: 0,
-	tls: false
-};
-const constraints = {
-	portMin: 1,
-	portMax: 65535,
-	dbMin: 0,
-	dbMax: 15
-};
-const patterns = {
-	url: /^rediss?:\/\/(?:[^:@/\s]+(?::[^@/\s]*)?@)?[^:/\s]+(?::\d+)?(?:\/\d+)?(?:\?.*)?$/,
-	host: /^[a-zA-Z0-9.-]+$/
-};
-
-//#endregion
-//#region ../schemas/src/plain/redis.ts
-const redisUrl = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions.url,
-	process: createZodProcessor(zod.z.string().regex(patterns.url, { message: messages.urlFormat })),
-	...input
-});
-const redisHost = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions.host,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages.hostRequired }).regex(patterns.host, { message: messages.hostFormat })),
-	required: false,
-	...input
-});
-const redisPort = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions.port,
-	default: defaults.port,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages.portInteger }).min(constraints.portMin, { message: messages.portMin }).max(constraints.portMax, { message: messages.portMax })),
-	...input
-});
-const redisPassword = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions.password,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages.passwordRequired })),
-	secret: true,
-	required: false,
-	...input
-});
-const redisUsername = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions.username,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages.usernameRequired })),
-	required: false,
-	...input
-});
-const redisDb = (input = {}) => new require_src.NumberEnvVarSchema({
-	description: descriptions.db,
-	default: defaults.db,
-	process: createZodProcessor(zod.z.coerce.number().int({ message: messages.dbInteger }).min(constraints.dbMin, { message: messages.dbRange }).max(constraints.dbMax, { message: messages.dbRange })),
-	...input
-});
-const redisTls = (input = {}) => new require_src.BooleanEnvVarSchema({
-	description: descriptions.tls,
-	default: defaults.tls,
-	...input
-});
-const redisTlsCaCertPath = (input = {}) => new require_src.StringEnvVarSchema({
-	description: descriptions.tlsCaCertPath,
-	process: createZodProcessor(zod.z.string().min(1, { message: messages.tlsCaCertPathRequired })),
-	required: false,
-	...input
-});
-const REDIS_URL = redisUrl();
-const REDIS_HOST = redisHost();
-const REDIS_PORT = redisPort();
-const REDIS_PASSWORD = redisPassword();
-const REDIS_USERNAME = redisUsername();
-const REDIS_DB = redisDb();
-const REDIS_TLS = redisTls();
-const REDIS_TLS_CA_CERT_PATH = redisTlsCaCertPath();
-const redis = {
-	REDIS_URL,
-	REDIS_HOST,
-	REDIS_PORT,
-	REDIS_PASSWORD,
-	REDIS_USERNAME,
-	REDIS_DB,
-	REDIS_TLS,
-	REDIS_TLS_CA_CERT_PATH
-};
-
-//#endregion
-//#region ../schemas/src/index.ts
-var src_exports = /* @__PURE__ */ require_src.__export({
-	API_BASE_URL: () => API_BASE_URL,
-	API_KEY: () => API_KEY,
-	API_TIMEOUT: () => API_TIMEOUT,
-	AWS_ACCESS_KEY_ID: () => AWS_ACCESS_KEY_ID,
-	AWS_REGION: () => AWS_REGION,
-	AWS_S3_BUCKET_NAME: () => AWS_S3_BUCKET_NAME,
-	AWS_SECRET_ACCESS_KEY: () => AWS_SECRET_ACCESS_KEY,
-	AWS_SQS_QUEUE_URL: () => AWS_SQS_QUEUE_URL,
-	AZURE_EVENT_HUB_CONNECTION_STRING: () => AZURE_EVENT_HUB_CONNECTION_STRING,
-	AZURE_SERVICE_BUS_CONNECTION_STRING: () => AZURE_SERVICE_BUS_CONNECTION_STRING,
-	AZURE_STORAGE_ACCOUNT_KEY: () => AZURE_STORAGE_ACCOUNT_KEY,
-	AZURE_STORAGE_ACCOUNT_NAME: () => AZURE_STORAGE_ACCOUNT_NAME,
-	AZURE_STORAGE_CONNECTION_STRING: () => AZURE_STORAGE_CONNECTION_STRING,
-	CORS_ORIGIN: () => CORS_ORIGIN,
-	DATABASE_HOST: () => DATABASE_HOST,
-	DATABASE_NAME: () => DATABASE_NAME,
-	DATABASE_PASSWORD: () => DATABASE_PASSWORD,
-	DATABASE_POOL_SIZE: () => DATABASE_POOL_SIZE,
-	DATABASE_PORT: () => DATABASE_PORT,
-	DATABASE_SCHEMA: () => DATABASE_SCHEMA,
-	DATABASE_SSL: () => DATABASE_SSL,
-	DATABASE_TIMEOUT: () => DATABASE_TIMEOUT,
-	DATABASE_URL: () => DATABASE_URL,
-	DATABASE_USERNAME: () => DATABASE_USERNAME,
-	DATADOG_API_KEY: () => DATADOG_API_KEY,
-	DOCKER_REGISTRY_PASSWORD: () => DOCKER_REGISTRY_PASSWORD,
-	DOCKER_REGISTRY_URL: () => DOCKER_REGISTRY_URL,
-	DOCKER_REGISTRY_USERNAME: () => DOCKER_REGISTRY_USERNAME,
-	ELASTICSEARCH_PASSWORD: () => ELASTICSEARCH_PASSWORD,
-	ELASTICSEARCH_URL: () => ELASTICSEARCH_URL,
-	ELASTICSEARCH_USERNAME: () => ELASTICSEARCH_USERNAME,
-	HOST: () => HOST,
-	JAEGER_ENDPOINT: () => JAEGER_ENDPOINT,
-	JWT_ACCESS_TOKEN_EXPIRES_IN: () => JWT_ACCESS_TOKEN_EXPIRES_IN,
-	JWT_REFRESH_TOKEN_EXPIRES_IN: () => JWT_REFRESH_TOKEN_EXPIRES_IN,
-	JWT_SECRET: () => JWT_SECRET,
-	KAFKA_BROKERS: () => KAFKA_BROKERS,
-	KAFKA_CLIENT_ID: () => KAFKA_CLIENT_ID,
-	LOG_LEVEL: () => LOG_LEVEL,
-	NEW_RELIC_LICENSE_KEY: () => NEW_RELIC_LICENSE_KEY,
-	NODE_ENV: () => NODE_ENV,
-	OAUTH_CLIENT_ID: () => OAUTH_CLIENT_ID,
-	OAUTH_CLIENT_SECRET: () => OAUTH_CLIENT_SECRET,
-	OAUTH_REDIRECT_URI: () => OAUTH_REDIRECT_URI,
-	OAUTH_SCOPE: () => OAUTH_SCOPE,
-	OPENAI_API_KEY: () => OPENAI_API_KEY,
-	OPENAI_BASE_URL: () => OPENAI_BASE_URL,
-	OPENAI_MODEL: () => OPENAI_MODEL,
-	OPENAI_ORGANIZATION_ID: () => OPENAI_ORGANIZATION_ID,
-	OPENAI_PROJECT_ID: () => OPENAI_PROJECT_ID,
-	OPENAI_TIMEOUT: () => OPENAI_TIMEOUT,
-	PORT: () => PORT,
-	PROMETHEUS_PORT: () => PROMETHEUS_PORT,
-	RABBITMQ_URL: () => RABBITMQ_URL,
-	REDIS_DB: () => REDIS_DB,
-	REDIS_HOST: () => REDIS_HOST,
-	REDIS_PASSWORD: () => REDIS_PASSWORD,
-	REDIS_PORT: () => REDIS_PORT,
-	REDIS_TLS: () => REDIS_TLS,
-	REDIS_TLS_CA_CERT_PATH: () => REDIS_TLS_CA_CERT_PATH,
-	REDIS_URL: () => REDIS_URL,
-	REDIS_USERNAME: () => REDIS_USERNAME,
-	SENTRY_DSN: () => SENTRY_DSN,
-	apiBaseUrl: () => apiBaseUrl,
-	apiKey: () => apiKey,
-	apiTimeout: () => apiTimeout,
-	aws: () => aws,
-	awsAccessKeyId: () => awsAccessKeyId,
-	awsRegion: () => awsRegion,
-	awsS3BucketName: () => awsS3BucketName,
-	awsSecretAccessKey: () => awsSecretAccessKey,
-	awsSqsQueueUrl: () => awsSqsQueueUrl,
-	azure: () => azure,
-	azureEventHubConnectionString: () => azureEventHubConnectionString,
-	azureServiceBusConnectionString: () => azureServiceBusConnectionString,
-	azureStorageAccountKey: () => azureStorageAccountKey,
-	azureStorageAccountName: () => azureStorageAccountName,
-	azureStorageConnectionString: () => azureStorageConnectionString,
-	cors: () => cors,
-	corsOrigin: () => corsOrigin,
-	databaseHost: () => databaseHost,
-	databaseName: () => databaseName,
-	databasePassword: () => databasePassword,
-	databasePoolSize: () => databasePoolSize,
-	databasePort: () => databasePort,
-	databaseSchema: () => databaseSchema,
-	databaseSsl: () => databaseSsl,
-	databaseTimeout: () => databaseTimeout,
-	databaseUrl: () => databaseUrl,
-	databaseUsername: () => databaseUsername,
-	datadogApiKey: () => datadogApiKey,
-	docker: () => docker,
-	dockerRegistryPassword: () => dockerRegistryPassword,
-	dockerRegistryUrl: () => dockerRegistryUrl,
-	dockerRegistryUsername: () => dockerRegistryUsername,
-	elasticsearch: () => elasticsearch,
-	elasticsearchPassword: () => elasticsearchPassword,
-	elasticsearchUrl: () => elasticsearchUrl,
-	elasticsearchUsername: () => elasticsearchUsername,
-	host: () => host,
-	hostSchema: () => hostSchema,
-	jaegerEndpoint: () => jaegerEndpoint,
-	jwt: () => jwt,
-	jwtAccessTokenExpiresIn: () => jwtAccessTokenExpiresIn,
-	jwtRefreshTokenExpiresIn: () => jwtRefreshTokenExpiresIn,
-	jwtSecret: () => jwtSecret,
-	kafka: () => kafka,
-	kafkaBrokers: () => kafkaBrokers,
-	kafkaClientId: () => kafkaClientId,
-	logLevel: () => logLevel,
-	logLevelSchema: () => logLevelSchema,
-	monitoring: () => monitoring,
-	newRelicLicenseKey: () => newRelicLicenseKey,
-	node: () => node,
-	nodeEnv: () => nodeEnv,
-	oauth: () => oauth,
-	oauthClientId: () => oauthClientId,
-	oauthClientSecret: () => oauthClientSecret,
-	oauthRedirectUri: () => oauthRedirectUri,
-	oauthScope: () => oauthScope,
-	openai: () => openai,
-	openaiApiKey: () => openaiApiKey,
-	openaiBaseUrl: () => openaiBaseUrl,
-	openaiModel: () => openaiModel,
-	openaiOrganizationId: () => openaiOrganizationId,
-	openaiProjectId: () => openaiProjectId,
-	openaiTimeout: () => openaiTimeout,
-	port: () => port,
-	prometheusPort: () => prometheusPort,
-	rabbitmq: () => rabbitmq,
-	rabbitmqUrl: () => rabbitmqUrl,
-	redis: () => redis,
-	redisDb: () => redisDb,
-	redisHost: () => redisHost,
-	redisPassword: () => redisPassword,
-	redisPort: () => redisPort,
-	redisTls: () => redisTls,
-	redisTlsCaCertPath: () => redisTlsCaCertPath,
-	redisUrl: () => redisUrl,
-	redisUsername: () => redisUsername,
-	sentryDsn: () => sentryDsn
-});
-
-//#endregion
-exports.BooleanEnvVarSchema = require_src.BooleanEnvVarSchema;
-exports.DefaultEnvChannel = require_src.DefaultEnvChannel;
-exports.DotEnvChannel = require_src.DotEnvChannel;
-exports.DotEnvXChannel = require_src.DotEnvXChannel;
-exports.EnumEnvVarSchema = require_src.EnumEnvVarSchema;
-exports.EnvModel = require_src.EnvModel;
-exports.EnvParseError = EnvParseError;
-exports.EnvSource = require_src.EnvSource;
-exports.EnvVarSchemaBase = require_src.EnvVarSchemaBase;
-exports.NumberEnvVarSchema = require_src.NumberEnvVarSchema;
-exports.ProcessEnvChannel = require_src.ProcessEnvChannel;
-exports.StringEnvVarSchema = require_src.StringEnvVarSchema;
-exports.booleanPreprocessor = require_src.booleanPreprocessor;
-exports.booleanProcessor = require_src.booleanProcessor;
-Object.defineProperty(exports, 'defaults', {
-  enumerable: true,
-  get: function () {
-    return require_src.defaults_exports;
-  }
-});
-exports.define = require_src.define;
-exports.enumPreprocessor = require_src.enumPreprocessor;
-exports.enumProcessor = require_src.enumProcessor;
-exports.get = require_src.get;
-exports.isEnvVarSchema = require_src.isEnvVarSchema;
-exports.numberPreprocessor = require_src.numberPreprocessor;
-exports.numberProcessor = require_src.numberProcessor;
-exports.parse = parse;
-exports.preprocessors = require_src.preprocessors;
-exports.processors = require_src.processors;
-exports.prompt = require_src.prompt;
-exports.resolveChannel = require_src.resolveChannel;
-exports.resolvePreprocessor = require_src.resolvePreprocessor;
-exports.resolveSchema = require_src.resolveSchema;
-exports.resolveSchemas = require_src.resolveSchemas;
-exports.s = s;
-exports.schema = schema;
-Object.defineProperty(exports, 'schemas', {
-  enumerable: true,
-  get: function () {
-    return src_exports;
-  }
-});
-exports.set = require_src.set;
-exports.source = source;
-exports.stringPreprocessor = require_src.stringPreprocessor;
-exports.stringProcessor = require_src.stringProcessor;